Un dolce tutorial per Emacs / Swank / Paredit per Clojure

Mi trasferisco su Emacs per lavorare su Clojure / Lisp. Quali sono tutte le informazioni che ho bisogno di configurare su Emacs per essere in grado di fare quanto segue?

  1. abbinamento automatico / generazione delle parentesi di chiusura corrispondenti
  2. stile autoindent Lisp / Clojure, non in stile C ++ / Java
  3. Evidenziazione della syntax
  4. Richiamo di REPL
  5. Essere in grado di caricare una parte di codice dal file nel REPL e valutarla.

Sarebbe bello se potessi anche avere la lista dei comandi per ottenere queste cose dopo aver impostato su Emacs.

[Modifica da non autore: questo è del 2010 e il processo è stato notevolmente semplificato da maggio 2011. Aggiungerò un post a questa risposta con le mie note di installazione a partire da febbraio 2012.]

Dovrai mettere insieme alcuni pezzi: Emacs, SLIME (che funziona perfettamente con Clojure – vedi swank-clojure), swank-clojure (l’implementazione Clojure della controparte server di SLIME), modalità clojure, Paredit e, di Certo, il jar Clojure per cominciare, quindi forse alcuni extra tra cui Leiningen sarebbe forse il più notevole. Una volta impostato tutto, avrai – all’interno di Emacs – tutte le funzionalità di workflow / editing menzionate nella domanda.

Impostazione di base:

Di seguito sono riportati alcuni tutorial che descrivono come impostare tutto questo; c’è di più sul Web, ma alcuni degli altri sono piuttosto obsoleti, mentre questi due sembrano essere ok per ora:

  1. in cui si trovano trucchi del mestiere riguardanti l’autore di clojure post sul blog di Phil Hagelberg; Phil mantiene la modalità Clojure Swank e Clojure, così come un pacchetto chiamato Emacs Starter Kit che è qualcosa che ogni nuovo arrivato nel mondo Emacs sarebbe ben consigliato di dare un’occhiata. Queste istruzioni sembrano essere state aggiornate con le recenti modifiche all’infrastruttura; in caso di dubbio, cerca ulteriori informazioni sul gruppo Google di Clojure.

  2. Impostare post Clojure, Incanter, Emacs, Slime, Swank e Paredit sul blog del progetto Incanter. Incanter è un pacchetto affascinante che fornisce una DSL simile a R per i calcoli statistici incorporati direttamente in Clojure. Questo post sarà utile anche se non pianifichi di utilizzare – o persino di installare – Incanter.

Mettendo tutto a lavoro:

Una volta impostato tutto questo, potresti provare a iniziare a usarlo subito, ma ti consiglio vivamente di fare quanto segue:

  1. Dai un’occhiata al manuale di SLIME: è incluso nelle fonti ed è in realtà molto leggibile. Inoltre, non c’è assolutamente alcun motivo per cui dovresti leggere l’intero manuale dei mostri di 50 pagine; basta dare un’occhiata in giro per vedere quali funzionalità sono disponibili.

    Nota: la funzione di autodoc di SLIME trovata nelle più recenti fonti upstream è incompatibile con swank-clojure – questo problema non si presenterà se segui la raccomandazione di Phil Hagelberg di usare la versione ELPA (vedi il suo post sul blog di cui sopra per una spiegazione) o semplicemente lasciare l’autodoc distriggersto (che è lo stato predefinito delle cose). Quest’ultima opzione ha un ulteriore appeal in quanto è comunque ansible utilizzare l’ultima SLIME con Common Lisp, nel caso si utilizzi anche questo.

  2. Dai un’occhiata ai documenti per paredit. Ci sono due modi per farlo: (1) guarda la fonte – c’è una quantità enorme di commenti nella parte superiore del file che contengono tutte le informazioni che probabilmente ti serviranno; (2) digitare Ch m in Emacs mentre la modalità paredit è triggers – un buffer apparirà con informazioni sulla modalità principale corrente seguita da informazioni su tutte le modalità minori attive (il paredit è uno di quelli).

    Aggiornamento: ho appena trovato questo fantastico set di note su Paredit di Phil Hagelberg … Questo è un link a un file di testo, ricordo di aver visto un bel set di diapositive con queste informazioni da qualche parte, ma non riesco a trovarlo ora . Ad ogni modo, è un bel riassunto di come funziona. Sicuramente dare un’occhiata a questo, non posso vivere senza Paredit ora e questo file dovrebbe rendere molto facile iniziare a usarlo, credo. 🙂

  3. In effetti, la combinazione Ch m vi parlerà di tutti i keybindings attivi su REIME SLIME, in modalità clojure (ricorderete Cc Ck per l’invio del buffer corrente per la compilazione) e in effetti in qualsiasi buffer Emacs.

Per quanto riguarda il caricamento del codice da un file e quindi la sperimentazione con esso al REPL: utilizzare la combinazione Cc Ck sopra menzionata per compilare il buffer corrente, quindi use o require suo spazio dei nomi al REPL. Quindi, fai un esperimento.

