Using hash table to apply command sequence with arguments

Using hash table to apply command sequence with arguments

[Heime via Users list for the GNU Emacs text editor]

How can use a hash table to execute a sequence of commands, 
possibly with arguments.  Here I am decoupling the action 
from the conditions.  Would this be a good strategy?

(defun fpln-test (actm-service)

  (let ((actm-table (make-hash-table :test 'eq)))

    ;; Put entry to actm-table
    (puthash 'armg (lambda ()
                     (alkotr-ar ar)
                     (alkotr-af af)))
              actm-table)

    ;; Put entry to actm-table
    (puthash 'go   (lambda ()
                     (require 'alkotr)
                     (alkotr-ignition gf))
             actm-table)

    ;; Map values from collection with lookup from hash table
    (mapc (lambda (actm)
            (let ((action (gethash actm actm-table)))
              (if action
                   (funcall action)
                (message "[marshal-falkotr]\n%s%s\n"
                         "  └── ACTM Unrecognised:" "'" actm))))
          actm-service)))

Re: Using hash table to apply command sequence with arguments

[Joel Reicher]

Heime via Users list for the GNU Emacs text editor 
<help-gnu-emacs@gnu.org> writes:

> How can use a hash table to execute a sequence of commands, 
> possibly with arguments.

Hash tables aren't sequences.

Regards,

        - Joel

Re: Using hash table to apply command sequence with arguments

[Jean Louis]

* Joel Reicher <joel.reicher@gmail.com> [2024-12-22 15:43]:
> Heime via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org>
> writes:
> 
> > How can use a hash table to execute a sequence of commands, possibly
> > with arguments.
> 
> Hash tables aren't sequences.

There is no statement above that hash table is sequence.

Sure! It is possible to use hash table as a database which can accept functions and their arguments, which then later need to be executed.

Though you would need to have some time of sorting, if you need the order of execution.

(setq my-hash (make-hash-table))

(puthash 'tetris nil my-hash)
(puthash 'message '("Hello there again") my-hash)

(defun my-run-sequence-of-commands-by-hash (hash)
  (let ((keys (reverse (hash-table-keys my-hash))) ;; it is questionable if there is any order with hashes
	(continue t))
    (while (and keys continue)
      (let* ((function (pop keys))
	     (args (gethash function hash)))
	(apply function args)
	(setq continue (y-or-n-p "Do you wish to continue with the function list?"))))))

(my-run-sequence-of-commands-by-hash my-hash)

I have https://gnu.support/files/emacs/packages/rcd-hash-edit.el hash
library which allows hashes to be visually edited, saved, and loaded
interactively or programmatically. That would mean that using hashes
to record which functions to execute could be made permanent and saved
on the disk, for the later execution.

Emacs Lisp package `rcd-hash-edit.el`:
https://hyperscope.link/3/7/6/6/1/Emacs-Lisp-package-rcd-hash-edit-37661.html

-- 
Jean Louis