common-lisp
Trabajando con SLIME

Instalación

Es mejor usar el último SLIME del repositorio de Emacs MELPA: los paquetes pueden ser un poco inestables, pero usted obtiene las últimas características.

Portales y multiplataforma Emacs, Slime, Quicklisp, SBCL y Git

Puede descargar una versión portátil y multiplataforma de Emacs25 ya configurada con Slime, SBCL, Quicklisp y Git: Portacle . Es una forma rápida y fácil de ponerse en marcha. Si quieres aprender a instalar todo tú mismo, sigue leyendo.

Manual de instalación

En el archivo de inicialización de GNU Emacs (> = 24.5) ( ~/.emacs o ~/.emacs.d/init.el ) agregue lo siguiente:

;; Use Emacs package system
(require 'package)
;; Add MELPA repository
(add-to-list 'package-archives
             '("melpa" . "http://melpa.milkbox.net/packages/") t)
;; Reload package list
(package-initialize)
(unless package-archive-contents
  (package-refresh-contents))
;; List of packages to install:
(setq package-list
      '(magit                    ; git interface (OPTIONAL)
        auto-complete            ; auto complete (RECOMMENDED)
        auto-complete-pcmp       ; programmable completion
        idle-highlight-mode      ; highlight words in programming buffer (OPTIONAL)
        rainbow-delimiters       ; highlight parenthesis (OPTIONAL)
        ac-slime                 ; auto-complete for SLIME
        slime                    ; SLIME itself
        eval-sexp-fu             ; Highlight evaluated form (OPTIONAL)
        smartparens              ; Help with many parentheses (OPTIONAL)
        ))

;; Install if are not installed
(dolist (package package-list)
  (unless (package-installed-p package)
    (package-install package)))

;; Parenthesis - OPTIONAL but recommended
(show-paren-mode t)
(require 'smartparens-config)
(sp-use-paredit-bindings)
(sp-pair "(" ")" :wrap "M-(")
(define-key smartparens-mode-map (kbd "C-<right>") 'sp-forward-slurp-sexp)
(define-key smartparens-mode-map (kbd "C-<left>") 'sp-backward-slurp-sexp)
(define-key smartparens-mode-map (kbd "C-S-<right>") 'sp-forward-barf-sexp)
(define-key smartparens-mode-map (kbd "C-S-<left>") 'sp-backward-barf-sexp)

(define-key smartparens-mode-map (kbd "C-)") 'sp-forward-slurp-sexp)
(define-key smartparens-mode-map (kbd "C-(") 'sp-backward-slurp-sexp)
(define-key smartparens-mode-map (kbd "C-}") 'sp-forward-barf-sexp)
(define-key smartparens-mode-map (kbd "C-{") 'sp-backward-barf-sexp)

(sp-pair "(" ")" :wrap "M-(")
(sp-pair "[" "]" :wrap "M-[")
(sp-pair "{" "}" :wrap "M-{")

;; MAIN Slime setup
;; Choose lisp implementation:
;; The first option uses roswell with default sbcl
;; the second option - uses ccl directly
(setq slime-lisp-implementations
      '((roswell ("ros" "-L" "sbcl-bin" "run"))
        (ccl ("ccl64"
              "-K" "utf-8"))))
;; Other settings...

SLIME por sí solo está bien, pero funciona mejor con el gestor de paquetes Quicklisp . Para instalar Quicklisp, siga las instrucciones del sitio web (si utiliza roswell , siga las instrucciones de roswell). Una vez instalado, en su invocación lisp:

(ql:quickload :quicklisp-slime-helper)

y agregue las siguientes líneas al archivo de inicio de Emacs:

;; Find where quicklisp is installed to
;; Add your own location if quicklisp is installed somewhere else
(defvar quicklisp-directories
  '("~/.roswell/lisp/quicklisp/"           ;; default roswell location for quicklisp
    "~/quicklisp/")                        ;; default quicklisp location
  "Possible locations of QUICKLISP")

;; Load slime-helper
(let ((continue-p t)
      (dirs quicklisp-directories))
  (while continue-p
    (cond ((null dirs) (message "Cannot find slime-helper.el"))
          ((file-directory-p (expand-file-name (car dirs)))
           (message "Loading slime-helper.el from %s" (car dirs))
           (load (expand-file-name "slime-helper.el" (car dirs)))
           (setq continue-p nil))
          (t (setq dirs (cdr dirs))))))

;; Autocomplete in SLIME
(require 'slime-autoloads)
(slime-setup '(slime-fancy))

;; (require 'ac-slime)
 (add-hook 'slime-mode-hook 'set-up-slime-ac)
 (add-hook 'slime-repl-mode-hook 'set-up-slime-ac)
 (eval-after-load "auto-complete"
   '(add-to-list 'ac-modes 'slime-repl-mode))

(eval-after-load "auto-complete"
  '(add-to-list 'ac-modes 'slime-repl-mode))

;; Hooks
(add-hook 'lisp-mode-hook (lambda ()
                            (rainbow-delimiters-mode t)
                            (smartparens-strict-mode t)
                            (idle-highlight-mode t)
                            (auto-complete-mode)))

(add-hook 'slime-mode-hook (lambda ()
                             (set-up-slime-ac)
                             (auto-complete-mode)))

(add-hook 'slime-repl-mode-hook (lambda ()
                                  (rainbow-delimiters-mode t)
                                  (smartparens-strict-mode t)
                                  (set-up-slime-ac)
                                  (auto-complete-mode)))

Después del reinicio, GNU Emacs instalará y configurará todos los paquetes necesarios.

Iniciar y finalizar SLIME, comandos REPL especiales (comas)

En Emacs Mx slime iniciará slime con la implementación predeterminada (primera) Common Lisp. Si se proporcionan múltiples implementaciones (a través de las implementaciones de slime-lisp-implementations variable), se puede acceder a otras implementaciones a través de M-- Mx slime , que ofrecerá la opción de implementaciones disponibles en mini-buffer.

Mx slime abrirá el búfer REPL que se verá como sigue:

; SLIME 2016-04-19
CL-USER> 

El búfer SLIME REPL acepta algunos comandos especiales. Todos ellos comienzan con , . Una vez , se escribe, la lista de opciones se mostrará en mini-buffer. Incluyen:

• ,quit
• ,restart-inferior-lisp
• ,pwd : imprime el directorio actual desde donde se ejecuta Lisp
• ,cd - cambiará el directorio actual

Usando REPL

CL-USER> (+ 2 3)
5
CL-USER> (sin 1.5)
0.997495
CL-USER> (mapcar (lambda (x) (+ x 2)) '(1 2 3))
(3 4 5)

El resultado que se imprime después de la evaluación no es solo una cadena: hay un objeto Lisp completo detrás que se puede inspeccionar haciendo clic derecho en él y seleccionando Inspeccionar.

La entrada multilínea también es posible: use Cj para poner una nueva línea. Enter enter hará que se evalúe el formulario ingresado y, si no se completa, es probable que cause un error:

CL-USER> (mapcar (lambda (x y)
                   (declare (ignore y))
                   (* x 2))
                 '(1 2 3)
                 '(:a :b :c))
(2 4 6)

Manejo de errores

Si la evaluación causa un error:

CL-USER> (/ 3 0)

Esto abrirá un búfer de depuración con el siguiente contenido (en SBCL lisp):

arithmetic error DIVISION-BY-ZERO signalled
Operation was /, operands (3 0).
   [Condition of type DIVISION-BY-ZERO]

Restarts:
 0: [RETRY] Retry SLIME REPL evaluation request.
 1: [*ABORT] Return to SLIME's top level.
 2: [ABORT] abort thread (#<THREAD "repl-thread" RUNNING {1004FA8033}>)

Backtrace:
  0: (SB-KERNEL::INTEGER-/-INTEGER 3 0)
  1: (/ 3 0)
  2: (SB-INT:SIMPLE-EVAL-IN-LEXENV (/ 3 0) #<NULL-LEXENV>)
  3: (EVAL (/ 3 0))
  4: (SWANK::EVAL-REGION "(/ 3 0) ..)
  5: ((LAMBDA NIL :IN SWANK-REPL::REPL-EVAL))
--- more ---

Mover el cursor hacia abajo pasado --- more --- hará que el retroceso se expanda más.

En cada línea del retroceso, al presionar Enter se mostrará más información sobre una llamada en particular (si está disponible).

Si presiona Enter en la línea de reinicios, se invocará un reinicio en particular. Alternativamente, el reinicio se puede elegir con el número 0 , 1 o 2 (presione la tecla correspondiente en cualquier lugar del búfer). El reinicio predeterminado está marcado con una estrella y se puede invocar presionando la tecla q (para "salir"). Presionando q cerrará el depurador y mostrará lo siguiente en REPL

; Evaluation aborted on #<DIVISION-BY-ZERO {10064CCE43}>.
CL-USER> 

Finalmente, muy raramente, pero Lisp puede encontrar un error que no puede ser manejado por el depurador de Lisp, en cuyo caso caerá en el depurador de bajo nivel o finalizará de manera anormal. Para ver la causa de este tipo de error, cambie al búfer *inferior-lisp* .

Configuración de un servidor SWANK sobre un túnel SSH.

1. Instale una implementación de Common Lisp en el servidor. (Por sbcl , sbcl , clisp , etc ...)
2. Instalar quicklisp en el servidor.
3. Cargue SWANK con (ql:quickload :swank)
4. Inicie el servidor con (swank:create-server) . El puerto predeterminado es 4005 .
5. [En su máquina local] Cree un túnel SSH con ssh -L4005:127.0.0.1:4005 [remote machine]
6. Conéctese al servidor swank remoto en ejecución con Mx slime-connect . El host debe ser 127.0.0.1 y el puerto 4005 .