Slimv Tutorial - Part One

SLIMV stands for Superior Lisp Interaction Mode for Vim. The name comes from SLIME (Superior Lisp Interaction Mode for Emacs), as Slimv tries to provide the same functionality using Vim.

There is an excellent SLIME tutorial movie created by Marco Barringer. The present series of tutorials is trying to introduce the same concepts using Vim and the Slimv plugin through similar actions like Marco did in his 55 minutes long movie.

Downloading

The Slimv plugin can be downloaded from the project page on vim.org. There is also a public Slimv repository containing the latest development builds.

You will also need a Python enabled Vim, and the same Python version installed that is Vim compiled against. This is because the communication part of the plugin is written in Vim's embedded Python (unfortunately there is no embedded Lisp for Vim).

The script is installed the same way as any regular Vim plugin: unzip the contents of the archive in the vimfiles directory.

Configuration

Starting up

File  Edit  Tools  Syntax  Buffers  Window  Slimv  REPL  Help                   
SBCL  Port: 4005  Pid: 2920                 Edit          >
; SWANK 2012-03-06                          Evaluation    > Eval-Defun        ,d 
CL-USER>                                    Debugging     > Eval-Current-Exp  ,e 
                                            Compilation   > Eval-Region       ,r 
                                            Xref          > Eval-Buffer       ,b 
                                            Profiling     > Interactive-Eval  ,v 
Slimv.REPL.lisp^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Documentation > Undefine-Function ,u 
                                            Repl          >                     
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
morse.lisp                                                    1,0-1          All
Connected to SWANK server on port 4005.

Basic REPL operations

CL-USER> (+ 2 2)
4
CL-USER> (make-hash-table)
#<HASH-TABLE :TEST EQL :COUNT 0 {B20CE49}>

When using Paredit Mode, an editor feature called 'electric return' is also enabled by default. When pressing Enter, an extra newline is inserted, so the line just opened is an empty one. This allows easy linewise editing of sub-forms. The electric returns are then gathered upon pressing ")". Check this animation to get a hint on how it works. If you want to disable electric returns, just add let g:paredit_electric_return=0 to .vimrc.

You can type *, **, *** to get the objects returned by previous evaluations, or +, ++, +++ to get the forms previously evaluated, just like in SLIME:

CL-USER> *
#<HASH-TABLE :TEST EQL :COUNT 0 {B20CE49}>
CL-USER> *
#<HASH-TABLE :TEST EQL :COUNT 0 {B20CE49}>
CL-USER> **
#<HASH-TABLE :TEST EQL :COUNT 0 {B20CE49}>
CL-USER> ***
#<HASH-TABLE :TEST EQL :COUNT 0 {B20CE49}>
CL-USER> (+ 2 2)
4
CL-USER> +
(+ 2 2)

The test of presented object lookup Marco did does not work in Slimv, so don't try this at home or the universe will collapse:

CL-USER> #<HASH-TABLE :TEST EQL :COUNT 0 {B20CE49}>
;; Should return #<HASH-TABLE :TEST EQL :COUNT 0 {B20CE49}>
;; Instead it drops you in the debugger.
;; More on the debugger in Part Two.

Editing a source file

Let's make a new file called morse.lisp and begin typing in the program source code.
Note that I have enabled rainbow parenthesis by adding let g:lisp_rainbow=1 to my .vimrc, so matching parens have the same color:

(defpackage :morse
  (:use :common-lisp))

(in-package :morse)

Move the mouse cursor over defpackage and wait for the tooltip. The function description will be displayed in the balloon. Now move the keyboard cursor somewhere in defpackage then press ,s (or select Documentation/Describe-Symbol from the Slimv menu) and the symbol description will be displayed in the status line and also copied to the REPL buffer.

If you want to look up the symbol in the Common Lisp Hyperspec (CLHS) then move the cursor on the symbol and press ,h (or select Documentation/Hyperspec). This will open the related CLHS page in the default browser.

Now it's time to test our little program. Let's evaluate the first form: place the cursor anywhere in the defpackage form and press ,d (or select Evaluation/Eval-Defun from the Slimv menu). This will evaluate the current top-level form. Now move the cursor inside the in-package form and press ,e (or select Evaluation/Eval-Current-Exp). This will evaluate the current s-expression in the REPL buffer:

CL-USER> 
;; ,d on (defpackage ...) in the source buffer
(defpackage :morse
  (:use :common-lisp))
#<Package "MORSE">
CL-USER> 
;; ,d on (in-package ...) in the source buffer
(in-package :morse)
#<Package "MORSE">

We can find the package via find-package. We can also set the current package to morse by pressing ,g (or selecting Set-Package from the REPL menu) and entering morse, this will be reflected in the new MORSE> prompt and in the value of *package*:

