Emacs: come si memorizza l'ultimo parametro fornito dall'utente come predefinito?

Question

Sto scrivendo una funzione interattiva che mi piacerebbe ricordare l'ultimo argomento fornito dall'utente e usarlo come predefinito.

(defun run-rake (param) 
    (interactive "sTask: ") 
    (shell-command (format "rake %s" task))) 

La prima volta che viene richiamata la funzione lo voglio ricordare l'argomento l'utente ha fornito in modo che la prossima volta che invocano la funzione si può solo premere invio e utilizzerà il valore hanno fornito la volta precedente.

Non riesco a trovare questo nella documentazione - come si fa a fare questo in elisp?

Answer 1

Si può vedere come il comando compile fa questo. Visualizzare il testo della guida per il comando di compilazione con C-h f compile, spostare il cursore sul nome del file che contiene la funzione, quindi premere RETURN. Verrà visualizzato il file di origine per compile.

Fondamentalmente, c'è una variabile dinamica/globale compile-command che contiene l'ultimo comando di compilazione. Emacs è un sistema single-user a thread singolo, quindi non c'è davvero bisogno di molto altro. Ricorda inoltre che Elisp è un Lisp molto vecchio, e le variabili hanno un dynamic (stack di chiamate), non lessicale, scope. In questo tipo di sistema è naturale:

(let ((compile-command "gcc -o foo foo.c frobnicate.c")) 
    ... 
    (compile) 
    ...) 

Parlando del comando compile, hai provato ad usarlo al posto di una propria funzione run-rake?

Answer 2

Ho capito come farlo manualmente utilizzando un defvar (globale), ma questo sembra il tipo di cosa che dovrebbe essere già fornita dalla libreria di base (tipo di parametro make dello schema simile). Questo sembra proprio come più codice, e più manuale di quello che dovrebbe essere:

(defvar *editconf-ruby-run-rake-last-rake-task* nil) 

(defun editconf-ruby-run-rake-last-rake-task (&optional new-val) 
    (when new-val 
    (setf *editconf-ruby-run-rake-last-rake-task* new-val)) 
    *editconf-ruby-run-rake-last-rake-task*) 

(defun editconf-ruby-run-rake (task-name) 
    "Execute rake `task-name'. See                        
`krb-ruby-get-rakefile-path-for-current-buffer' for how the                 
Rakefile is located.." 
    (interactive 
    (let* ((rakefile (krb-ruby-get-rakefile-path-for-current-buffer)) 
      (rake-tasks (krb-ruby-get-rake-tasks rakefile)) 
      (default-task (or (editconf-ruby-run-rake-last-rake-task) 
          (editconf-ruby-run-rake-last-rake-task (car rake-tasks))))) 
    (list 
     (read-string (format "Task [%s|%s]: " 
          rake-tasks 
          default-task) 
        nil nil default-task)))) 
    (editconf-ruby-run-rake-last-rake-task task-name) 
    (let ((cmd (format "cd %s; rake %s" 
        (krb-lisp-strip-path-suffix rakefile 1) 
        task-name))) 
    (message "editconf-ruby-run-rake: cmd='%s'" cmd) 
    (shell-command cmd))) 

Answer 3

read-from-minibuffer 

è ciò che si desidera utilizzare. Ha un posto per una variabile storica.

Ecco alcuni esempi di codice:

(defvar run-rake-history nil "History for run-rake") 
(defun run-rake (cmd) 
(interactive (list (read-from-minibuffer "Task: " (car run-rake-history) nil nil 'run-rake-history))) 
    (shell-command (format "rake %s " cmd))) 

Ovviamente personalizzare le vostre esigenze. La cronologia run-rake è semplicemente una variabile che viene utilizzata per memorizzare la cronologia per questa chiamata di "read-from-minibuffer". Un'altra opzione sarebbe quella di usare 'completamento-lettura - ma questo presuppone che tu abbia una lista di scelte che vuoi limitare all'utente a usare (che di solito non è il caso per i comandi di tipo shell).