qq

2 years ago · 6213334707
3 changed files with 3336 additions and 0 deletions
--- a/lisp/vlime-api.md
+++ b/lisp/vlime-api.md
--- a/lisp/vlime-tutor.md
+++ b/lisp/vlime-tutor.md
@ -0,0 +1,733 @@
 *vlime-tutor.txt*  A tutorial for Vlime                  *vlime-tutor*
 * [soure of text](https://github.com/vlime/vlime/blob/master/vim/doc/vlime-tutor.txt)
 ======================================================================
 CONTENTS                                        *vlime-tutor-contents*
    1. Introduction .............................. |vlime-tutor-intro|
    2. Starting the Server ................ |vlime-tutor-start-server|
    3. Connecting .............................. |vlime-tutor-connect|
    4. The REPL ................................... |vlime-tutor-repl|
    5. Coding ..................................... |vlime-tutor-code|
    6. Compiling ............................... |vlime-tutor-compile|
    7. Debugging ................................. |vlime-tutor-debug|
    8. The inspector ......................... |vlime-tutor-inspector|
    9. Conclusion ........................... |vlime-tutor-conclusion|
 ======================================================================
 1. Introduction                                    *vlime-tutor-intro*
 This is a guided tour to show the major features of Vlime. For a
 complete list of the features and key mappings etc., see |vlime.txt|.
 This tutorial was written on a Linux machine, so there may be some
 Linux-specific commands. Vlime also works fine on Windows, and maybe
 MacOS, but these systems will not be covered here.
 Before we get started, please make sure your system has all these
 prerequisites:
    * A decent Common Lisp implementation. SBCL is strongly
      recommended, but other implementations that support the debugger
      may also be fine. See |vlime-intro| for a list of supported
      implementations.
    * The Paredit plugin for Vim (https://github.com/kovisoft/paredit).
    * Vlime being properly installed. See README.md in the Vlime
      source repo for installation instructions.
 We will be building a Fibonacci sequence generator in the rest of this
 tutorial. Fascinating, right?
 ======================================================================
 2. Starting the Server                      *vlime-tutor-start-server*
 Vlime works in a client-server fashion. The server is written in
 Common Lisp. You can let Vlime start the server for you (see
 |vlime-start-up|), but let's do it manually for the first time. To
 start the server on the local machine:
    sbcl --load <vlime repo>/lisp/start-vlime.lisp
 To run the server on a remote machine, see |vlime-remote-server|.
 The server is fully functional when we see something like this in the
 console:
    <INFO> [10:08:07] vlime-usocket - Server created: ....
 It will be listening on port 7002 by default.
 ======================================================================
 3. Connecting                                    *vlime-tutor-connect*
 Now we can create a new *.lisp file in Vim:
    :tabedit ad-hoc.lisp
 Then type "\cc" (without the quote marks) in normal mode to create a
 connection. The backslash "\" is the default mapping for
 |<LocalLeader>|. See |vlime-mappings|.
 Vlime will show a message in Vim if everything went well:
    Vlime Connection 1 established.
 There can be multiple Vlime connections in a single Vim process. You
 can use "\cc" to make more connections to the same server (though that
 usually doesn't make any sense), or call vlime#plugin#ConnectREPL() in
 Vim to connect to another server. For example:
    :call vlime#plugin#ConnectREPL("127.0.0.1", 9999)
 This will try to make a connection to 127.0.0.1:9999.
 Now, just for demostrating, let's type "\cc" a few more times, to
 create more connections. Then type "\cs" (without the quote marks) in
 the ad-hoc.lisp buffer to see the connection list. A list with three
 connections should look like this:
    Which connection to use?
    1. Vlime Connection 1 (127.0.0.1:7002)
    2. Vlime Connection 2 (127.0.0.1:7002)
    3. Vlime Connection 3 (127.0.0.1:7002)
    Type number and <Enter> or click with mouse (empty cancels):
 From there you can also choose a connection for the current buffer to
 use by typing it's ID and then <Enter>. See
 |vlime-current-connection|.
 When you're done with a connection, type "\cd" (without the quote
 marks) in a *.lisp buffer to close it. The connection list may pop up
 if Vlime was not sure which connection to close.
 You may try out the "\cc", "\cs", and "\cd" commands now, until you
 feel comfortable to move on. Please leave at least one connection open
 before proceeding to the next section.
 ======================================================================
 4. The REPL                                         *vlime-tutor-repl*
 Now that we have an active connection, let's try something simple.
 Vlime has good REPL integration, but it's different from other Lisp
 environments, in that Vlime's REPL buffer is dedicated for output,
 i.e. you can not type and evaluate an expression directly in the REPL
 buffer. To evaluate something in the REPL, you send it using key
 mappings listed in |vlime-mappings-send|.
 Let's go to ad-hoc.lisp, the file we created in |vlime-tutor-connect|,
 and write a simple expression in it:
    (cons 1 2)
 Note: You may notice some "strange" behaviors when typing the
      expression, such as parentheses being paired up automatically.
      They are in fact features to aid you in code editing. We will
      get to them in |vlime-tutor-code|.
 Make sure the cursor is on or inside the parentheses, then type "\ss"
 (without the quote marks) in normal mode. A new buffer will pop up at
 the bottom, showing some info about the server and the evaluation
 result:
    SWANK version 2016-04-19, pid 14403
    ===================================
    --
    (1 . 2)
 This is the REPL buffer.
 Try typing "i" (without the quote marks) in the REPL buffer. It will
 result in an error message:
    E21: Cannot make changes, 'modifiable' is off
 Indeed, it's read-only.
 To make sending things to the REPL easier, Vlime has an interaction
 mode for *.lisp buffers. Go back to the ad-hoc.lisp buffer at the top,
 then type "\i" (without the quote marks) to activate interaction mode.
 To send something to the REPL in interaction mode, simply press <CR>.
 Consider the expression we just wrote:
    (cons 1 2)
 Again, make sure the cursor is on or inside the parentheses, then
 press <CR>, the new result will also come out in the REPL buffer:
    SWANK version 2016-04-19, pid 14403
    ===================================
    --
    (1 . 2)
    --
    (1 . 2)
 Be careful with nested expressions though. Vlime will only match the
 nearest parentheses that enclose the cursor. Let's add one more line
 to ad-hoc.lisp:
    (cons 1 2)
    (+ 1 (- 10 2))  ; the new line
 When <CR> is pressed, if the cursor was on the "+" operator, the whole
 expression "(+ 1 (- 10 2))" will be sent, and the result will be 9. If
 the cursor was on the "-" operator, only the nested expression
 "(- 10 2)" will be sent, and the result will be 8.
 To disable interaction mode, type "\i" (without the quote marks) again
 in the ad-hoc.lisp buffer.
 But in what package were those expressions evaluated? Let's have a
 look. Add one more line to ad-hoc.lisp and evaluate it by typing "\ss"
 (without the quote marks) in normal mode or <CR> in interaction mode:
    (cons 1 2)
    (+ 1 (- 10 2))
    (symbol-value (find-symbol "*PACKAGE*" "COMMON-LISP"))  ; the new line
 The result should look like
    --
    #<PACKAGE "COMMON-LISP-USER">
 When evaluating an expression, Vlime would use the package associated
 with the buffer containing that expression (see
 |vlime-current-package|). And the default package is COMMON-LISP-USER.
 In the examples above, we never explicitly set the package for
 ad-hoc.lisp, so it used the default package, and all the expressions
 are evaluated in the default package too.
 There are two methods to set the package for a buffer:
    1. Write an "in-package" expression in the buffer. Change the
       content of ad-hoc.list to
           (cons 1 2)
           (+ 1 (- 10 2))
           (in-package :vlime) ; the new line
           (symbol-value (find-symbol "*PACKAGE*" "COMMON-LISP"))
       And then evaluate the last line again, the result would be
           --
           #<PACKAGE "VLIME">
    2. Type "\p" (without the quote marks) in a buffer in normal mode.
       Vim will then prompt for the new package name, with the current
       package displayed as the default. You can edit the package name
       like you edit any other text in a normal buffer, and then press
       <CR> in normal mode to submit (see |vlime-input-buffer|). The
       name to enter can be a nickname, and is case-insensitive. This
       method will take precedence over method 1.
       Now type "\p" in ad-hoc.lisp, and set the package to "cl-user"
       (without the quote marks). Evaluate the last line again, the
       result would be
           --
           #<PACKAGE "COMMON-LISP-USER">
 You may try out the REPL and the interaction mode now, until you feel
 comfortable to move on. Try writing some complex expressions in
 ad-hoc.lisp, such as multi-line DEFUNs, and evaluate them using
 interaction mode.
 ======================================================================
 5. Coding                                           *vlime-tutor-code*
 Finally, we are going to write some real code. Our goal is to build a
 Fibonacci sequence generator. Let's create a new file in Vim:
    :tabedit fibonacci.lisp
 And then type the content in it:
    (in-package #:cl-user)
    (defpackage #:fibonacci
      (:use #:cl)
      (:export #:generate))
    (in-package #:fibonacci)
    (defun generate (n &optional (a 0) (b 1) (acc (list)))
      (if (<= n 0)
        (reverse acc)
        (generate (1- n) b (+ a b) (push acc a))))
 The GENERATE function should build a list of N Fibonacci numbers. If
 you typed the code manually instead of copy-and-paste, You may have
 noticed a few things when typing:
    1. The parentheses are automatically paired. This is done by the
       Paredit plugin. It's an invaluable tool for editing Lisp code.
       See |paredit.txt| for details and more advanced usage.
    2. When pressing <Space> or <CR> inside a pair of parentheses in
       insert mode, a small preview window may pop up at the top,
       showing the argument list for the current expression.
    3. The code is automatically indented. See |vlime-auto-indent|.
    4. You can press <Tab> or the old-school CTRL-x CTRL-o keys in
       insert mode to activate the omni-completion menu, and then
       use CTRL-n or CTRL-p to select a candidate. See
       |vlime-completions|.
 Note: If you have other completion plugins installed, the <Tab> key
      may be mapped to the other plugins, and may not work as
      expected. You can fall back to CTRL-x CTRL-o, or remap the
      <Tab> key as described in |vlime-mappings-remap|.
 These are the most frequently used features when editing the source
 code.
 Vlime also has support for showing document strings and cross
 references. Move the cursor inside the word "reverse", and type "\dda"
 (without the quote marks), a preview buffer will then show a brief
 description of the REVERSE function:
    Documentation for the symbol REVERSE:
    Function:
     Arglist: (SEQUENCE)
     Return a new sequence containing the same elements but in reverse order.
 This information varies between Common Lisp implementations, but is
 generally helpful. See |vlime-mappings-describe| for more operations
 on describing symbols.
 Now keep the cursor inside the word "reverse", and type "\xc" (without
 the quote marks). The cross reference (a.k.a. xref) buffer will pop up
 with some content like this:
    SB-WALKER::LET*-BINDINGS
    SB-SYS:CLOSE-SHARED-OBJECTS
    SB-PCL::MAKE-PRELIMINARY-LAYOUT
    SB-PCL::STD-COMPUTE-SLOTS
    SB-PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD
    SB-PCL::COMPUTE-STD-CPL-PHASE-3
    SB-PCL::%UPDATE-LISP-CLASS-LAYOUT
    ....
 Note: Depending on how your Common Lisp implementation was built, you
      may get the "No xref found" error message instead. Don't worry.
      You can try other xrefs listed in |vlime-mappings-invoke-xref|,
      or skip this operation and proceed to the next section.
 These are the locations where the REVERSE function is called. Press
 <CR> on one of them and Vlime will take you directly to the referenced
 location, provided the source code is readable. Use |CTRL-O| to go
 back to previous cursor locations. There are other kinds of cross
 references, see |vlime-mappings-invoke-xref|.
 Before proceeding to the next section, you can close all Vlime windows
 in the current tab page by typing "\wA" (without the quote marks) in
 fibonacci.lisp in normal mode. See |vlime-mappings-close-window| for
 all window-manipulating commands.
 ======================================================================
 6. Compiling                                     *vlime-tutor-compile*
 Make sure you have saved fibonacci.lisp, and then type "\of" (without
 the quote marks) in it's buffer in normal mode. Go back to the REPL
 buffer, you'll see the compilation result:
    --
    ; compiling file "/home/user/fibonacci.lisp" (written 28 FEB 2017 11:16:53 AM):
    ; /home/user/fibonacci.fasl written
    ; compilation finished in 0:00:00.093
 Note: If you have closed the window containing the REPL buffer, it
      should now pop up again.
 This result means our code compiled cleanly, with no errors or
 warnings etc. To generate a warning message, let's change the
 expression calling the GENERATE function from
    (generate (1- n) b (+ a b) (push acc a))
 To
    (some-other-func (1- n) b (+ a b) (push acc a))
 SOME-OTHER-FUNC is not defined, of course. Save the file, and Compile
 it again by typing "\of" (without the quote marks). A buffer will pop
 up with a warning message:
    STYLE-WARNING: undefined function: SOME-OTHER-FUNC
 Pressing <CR> on the message will take you to the exact location where
 the undefined function is called.
 Let's change the function call back to GENERATE, then save and compile
 fibonacci.lisp again. The compiler messages (a.k.a. notes) buffer
 should say:
    No message from the compiler.
 We will see whether the GENERATE function can work as expected in
 |vlime-tutor-debug|. See |vlime-mappings-compile| for other compiling
 operations.
 You can close the notes window before proceeding to the next section.
 ======================================================================
 7. Debugging                                       *vlime-tutor-debug*
 The first step of debugging in Common Lisp is usually trying out the
 new function in the REPL. We'll do the same here.
 Go back to ad-hoc.lisp, write an expression to call
 FIBONACCI:GENERATE:
    (fibonacci:generate 10)
 And send it to the REPL, via either "\ss" or interaction mode.
 A new buffer came out instead of the evaluation result. The buffer
 content looks quite scary:
    Thread: 1; Level: 1
    The value
      34
    is not of type
      LIST
       [Condition of type TYPE-ERROR]
    Restarts:
      0.  RETRY - Retry SLIME REPL evaluation request.
      1. *ABORT - Return to SLIME's top level.
      2.  ABORT - abort thread (#<THREAD "repl-thread" RUNNING ...
    Frames:
      0.  (SB-IMPL::LIST-REVERSE 34)
      1.  (SB-INT:SIMPLE-EVAL-IN-LEXENV (FIBONACCI:GENERATE 10) ...
      2.  (EVAL (FIBONACCI:GENERATE 10))
      3.  (SWANK::EVAL-REGION "(fibonacci:generate 10)")
      4.  ((LAMBDA NIL :IN SWANK-REPL::REPL-EVAL))
      5.  (SWANK-REPL::TRACK-PACKAGE #<CLOSURE (LAMBDA NIL :IN ...
      6.  (SWANK::CALL-WITH-RETRY-RESTART "Retry SLIME REPL ...
      7.  (SWANK::CALL-WITH-BUFFER-SYNTAX NIL #<CLOSURE (LAMBDA ...
      8.  (SWANK-REPL::REPL-EVAL "(fibonacci:generate 10)")
      9.  (SB-INT:SIMPLE-EVAL-IN-LEXENV (SWANK-REPL:LISTENER-EVAL ...
      ....
 This is the debugger. It pops up whenever an unhandled condition
 occurs. The content can be divided into four parts, separated by an
 empty line:
    * The thread and netsted level this condition occured in.
    * The description of this condition.
    * Some available restarts.
    * The stack frames.
 Our GENERATE function is recursive, but we see no GENERATE function
 call in the stack frames. That's because the compiler did it's job and
 optimized our code a bit, so the debugger has fewer info available.
 We can't determine what went wrong yet, so let's abort the evaluation
 for now. Select the restart labeled "ABORT - Return to SLIME's top
 level" by moving the cursor to that line and press <CR>. The debugger
 will then disappear, leaving a printed condition in the REPL buffer to
 indicate the evaluation was aborted:
    --
    #<TYPE-ERROR expected-type: "LIST"datum: 34>
 There's an option in Vlime to tell the compiler our preference. Let's
 use it now to preserve all available debug info:
    :let g:vlime_compiler_policy = {"DEBUG": 3}
 See |g:vlime_compiler_policy| for a detailed description of this
 variable.
 With the compiler policy set, we compile fibonacci.lisp and call
 FIBONACCI:GENERATE in the REPL again. Of course the debugger will
 still pop up, but this time it has more detailed stack info:
    Thread: 1; Level: 1
    The value
      34
    is not of type
      LIST
       [Condition of type TYPE-ERROR]
    Restarts:
      0.  RETRY - Retry SLIME REPL evaluation request.
      1. *ABORT - Return to SLIME's top level.
      2.  ABORT - abort thread (#<THREAD "repl-thread" RUNNING {1003907F93}>)
    Frames:
      0.  (SB-IMPL::LIST-REVERSE 34)
      1.  (FIBONACCI:GENERATE 0 55 89 (((# . 13) . 21) . 34))
      2.  (FIBONACCI:GENERATE 1 (((# . 13) . 21) . 34) 55 (((# . 8) . 13) . 21))
      3.  (FIBONACCI:GENERATE 2 (((# . 8) . 13) . 21) 34 (((# . 5) . 8) . 13))
      4.  (FIBONACCI:GENERATE 3 (((# . 5) . 8) . 13) 21 (((# . 3) . 5) . 8))
      5.  (FIBONACCI:GENERATE 4 (((# . 3) . 5) . 8) 13 (((# . 2) . 3) . 5))
      6.  (FIBONACCI:GENERATE 5 (((# . 2) . 3) . 5) 8 (((# . 1) . 2) . 3))
      7.  (FIBONACCI:GENERATE 6 (((# . 1) . 2) . 3) 5 (((# . 1) . 1) . 2))
      8.  (FIBONACCI:GENERATE 7 (((# . 1) . 1) . 2) 3 (((NIL . 0) . 1) . 1))
      9.  (FIBONACCI:GENERATE 8 (((NIL . 0) . 1) . 1) 2 ((NIL . 0) . 1))
      10. (FIBONACCI:GENERATE 9 ((NIL . 0) . 1) 1 (NIL . 0))
      11. (FIBONACCI:GENERATE 10 (NIL . 0) 1 NIL)
      12. (SB-INT:SIMPLE-EVAL-IN-LEXENV (FIBONACCI:GENERATE 10) #<NULL-LEXENV>)
      13. (EVAL (FIBONACCI:GENERATE 10))
      ....
 This stack deserves careful examination. We can see each call of the
 FIBONACCI:GENERATE function and the values of it's arguments. To see
 more details, move the cursor to frame 2 and press "d" (without the
 quote marks). A preview buffer will show all local variable names and
 their values, plus other useful info:
    Frame: 2 (Restartable)
    Locals:
      A:   ((((# . 8) . 13) . 21) . 34)
      ACC: ((((# . 5) . 8) . 13) . 21)
      B:   55
      N:   1
    Location:
      File: /home/user/fibonacci.lisp
      Position: 239
      Snippet:
        (generate (1- n) b (+ a b) (push acc a))))
      ....
 The variables A and B should be adjacent Fibonacci numbers, but A is
 in fact a strange cons struct.
 To make it more challenging, I'll let you use what you learnt to
 figure out what's wrong with our program. Don't worry if you can't
 make it right. There is a corrected version of fibonacci.lisp in the
 next section. See |vlime-mappings-debugger| for all available debugger
 operations.
 ======================================================================
 8. The Inspector                               *vlime-tutor-inspector*
 Now that we have fixed fibonacci.lisp, it should look like this:
    (in-package #:cl-user)
    (defpackage #:fibonacci
      (:use #:cl)
      (:export #:generate))
    (in-package #:fibonacci)
    (defun generate (n &optional (a 0) (b 1) (acc (list)))
      (if (<= n 0)
        (reverse acc)
        (generate (1- n) b (+ a b) (push a acc))))
 It works well, but It's a boring function after all. We should
 probably add some fancy classes and methods:
    (in-package #:cl-user)
    (defpackage #:fibonacci
      (:use #:cl)
      (:export #:generate
               #:generator
               #:next))
    (in-package #:fibonacci)
    (defun generate (n &optional (a 0) (b 1) (acc (list)))
      (if (<= n 0)
        (values (reverse acc) a b)
        (generate (1- n) b (+ a b) (push a acc))))
    (defclass generator ()
      ((param-a :accessor generator-param-a :initform 0)
       (param-b :accessor generator-param-b :initform 1)))
    (defgeneric next (obj)
      (:method ((obj generator))
        (with-slots (param-a param-b) obj
          (multiple-value-bind (result a b) (generate 1 param-a param-b)
            (setf param-a a
                  param-b b)
            (car result)))))
 We use a modified GENERATE function as a backend to build a GENERATOR
 class. Now let's test it by first creating an instance. Save
 fibonacci.lisp, and compile it by typing "\of" (without the quote
 marks), then go back to ad-hoc.lisp, write down this MAKE-INSTANCE
 expression and send it to the REPL:
    (make-instance 'fibonacci:generator)
 The REPL buffer will show the result:
    --
    #<FIBONACCI:GENERATOR {1003D83903}>
 We can call the accessors or SLOT-VALUE to see whether the slots are
 initialized correctly, but there is an easier way. We should bring up
 the inspector.
 Go to the REPL buffer, and move the cursor to the printed
 representation of our newly created instance, then type "\I" (without
 the quote marks). The inspector buffer should appear. The info
 displayed in the inspector will look like this:
    #<FIBONACCI:GENERATOR {1003D83903}>
    ===================================
    Class: #<STANDARD-CLASS FIBONACCI:GENERATOR>
    --------------------
     Group slots by inheritance [ ]
     Sort slots alphabetically  [X]
    All Slots:
    [ ]  PARAM-A = 0
    [ ]  PARAM-B = 1
    [set value]  [make unbound]
 We can see that PARAM-A is 0 and PARAM-B is 1. They are initialized
 correctly.
 Now we are going to test the FIBONACCI:NEXT method. We want to call
 the method on the instance we just created, and see if the slot values
 are changed correctly.
 We didn't save a reference to the generator instance, but that's not
 a problem. The REPL buffer remembers all evaluation results it has
 seen. We can just yank the result from the REPL buffer.
 Keep the inspector open, go back to the REPL buffer, and make sure the
 cursor is still on the printed representation of our
 FIBONACCI:GENERATOR instance. Type "\y" (without the quote marks) to
 yank the object into the register |quotequote|.
 Then add a new line in ad-hoc.lisp:
    (fibonacci:next )
 Place the cursor on the space character just before the right
 parentheses, and type "p" (without the quote marks). The new line
 should now look like this:
    (fibonacci:next (swank:lookup-presented-object 10))
 You may have a number other than "10", and that's OK. The
 SWANK:LOOKUP-PRESENTED-OBJECT expression returns the
 FIBONACCI:GENERATOR instance saved by the REPL.
 Evaluate the whole FIBONACCI:NEXT expression a few times, and we'll
 get a series of Fibonacci numbers in the REPL buffer.
 Now go to the inspector and press "R" (without the quote marks) to
 refresh it. We can see that PARAM-A and PARAM-B are successfully
 changed:
    #<FIBONACCI:GENERATOR {100257FFE3}>
    ===================================
    Class: #<STANDARD-CLASS FIBONACCI:GENERATOR>
    --------------------
     Group slots by inheritance [ ]
     Sort slots alphabetically  [X]
    All Slots:
    [ ]  PARAM-A = 377
    [ ]  PARAM-B = 610
    [set value]  [make unbound]
 The inspector is also capable of setting slot values. The square
 brackets in the inspector buffer denote buttons, we can use these
 buttons to manipulate PARAM-A and PARAM-B.
 Say we want to fast forward the generator to the 50th Fibonacci
 number. Move the cursor inside the brackets just before PARAM-A, and
 press <CR> or <Space>. An "X" will appear to indicate that this slot
 is selected. Do the same with PARAM-B. The inspector should now look
 like this:
    #<FIBONACCI:GENERATOR {100257FFE3}>
    ===================================
    Class: #<STANDARD-CLASS FIBONACCI:GENERATOR>
    --------------------
     Group slots by inheritance [ ]
     Sort slots alphabetically  [X]
    All Slots:
    [X]  PARAM-A = 377
    [X]  PARAM-B = 610
    [set value]  [make unbound]
 Now move the cursor to "[set value]" and press <CR> or <Space>. A
 buffer will pop up at the bottom prompting for the value of slot
 PARAM-A. Let's write an expression to calculate the 50th Fibonacci
 number:
    ; Set slot FIBONACCI::PARAM-A to (evaluated) :
    (car (last (fibonacci:generate 50)))
 Then go back to normal mode and press <CR>. Another buffer will
 appear, prompting for the value of PARAM-B. We give it the 51st
 number:
    ; Set slot FIBONACCI::PARAM-B to (evaluated) :
    (car (last (fibonacci:generate 51)))
 Remember to press <CR> in normal mode after you have done editing the
 expression. The inspector should be automatically updated and look
 like this:
    #<FIBONACCI:GENERATOR {100257FFE3}>
    ===================================
    Class: #<STANDARD-CLASS FIBONACCI:GENERATOR>
    --------------------
     Group slots by inheritance [ ]
     Sort slots alphabetically  [X]
    All Slots:
    [X]  PARAM-A = 7778742049
    [X]  PARAM-B = 12586269025
    [set value]  [make unbound]
 We can call FIBONACCI:NEXT again to confirm that the internal state of
 our generator instance is indeed changed:
    (fibonacci:next (swank:lookup-presented-object 10))
 And the REPL buffer shows:
    --                                                                                                                                       
    7778742049
 The inspector can also look inside lists, vectors, hashtables, and
 packages. You can try to create some of these data structures and peek
 inside. See |vlime-mappings-inspector| for all available operations in
 the inspector.
 You can simply close the inspector window when you've done playing
 with it.
 ======================================================================
 9. Conclusion                                 *vlime-tutor-conclusion*
 Our Finbonacci sequence generator is working, and we have covered the
 most frequently used features of Vlime. You should now be able to use
 Vlime to write and debug Common Lisp programs. You can then read the
 full documentation in |vlime.txt|.
--- a/lisp/vlime.md
+++ b/lisp/vlime.md