Come ricaricare un file clojure in REPL

Qual è il modo preferito di ricaricare le funzioni definite in un file Clojure senza riavviare REPL. In questo momento, per utilizzare il file aggiornato devo:

• modificare src/foo/bar.clj
• chiudere il REPL
• aprire la REPL
• (load-file "src/foo/bar.clj")
• (use 'foo.bar)

Inoltre, (use 'foo.bar :reload-all)non si ottiene l'effetto richiesto, che sta valutando i corpi modificati delle funzioni e restituendo nuovi valori, invece di comportarsi come l'origine non è cambiata affatto.

Documentazione:

• load-file
• uso

O (use 'your.namespace :reload)

Esiste anche un'alternativa come l'utilizzo di tools.namespace , è piuttosto efficiente:

user=> (use '[clojure.tools.namespace.repl :only (refresh)])

user=> (refresh)

:reloading (namespace.app)

:ok

Ricaricare il codice Clojure usando (require … :reload)ed :reload-allè molto problematico :

• Se si modificano due spazi dei nomi che dipendono l'uno dall'altro, è necessario ricordarsi di ricaricarli nell'ordine corretto per evitare errori di compilazione.

• Se si rimuovono le definizioni da un file di origine e lo si ricarica, tali definizioni sono ancora disponibili in memoria. Se altro codice dipende da tali definizioni, continuerà a funzionare ma si interromperà al successivo riavvio di JVM.

• Se lo spazio dei nomi ricaricato contiene defmulti, è inoltre necessario ricaricare tutte le defmethodespressioni associate .

• Se lo spazio dei nomi ricaricato contiene defprotocol, è inoltre necessario ricaricare tutti i record o tipi che implementano quel protocollo e sostituire eventuali istanze esistenti di tali record / tipi con nuove istanze.

• Se lo spazio dei nomi ricaricato contiene macro, è necessario ricaricare anche gli spazi dei nomi che utilizzano tali macro.

• Se il programma in esecuzione contiene funzioni che chiudono i valori nello spazio dei nomi ricaricato, tali valori chiusi non vengono aggiornati. (Questo è comune nelle applicazioni web che costruiscono lo "stack gestore" come una composizione di funzioni.)

La libreria clojure.tools.namespace migliora significativamente la situazione. Fornisce una funzione di aggiornamento facile che esegue un ricaricamento intelligente basato su un grafico delle dipendenze degli spazi dei nomi.

myapp.web=> (require '[clojure.tools.namespace.repl :refer [refresh]])
nil
myapp.web=> (refresh)
:reloading (myapp.web)
:ok

Sfortunatamente il ricaricamento una seconda volta fallirà se lo spazio dei nomi in cui si fa riferimento alla refreshfunzione è cambiato. Ciò è dovuto al fatto che tools.namespace distrugge la versione corrente dello spazio dei nomi prima di caricare il nuovo codice.

myapp.web=> (refresh)

CompilerException java.lang.RuntimeException: Unable to resolve symbol: refresh in this context, compiling:(/private/var/folders/ks/d6qbfg2s6l1bcg6ws_6bq4600000gn/T/form-init819543191440017519.clj:1:1)

È possibile utilizzare il nome var completo come soluzione alternativa per questo problema, ma personalmente preferisco non doverlo digitare ad ogni aggiornamento. Un altro problema con quanto sopra è che dopo aver ricaricato lo spazio dei nomi principale le funzioni di supporto REPL standard (come doce source) non vengono più citate lì.

Per risolvere questi problemi, preferisco creare un file sorgente effettivo per lo spazio dei nomi utente in modo che possa essere ricaricato in modo affidabile. Ho inserito il file sorgente ~/.lein/src/user.cljma puoi inserirlo ovunque. Il file dovrebbe richiedere la funzione di aggiornamento nella dichiarazione ns in alto in questo modo:

(ns user
  (:require [clojure.tools.namespace.repl :refer [refresh]]))

È possibile impostare un profilo utente leiningen in ~/.lein/profiles.cljmodo che la posizione in cui è stato inserito il file sia aggiunta al percorso della classe. Il profilo dovrebbe assomigliare a questo:

{:user {:dependencies [[org.clojure/tools.namespace "0.2.7"]]
        :repl-options { :init-ns user }
        :source-paths ["/Users/me/.lein/src"]}}

Si noti che ho impostato lo spazio dei nomi utente come punto di ingresso all'avvio di REPL. Ciò garantisce che le funzioni di supporto REPL vengano referenziate nello spazio dei nomi utente anziché nello spazio dei nomi principale dell'applicazione. In questo modo non andranno persi se non si modifica il file di origine che abbiamo appena creato.

Spero che questo ti aiuti!

La migliore risposta è:

(require 'my.namespace :reload-all)

Questo non solo ricaricherà lo spazio dei nomi specificato, ma ricaricherà anche tutti gli spazi dei nomi delle dipendenze.

Documentazione:

richiedere

Una fodera basata sulla risposta di papachan:

(clojure.tools.namespace.repl/refresh)

Lo uso in Lighttable (e nel fantastico instarepl) ma dovrebbe essere utile in altri strumenti di sviluppo. Stavo avendo lo stesso problema con vecchie definizioni di funzioni e multimetodi in giro dopo le ricariche così ora durante lo sviluppo invece di dichiarare spazi dei nomi con:

(ns my.namespace)

Dichiaro i miei spazi dei nomi in questo modo:

(clojure.core/let [s 'my.namespace]
                  (clojure.core/remove-ns s)
                  (clojure.core/in-ns s)
                  (clojure.core/require '[clojure.core])
                  (clojure.core/refer 'clojure.core))

Abbastanza brutto ma ogni volta che rivaluto l'intero spazio dei nomi (Cmd-Shift-Enter in Lighttable per ottenere i nuovi risultati instarepl di ogni espressione), cancella tutte le vecchie definizioni e mi dà un ambiente pulito. Sono stato inciampato ogni pochi giorni da vecchie definizioni prima di iniziare a fare questo e mi ha salvato la sanità mentale. :)

Prova di nuovo a caricare il file?

Se stai usando un IDE, di solito c'è una scorciatoia da tastiera per inviare un blocco di codice al REPL, ridefinendo così efficacemente le funzioni associate.

Non appena (use 'foo.bar)funziona per te, significa che hai CLASSEFATH foo / bar.clj o foo / bar_init.class. Bar_init.class sarebbe una versione compilata AOT di bar.clj. Se lo fai (use 'foo.bar), non sono esattamente sicuro che Clojure preferisca la classe al clj o viceversa. Se preferisce i file di classe e hai entrambi i file, è chiaro che la modifica del file clj e il ricaricamento dello spazio dei nomi non ha alcun effetto.

A proposito: non è necessario load-fileprima useche CLASSPATH sia impostato correttamente.

BTW2: se devi usarlo load-fileper un motivo, puoi semplicemente farlo di nuovo se hai modificato il file.