anchor.diff:   
   (defparameter *impl-name* nil)
  +(defvar *slime-command-impls* '(roswell-impls-candidates
  +                                qlot-impls-candidates))
  +
  +(defun get-lisp-command (&key impl (port *default-port*) (prefix ""))
  +  (format nil "~Aros ~{~S~^ ~} &" prefix
  +          `(,@(if impl `("-L" ,impl))
  +            "-s" "swank"
  +            "-e" ,(format nil "(swank:create-server :port ~D :dont-close t)" port)
  +            "wait")))
   
   (let (cache)
  -  (defun completion-impls (str)
  -    (unless (and cache
  -                 (< (get-universal-time) (+ 3600 (cdr cache))))
  -      (setf cache (cons (nreverse (uiop:split-string (string-right-trim
  -                                            (format nil "~%")
  -                                            (with-output-to-string (out)
  -                                             (uiop:run-program "ros list installed" :output out)))
  -                                           :separator '(#\Newline)))
  -                        (get-universal-time))))
  -    (completion-strings
  -     str (append (first cache)
  -                 (when (and #+ros.init (roswell.util:which "qlot"))
  -                   (mapcar (lambda (x) (format nil "qlot/~A" x)) (first cache)))
  -                 '("")))))
  +  (defun roswell-impls-candidates (&optional impl)
  +    (if impl
  +        (cond ((string= "" impl)
  +               (get-lisp-command :impl nil))
  +              ((find impl (or (first cache) (roswell-impls-candidates)) :test #'equal)
  +               (get-lisp-command :impl impl)))
  +        (progn
  +          (unless (and cache
  +                       (< (get-universal-time) (+ 3600 (cdr cache))))
  +            (setf cache (cons (nreverse
  +                               (uiop:split-string (string-right-trim
  +                                                   (format nil "~%")
  +                                                   (with-output-to-string (out)
  +                                                     (uiop:run-program "ros list installed" :output out)))
  +                                                  :separator '(#\Newline)))
  +                              (get-universal-time))))
  +          (first cache)))))
  +
  +(defun qlot-impls-candidates (&optional impl)
  +  (if impl
  +      (ignore-errors
  +       (when (string= "qlot/" impl :end2 5)
  +         (get-lisp-command :prefix "qlot exec "
  +                           :impl (let ((impl (subseq impl 5)))
  +                                   (unless (zerop (length impl))
  +                                     impl)))))
  +      (when (and #+ros.init (roswell.util:which "qlot"))
  +        (mapcar (lambda (x) (format nil "qlot/~A" x)) (roswell-impls-candidates)))))
  +
  +(defun completion-impls (str)
  +  (completion-strings
  +   str (cons "" (loop :for f :in *slime-command-impls*
  +                      :append (funcall f)))))
   
   (defun prompt-for-impl (&key (existing t))
     (let ((impl (prompt-for-line
  
positive.code:                (slime-quit)))))
  
  (define-command slime (&optional ask-impl) ("P")
    (let ((impl (if ask-impl
                    (prompt-for-impl)
                    *impl-name*)))
      (run-slime (get-lisp-command :impl impl))))
  
  (define-command slime-quit () ()
    (when *connection*
  
negative.code:                'completion-impls
                 (and existing
                      (lambda (name)
                        (member name (completion-impls name) :test #'string=)))
                 'mh-read-impl)))
      (loop :for f :in *slime-command-impls*
            :for command := (funcall f impl)
            :when command
            :do (return-from prompt-for-impl command))))
  
  (defun run-slime (cmd)
    (uiop:with-current-directory ((or (buffer-directory) (uiop:getcwd)))
  