Een zachte tutorial voor Emacs/Swank/Paredit voor Clojure

Ik ga naar Emacs om te werken aan Clojure/Lisp.
Wat is alle informatie die ik nodig heb om op Emacs in te stellen om het volgende te kunnen doen?

1. automatisch matchen/genereren van corresponderende haakjes sluiten
2. autoindent Lisp/Clojure-stijl, niet C++/Java-stijl
3. Syntax highlighting
4. Een beroep doen op REPL
5. Om een ​​deel van de code uit een bestand in de REPL te kunnen laden en het te evalueren.

Het zou geweldig zijn als ik ook de lijst met opdrachten zou kunnen krijgen om deze dingen te krijgen nadat ik dingen op Emacs heb ingesteld.

Antwoord 1, autoriteit 100%

[Bewerken van niet-auteur: dit is uit 2010 en het proces is sinds mei 2011 aanzienlijk vereenvoudigd. Ik zal vanaf februari 2012 een bericht aan dit antwoord toevoegen met mijn opmerkingen over de instellingen]

Je moet een paar onderdelen samenstellen: Emacs, SLIME (wat perfect werkt met Clojure — zie swank-clojure), swank-clojure (de Clojure-implementatie van SLIME’s server-tegenhanger), clojure-mode, Paredit en natuurlijk de Clojure-pot om te beginnen, dan misschien wat extra’s waarvan Leiningen misschien wel de meest opvallende zou zijn. Als je alles eenmaal hebt ingesteld, heb je — binnen Emacs — alle workflow- / bewerkingsfuncties die je in de vraag noemt.

Basisconfiguratie:

Hier volgen geweldige tutorials die beschrijven hoe je dit allemaal kunt instellen; er is meer op het web, maar sommige van de andere zijn behoorlijk verouderd, terwijl deze twee voorlopig in orde lijken:

1. waarin de kneepjes van het vak met betrekking tot clojure-auteurschap te vinden zijnpost op Phil Hagelberg’s blog; Phil onderhoudt swank-clojure en clojure-modus, evenals een pakket genaamd de Emacs Starter Kit, iets dat elke nieuwkomer in de Emacs-wereld goed zou doen om naar te kijken. Deze instructies lijken te zijn bijgewerkt met recente wijzigingen in de infrastructuur; zoek in geval van twijfel naar aanvullende informatie over de Google-groep van Clojure.

2. Clojure, Incanter, Emacs, Slime, Swank instellen, en Pareditposten op de blog van het Incanter-project. Incanter is een fascinerend pakket dat een R-achtige DSL biedt voor statistische berekeningen, rechtstreeks ingebed in Clojure. Dit bericht is zelfs nuttig als je niet van plan bent om Incanter te gebruiken of zelfs maar te installeren.

Alles aan het werk zetten:

Zodra je al deze dingen hebt ingesteld, kun je proberen het meteen te gebruiken, maar ik raad je ten zeerste aan om het volgende te doen:

1. Bekijk de handleiding van SLIME — het is opgenomen in de bronnen en is eigenlijk heel leesbaar. Er is ook absoluut geen reden waarom je de hele monsterhandleiding van 50 pagina’s zou lezen; kijk maar eens rond om te zien welke functies beschikbaar zijn.

   Opmerking: de autodoc-functie van SLIME zoals gevonden in de nieuwste upstream-bronnen is niet compatibel met swank-clojure— dit probleem zal niet optreden als u de aanbeveling van Phil Hagelberg opvolgt om de ELPA-versie te gebruiken (zie zijn eerder genoemde blogpost voor uitleg) of laat autodoc gewoon uit (wat de standaard stand van zaken is). De laatste optie heeft een extra aantrekkingskracht omdat je nog steeds de nieuwste SLIME kunt gebruiken met Common Lisp, voor het geval je die ook gebruikt.

2. Bekijk de documenten voor paredit. Er zijn twee manieren om dit aan te pakken: (1) kijk naar de bron — er staat een enorme hoeveelheid opmerkingen bovenaan het bestand die alle informatie bevatten die je waarschijnlijk nodig hebt; (2) typ Ch min Emacs terwijl paredit-mode actief is — er verschijnt een buffer met informatie over de huidige hoofdmodus gevolgd door informatie over alle actieve secundaire modi (paredit is daar één van) .

   Update:ik heb zojuist deze coole set aantekeningen gevondenop Paredit door Phil Hagelberg… Dat is een link naar een tekstbestand, ik herinner me ergens een mooie set dia’s met deze informatie te hebben gezien, maar kan het nu niet meer vinden. Het is in ieder geval een mooie samenvatting van hoe het werkt. Kijk er zeker eens naar, ik kan nu niet meer zonder Paredit en dit bestand zou het volgens mij heel gemakkelijk moeten maken om het te gaan gebruiken. 🙂

3. In feite vertelt de Ch m-combinatie u over alle sneltoetsen die actief zijn bij de SLIME REPL, in clojure-modus (u zult de Cc Ckwillen onthouden kbd>voor het verzenden van de huidige buffer voor compilatie) en inderdaad in elke Emacs-buffer.

