anchor.diff:    (slot-value (extra e) 'rprompt))
   
   (defun make-editline (program stdin-fd stdout-fd stderr-fd &key (prompt "% ") (rprompt "") (editor "emacs"))
  +  "Create an `editline' instance.
  +
  +This instance must be destroyed with `destroy-editline'.  You are
  +encouraged to use `with-editline' to ensure the object is destroyed."
     (let ((extra (make-instance 'editline)))
       (unwind-protect
            (with-slots
  
positive.code:     (make-lineinfo :text buffer-text :cursor-index cursor-position)))
  
  (defun editline-line (e)
    (with-slots (ptr) e
      (convert-lineinfo (el-line ptr))))
  
  
negative.code:     value))
  
  (defun editline-gets (e)
    "Retrieve a line of input from the user."
    (nth-value 0 (el-gets (slot-value e 'ptr))))
  
  (defmacro define-editline-trampoline (trampoline-name &optional (fn-name trampoline-name))
    "Create a cffi callback which calls the given lisp function.
  
  `editline-set-addfn' takes a symbol naming a \"trampoline\".  This
  macro creates such a trampoline.
  
  CFFI callbacks can be a bit annoying to work with directly for two
  reasons.
  
  1. Redefining the callback doesn't replace the existing callback.  If
  you've passed the callback to editline, then it won't call the new
  definition of the callback.  Using a trampoline means that you can
  redefine the lisp function that the callback calls.
  
  2. We need to store extra information outside of the `editline-ptr'
  that editline passes to the callback.  It can be anoying to retrieve
  that info in every callback.  This trampoline takes care of that for
  you."
    (check-type trampoline-name symbol)
    (check-type fn-name symbol)
    `(defcallback ,trampoline-name :unsigned-char
  