Assegnare lo stesso valore a più variabili?

A volte ho bisogno di impostare lo stesso valore su più variabili.

In Python, potrei farlo

f_loc1 = f_loc2 = "/foo/bar"

Ma in elisp, sto scrivendo

(setq f_loc1 "/foo/bar" f_loc2 "/foo/bar")

Mi chiedo se c'è un modo per raggiungere questo obiettivo usando "/foo/bar"una sola volta?

setq restituisce il valore, quindi puoi semplicemente:

(setq f-loc1 (setq f-loc2 "/foo/bar"))

Se non vuoi fare affidamento su questo, allora usa:

(setq f-loc1 "/foo/bar" f-loc2 f-loc1)

Personalmente eviterei quest'ultimo e scrivo invece:

(setq f-loc1 "/foo/bar"
      f-loc2 f-loc1)

o anche

(setq f-loc1 "/foo/bar")
(setq f-loc2 f-loc1)

E il primo approccio che userei solo in circostanze piuttosto speciali in cui enfatizza effettivamente l'intenzione o quando l'alternativa sarebbe usare il secondo approccio o altro progn.

Puoi smettere di leggere qui se quanto sopra ti rende felice. Ma penso che sia una buona opportunità per avvisare te e gli altri di non abusare delle macro.

Infine, mentre è allettante scrivere una macro come setq-every"perché è lisp e possiamo", raccomanderei caldamente di non farlo. Guadagni molto poco facendolo:

(setq-every value a b)
   vs
(setq a (setq b value))

Ma allo stesso tempo rendi molto più difficile per gli altri lettori leggere il codice ed essere sicuro di ciò che accade. setq-everypotrebbe essere implementato in vari modi e altri utenti (incluso un futuro tu) non possono sapere quale scegli l'autore, semplicemente guardando il codice che lo utilizza. [Inizialmente ho fatto alcuni esempi qui, ma quelli sono stati considerati sarcastici e diffidenti da qualcuno.]

Puoi affrontare quel sovraccarico mentale ogni volta che guardi setq-everyo puoi semplicemente vivere con un singolo personaggio in più. (Almeno nel caso in cui devi impostare solo due variabili, ma non ricordo che ho mai dovuto impostare più di due variabili allo stesso valore contemporaneamente. Se devi farlo, allora probabilmente c'è qualcos'altro che non va con il tuo codice.)

D'altra parte, se hai intenzione di utilizzare questa macro più di una mezza dozzina di volte, allora vale la pena indirizzarla. Ad esempio, utilizzo macro come --when-letdalla dash.ellibreria. Ciò rende più difficile per coloro che lo incontrano per la prima volta nel mio codice, ma superare la difficoltà di comprensione vale la pena perché è usato più di poche volte e, almeno secondo me, rende il codice più leggibile .

Si potrebbe obiettare che lo stesso vale per setq-every, ma penso che sia molto improbabile che questa particolare macro venga utilizzata più di qualche volta. Una buona regola empirica è che quando la definizione della macro (inclusa la doc-string) aggiunge più codice di quanto rimuova l'uso della macro, allora la macro molto probabilmente è eccessiva (il contrario non è necessariamente vero).

Una macro per fare quello che vuoi

Come esercizio di una specie:

(defmacro setq-every (value &rest vars)
  "Set every variable from VARS to value VALUE."
  `(progn ,@(mapcar (lambda (x) (list 'setq x value)) vars)))

Ora provalo:

(setq-every "/foo/bar" f-loc1 f-loc2)

Come funziona

Dato che le persone sono curiose di sapere come funziona (secondo i commenti), ecco una spiegazione. Per imparare davvero a scrivere macro scegli un buon libro Common Lisp (sì, Common Lisp, sarai in grado di fare le stesse cose in Emacs Lisp, ma Common Lisp è un po 'più potente e ha libri migliori, IMHO).

Le macro operano su codice non elaborato. Le macro non valutano i loro argomenti (a differenza delle funzioni). Quindi abbiamo qui non valutato valuee la raccolta di vars, che per la nostra macro sono solo simboli.

prognraggruppa diverse setqforme in una. Questa cosa:

(mapcar (lambda (x) (list 'setq x value)) vars)

Genera solo un elenco di setqmoduli, usando l'esempio di OP sarà:

((setq f-loc1 "/foo/bar") (setq f-loc2 "/foo/bar"))

Vedete, il modulo è all'interno del modulo backquote ed è preceduto da una virgola ,. All'interno del modulo retroquistato, tutto viene quotato come al solito, ma la , valutazione "attiva" temporaneamente, quindi l'intero mapcarviene valutato al momento dell'espansione macro.

@Rimuove infine la parentesi esterna dall'elenco con setqs, quindi otteniamo:

(progn
  (setq f-loc1 "/foo/bar")
  (setq f-loc2 "/foo/bar"))

Le macro possono trasformare arbitrariamente il tuo codice sorgente, non è fantastico?

Un avvertimento

Ecco un piccolo avvertimento, il primo argomento verrà valutato più volte, poiché questa macro si espande essenzialmente a quanto segue:

(progn
  (setq f-loc1 "/foo/bar")
  (setq f-loc2 "/foo/bar"))

Vedi, se hai una variabile o una stringa qui va bene, ma se scrivi qualcosa del genere:

(setq-every (my-function-with-side-effects) f-loc1 f-loc2)

Quindi la tua funzione verrà chiamata più di una volta. Questo potrebbe essere indesiderabile. Ecco come risolverlo con l'aiuto di once-only(disponibile nel pacchetto MMT ):

(defmacro setq-every (value &rest vars)
  "Set every variable from VARS to value VALUE.

VALUE is only evaluated once."
  (mmt-once-only (value)
    `(progn ,@(mapcar (lambda (x) (list 'setq x value)) vars))))

E il problema è sparito.

Dal momento che è possibile utilizzare e manipolare i simboli in lisp, è possibile semplicemente scorrere su un elenco di simboli e utilizzare set.

(dolist (var '(foo bar baz)) (set var 10))

(mapc (lambda (var) (set var 10)) '(foo bar baz))

(loop for var in '(foo bar baz) do (set var 11))

(--each '(foo bar baz) (set it 10))