Wat betreft het laden van de code uit een bestand en er vervolgens mee experimenteren bij de REPL: gebruik de eerder genoemde combinatie Cc Ckom de huidige buffer te compileren, en useof requirezijn naamruimte op de REPL. Experimenteer vervolgens maar eens.

Laatste opmerkingen:

Wees erop voorbereid dat je een tijdje dingen moet aanpassen voordat het allemaal klikt. Er zijn veel tools bij betrokken en hun interacties zijn meestal redelijk soepel, maar niet op het punt waarop het veilig zou zijn om aan te nemen dat u in eerste instantie geen enkele aanpassingen hoeft aan te brengen.

Ten slotte is hier een stukje code dat ik bewaar in .emacsen dat je nergens anders zult vinden (hoewel het is gebaseerd op een coole functie van Phil Hagelberg). Ik wissel af tussen het starten van mijn swank-instanties met lein swank(een van de koelere functies van Leiningen) en het gebruik van de functie clojure-projectzoals hieronder te vinden is om het hele ding van binnenuit te starten Emacs. Ik heb mijn best gedaan om de laatste een omgeving te laten produceren die nauw overeenkomt met die van lein swank. Oh, en als je gewoon een REPL in Emacs wilt voor een snel en vies experiment, dan zou je met de juiste setup M-x slimedirect moeten kunnen gebruiken.

(setq clojure-project-extra-classpaths
      '(
        ; "deps/"
        "src/"
        "classes/"
        "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 d t))
                         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 e.g. clojure or clojure-contrib as a project
  ;; (both lack "deps/")
                                        ; (mapcar (lambda (d) (mkdir d t)) '("deps" "src" "classes" "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 "classes/" 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))

Antwoord 2, autoriteit 11%

Er is nog een uitstekende tutorial:

• http://www.braveclojure.com/basic-emacs/(1e deel )
• http://www.braveclojure.com/using-emacs-with-clojure /(2e deel)

In 30 tot 45 minuten kan je alles helemaal opnieuw instellen.

De tutorial veronderstelt geen voorkennis van Emacs (en ook Clojure - in eerdere berichten is er een mooie introductie tot Clojure).

Antwoord 3, autoriteit 9%

De Emacs-starterkit heeft goede recensies gekregen om aan de slag te gaan met Clojure:

Om alleen het chique deel van je vraag te beantwoorden:

Leiningen is een heel gemakkelijke manier om swank in te stellen met het juiste klassenpad en het te verbinden met Emacs.

Hier is een geweldige video: http://vimeo.com/channels/fulldisclojure#8934942
Hier is een voorbeeld van een project.clj-bestand dat

(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)

voer dan uit:

lein swank

en van Emacs:

alt-x slime-connect

Antwoord 4, autoriteit 2%

Clojure met Emacsop Clojure-documentatiekan ook nuttig zijn.

Antwoord 5

CIDER(Clojure Interactive
Development Environment) moet hier worden vermeld.

Het dekt het grootste deel van wat u zoekt. Het omvat:

• interactieve REPL
• foutopsporing
• testrun
• codenavigatie
• documentatie opzoeken
• veel meer

Naast CIDER zijn er nog enkele andere essentiële en leuke dingen
add-ons voor clojure-ontwikkeling, die ik respectievelijk zal proberen te groeperen
(en subjectief):

Benodigdheden

• smartparens– haakjes
  koppelen, manipuleren, navigeren (of
  parinferals je wilt)

• clj-refactor–-
  heeft een paar geweldige functies, zoals automatisch toevoegen/compileren van naampacten
  (het kan binnenkort in CIDER worden opgenomen)

• clojure-mode–
  font-lock, inspringing, navigatie

• bedrijf- tekstaanvulling
  framework (of kies een andere auto-completer)

• regenboogbegrenzingen–
  markeert/kleurt scheidingstekens zoals haakjes, haakjes of
  beugels volgens hun diepte

• flycheck– on-the-fly syntaxis
  extensie controleren

• flycheck-clj-kondo–
  integratie voor clj-kondo

Prettige dingen

• clojure-snippets–
  tab-uitbreidbare snelkoppelingen naar langere codebrokken

• dumb-jump– ga naar
  definities

• welke-key– wordt weergegeven
  beschikbare sneltoetsen in pop-up

• haakjes markeren–
  markeer de omringende haakjes

• crux– een verzameling van
  Belachelijk nuttige eXtensions voor Emacs

• comment-dwim-2–
  vervanging voor Emacs' ingebouwde comment-dwim

Algemene benodigdheden (voor elke taal)

• magit– git porselein in Emacs

• projectiel– project mgmt
  voor het vinden van bestanden, zoeken, enz.

• helm– incrementele voltooiing
  en selectieversmallend kader (of
  swiper)

Andere bronnen

Als je op zoek bent naar een opstelling die dit al grotendeels/al heeft gedaan
voor u werken, zijn een paar opties:

• prelude
• spacemacs