Note finali:

Preparati a modificare le cose per un po ‘prima che facciano clic. Ci sono molti strumenti coinvolti e le loro interazioni sono per lo più abbastanza lisce, ma non al punto in cui è ragionevole presumere che non sia necessario apportare alcune modifiche inizialmente.

Infine, ecco un po ‘di codice che tengo in .emacs che non troverete altrove (sebbene sia basato su una funzione interessante di Phil Hagelberg). Ho alternato l’avvio delle istanze lein swank con lein swank (una delle caratteristiche più interessanti di Leiningen) e l’utilizzo della funzione clojure-project come di seguito riportato per avviare l’intera operazione da Emacs. Ho fatto del mio meglio per produrre un ambiente che corrisponda a quello fornito da lein swank . Oh, e se vuoi solo un REPL in Emacs per un esperimento veloce e sporco, allora con l’impostazione corretta dovresti essere in grado di usare direttamente la melma di Mx .

 (setq clojure-project-extra-classpaths '( ; "deps/" "src/" "classs/" "test/" )) (setq clojure-project-jar-classpaths '( ; "deps/" "lib/" )) (defun find-clojure-project-jars (path) (apply #'append (mapcar (lambda (d) (loop for jar in (remove-if (lambda (f) (member f '("." ".."))) (directory-files dt)) collect jar into jars finally return jars)) (remove-if-not #'file-exists-p clojure-project-jar-classpaths)))) (defun find-clojure-jar (jars) (let ((candidates (remove-if-not (lambda (jar) (string-match-p "clojure\\([0-9.-]+\\(SNAPSHOT|MASTER\\)?\\)?\\.jar$" jar)) jars))) (if candidates (car candidates) (expand-file-name "~/.clojure/clojure.jar")))) (defun find-clojure-contrib-jar (jars) (let ((candidates (remove-if-not (lambda (jar) (string-match-p "clojure-contrib\\([0-9.-]+\\(SNAPSHOT|MASTER\\)?\\)?\\.jar$" jar)) jars))) (if candidates (car candidates) (expand-file-name "~/.clojure/clojure-contrib.jar")))) ;;; original due to Phil Hagelberg ;;; (see `Best practices for Slime with Clojure' thread on Clojure Google Group) (defun clojure-project (path) "Sets up classpaths for a clojure project and starts a new SLIME session. Kills existing SLIME session, if any." (interactive (list (ido-read-directory-name "Project root:" (locate-dominating-file default-directory "pom.xml")))) (when (get-buffer "*inferior-lisp*") (kill-buffer "*inferior-lisp*")) (cd path) ;; I'm not sure if I want to mkdir; doing that would be a problem ;; if I wanted to open eg clojure or clojure-contrib as a project ;; (both lack "deps/") ; (mapcar (lambda (d) (mkdir dt)) '("deps" "src" "classs" "test")) (let* ((jars (find-clojure-project-jars path)) (clojure-jar (find-clojure-jar jars)) (clojure-contrib-jar (find-clojure-contrib-jar jars))) (setq swank-clojure-binary nil ;; swank-clojure-jar-path (expand-file-name "~/.clojure/clojure.jar") swank-clojure-jar-path clojure-jar swank-clojure-extra-classpaths (cons clojure-contrib-jar (append (mapcar (lambda (d) (expand-file-name d path)) clojure-project-extra-classpaths) (find-clojure-project-jars path))) swank-clojure-extra-vm-args (list (format "-Dclojure.compile.path=%s" (expand-file-name "classs/" path))) slime-lisp-implementations (cons `(clojure ,(swank-clojure-cmd) :init swank-clojure-init) (remove-if #'(lambda (x) (eq (car x) 'clojure)) slime-lisp-implementations)))) (slime)) 

C’è un altro tutorial eccellente:

Tra 30 e 45 minuti si può avere tutto da zero.

Il tutorial non presuppone alcuna conoscenza preliminare di Emacs (e anche Clojure – nei post precedenti c’è una bella introduzione a Clojure).

Il kit Emacs Starter ha ottenuto ottime recensioni per iniziare con Clojure:

Per rispondere solo alla parte Swank della tua domanda:

Leiningen è un modo molto semplice per configurare Swank con il classpath corretto e collegarlo ad Emacs.

Un grande video è qui: http://vimeo.com/channels/fulldisclojure#8934942 Ecco un esempio di un file project.clj che

 (defproject project "0.1" :dependencies [[org.clojure/clojure "1.1.0-master-SNAPSHOT"] [org.clojure/clojure-contrib "1.0-SNAPSHOT"]] :dev-dependencies [[leiningen/lein-swank "1.1.0"]] :main my.project.main) 

quindi eseguire:

 lein swank 

e da Emacs:

  alt-x slime-connect 

Anche Clojure con Emacs su Clojure Documentation può essere utile.