CL-USER> (find-package :morse)
#<Package "MORSE">
CL-USER> 
;; Set-Package command was used here
MORSE> *package*
#<Package "MORSE">

Let's add the morse code mapping function. After typing defparameter and pressing Space the function argument list is displayed in the status line. This feature works for all functions defined by the user, not just the built-in ones:

(defparameter )



morse.lisp [+]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^7,15^^^^^^^^^^^Top
(defparameter VAR VAL &OPTIONAL (DOC NIL DOCP))

Let's fill in the morse mapping table. Marco googled and copy-pasted the morse table into the source code, then he transformed each line into an s-expression. We can do the same via a Vim macro (q), I do not cover this topic here. He also auto-indented the code, in Vim we can do that by selecting the form(s) and pressing =. The indentation is similar in Slimv and in SLIME: &body arguments in lambda lists and macros are indented by two spaces (and not below the previous argument).

We also define a new function to lookup a character in the morse mapping table:

(defparameter *morse-mapping*
  '((#\A ".-")
    (#\B "-...")
    (#\C "-.-.")
    ...
    (#\, "--..--")
    (#\? "..--..")))

(defun character-to-morse (character)
  (assoc character *morse-mapping* :test #'char-equal))

Then we realize that we need only the second part of the value returned, so we want to call cdr on the (assoc ...) part. Because of Paredit this is not done by entering an opening paren, as this would immediately insert its closing pair next to it. Rather we move the cursor to the opening paren of the form we want to wrap (the one before "assoc") and press ,W or ,w( which wraps the s-expression in a new pair of parentheses. Now we can enter the wrapping function name:

(defun character-to-morse (character)
  (cdr (assoc character *morse-mapping* :test #'char-equal)))

The inverse for Paredit Wrap is Splice, which removes the outer pair of parens by pressing ,S. It is also possible to Split (,O) and Join (,J) s-expressions, Raise (,I) subforms, or Move parens to the Left (,<) or Right (,>).

Now let's compile our morse mapping: press ,D or select Compilation/Compile-Defun from the Slimv menu. We can also compile and load the whole source file. To compile the file press ,F (or select Compilation/Compile-File), to compile and load press ,L (or select Compilation/Compile-Load-File):

MORSE> 
; compiling (DEFPARAMETER *MORSE-MAPPING* ...)
Compilation finished. (No warnings)  [0.005 secs]

MORSE> 
; compiling file "/home/kovisoft/morse.lisp" (written 09 APR 2011 10:00:17 PM):

; /home/kovisoft/morse.fasl written
; compilation finished in 0:00:00.036

Compilation finished. (No warnings)  [0.011 secs]

MORSE> 

It's time to test our character-to-morse function. Switch to the REPL buffer and begin typing at the prompt: (char, then press <Tab>. You will see a list of possible completions in a popup menu to choose from:

MORSE> (char)
        char              
        char-code         
        char-code-limit   
        char-downcase     
        char-equal        
        char-greaterp     
        ...               

If you type more letters then a subsequent <Tab> will bring up a subset of the previous completion list. Remember that we are in the MORSE package, this is why character-to-morse is included. Repeated pressing of <Tab> selects (and immediately inserts) the next possible completion.

MORSE> (charac)
        character           
        characterp          
        character-to-morse  
        get-macro-character 
        set-macro-character 
        ...                 

The default method is "fuzzy completion", so you can even type ctm and press Tab, then you still get it completed to character-to-morse.

This kind of completion is not limited to the REPL buffer, it works the same way for the source code buffer, as long as Slimv is connected to the Swank server.

BTW, there is another kind of Vim completion via <Ctrl-p> or <Ctrl-n>. That one works by searching for the word with the same prefix in the current buffer up or down. This can be useful for completing words that are not symbol names, e.g. text in comments or strings.

We select the proper completion and finalize the function call:

MORSE> (character-to-morse #\a)
(".-")
MORSE> (character-to-morse #\m)
("--")

What we got is a list containing a string, but we need a string as the result. We realize that we should use second instead of cdr in the function, so we edit the code accordingly and then re-evaluate the defun with ,d.

(defun character-to-morse (character)
  (second (assoc character *morse-mapping* :test #'char-equal)))

Switch to the REPL buffer again and recall the latest command by pressing Up in Insert mode, then press Enter to evaluate it:

MORSE> 
(defun character-to-morse (character)
  (second (assoc character *morse-mapping* :test #'char-equal)))
STYLE-WARNING: redefining CHARACTER-TO-MORSE in DEFUN
CHARACTER-TO-MORSE
;; Pressing Up to recall last command:
MORSE> (character-to-morse #\m)
"--"

Fine, character-to-morse now returns the morse code string for the character passed as parameter.

Written by Tamas Kovacs
Last updated on Aug 28, 2020

Contents

Part One

Part Two

Part Three