anchor.diff:  	  (if (null list)
   	      (return (coerce (nreverse result) 'string)))))))
   
  -(defun handle-condition (err)
  +(defun handle-condition (condition)
     (format *error-output*
   	  (str " *~A*~%~A~%")
  -	  (red (bright (format nil "~A" (class-name (class-of err)))))
  -	  (red (bright (format nil "~A" err))))
  -  (if (string= (class-name (class-of err)) "INTERACTIVE-INTERRUPT")
  +	  (red (bright (format nil "~A" (class-name (class-of condition)))))
  +	  (red (bright (format nil "~A" condition))))
  +  (if (string= (class-name (class-of condition)) "INTERACTIVE-INTERRUPT")
         (format *error-output* "~&~A~%" (red "If you want to quit, type 'exit', 'quit', '(exit)', '(quit)', or Ctrl-D")))
     (force-output *error-output*))
   
  -(defmacro handling-errors (&body body)
  +(defmacro with-handle-conditions (&body body)
     `(handler-case
          (progn ,@body)
  -     (CONDITION (e)
  -       (handle-condition e))))
  +     (condition (c)
  +       (handle-condition c))))
   
   (defvar *history* 0)
   (defvar *prompt-before* "")
  
positive.code:     (write-string left stream)
      (force-output stream)))
  
  (defun repl ()
      (do ((+eof+ (gensym))
  	 (+eol+ (gensym))
  	 (read-done-p nil nil)
  	 (-) (--) (+) (++) (+++)
  	 (/) (//) (///) (*) (**) (***))
  	(nil)
        (block iter
  	(incf *history*)
  	(print-prompt *query-io*)
  	;; read part
  	(handling-errors
  	 ;; repeat until sexp complete
  	 (do ((input) (form))
  	     (read-done-p)
  	   (setf input (read-line *standard-input* nil +eof+))
  	   (when (equal input "")
  	     (return-from iter))
  	   (when (eq input +eof+) (return-from repl))
  	   (setf form (concatenate 'string form " " input))
  	   (handler-case
  	       ;; repeat over the input sexps
  	       (do* ((in (make-string-input-stream form))
  		     (sexp (read in nil +eol+) (read in nil +eol+))
  		     (count 0) (sexps))
  		    ((eql sexp +eol+)
  		     (setf read-done-p t)
  		     (setf -- (if (= count 1) (car sexps) (cons 'values (nreverse sexps)))))
  		 (push sexp sexps)
  		 (incf count))
  	     (END-OF-FILE ()
  	       (print-prompt *error-output* t))))
  	 (setf +++ ++   ++ +   + - - --)
  	 ;; eval and print part
  	 (when (member - '((quit) quit (exit) exit (bye)) :test (function equal))
  	   (return-from repl))
  	 (format *error-output* "~A"
  		 (yellow
  		  (with-output-to-string (s)
  		    (let ((*standard-output* s))
  		      (setf /// //   // /   / (multiple-value-list (eval -)))))))
  	 (setf *** **   ** *   * (first /))
  	 (force-output)
  	 (format *error-output* (green "~{~#[; No value~:;;=> ~@{~S~^~&;   ~}~]~:}~%") / )
  	 (force-output *error-output*)))))
  (repl)
  
negative.code: (in-package :cl-user)
  (defpackage cim.repl
    (:use :CL :cim)
    (:export :*history*
  	   :print-prompt
  	   :with-handle-conditions
  	   :strf))
  (in-package :cim.repl)
  
  (defun get-current-package-name ()
    (or (car (package-nicknames *package*))
        (package-name *package*)))
  
  (defmacro make-color (name before after)
    (let ((str (gensym "strings")))
      `(defun ,name (&rest ,str)
         (apply #'concatenate
  		(append '(string)
  		 (list ,(if (opt :no-color) "" before)) ,str (list ,(if (opt :no-color) "" after)))))))
  
  (defmacro make-colors ((name before after) &rest clauses)
    `(progn
  