anchor.diff:             :meta meta
              :attrs (types:mal-data-attrs value)))
   
  -(defun mal-meta (value)
  -  (or (types:mal-data-meta value)
  -      types:mal-nil))
  +(defmal meta (value)
  +  (or (types:mal-data-meta value) types:mal-nil))
  +
  +(defun wrap-value (value &optional booleanp listp)
  +  (typecase value
  +    (number (make-mal-number value))
  +    ;; This needs to be before symbol since nil is a symbol
  +    (null (cond (booleanp mal-false)
  +                (listp (make-mal-list value))
  +                (t mal-nil)))
  +    ;; This needs to before symbol since t, nil are symbols
  +    (boolean (if value mal-true mal-nil))
  +    (keyword (make-mal-keyword value))
  +    (symbol (make-mal-symbol (symbol-name value)))
  +    (string (make-mal-string value))
  +    (list (make-mal-list (map 'list #'wrap-value value)))
  +    (vector (make-mal-vector (map 'vector #'wrap-value value)))
  +    (hash-table (make-mal-hash-map (let ((new-hash-table (make-mal-value-hash-table)))
  +                                     (hashmap (lambda (key value)
  +                                                (setf (hashref (wrap-value key) new-hash-table)
  +                                                      (wrap-value value)))
  +                                              value)
  +                                     new-hash-table)))))
   
   ;; Since a nil in Common LISP may mean an empty list or boolean false or
   ;; simply nil, the caller can specify the preferred type while evaluating an
   ;; expression
  -(defun mal-cl-eval (code &optional booleanp listp)
  +(defmal cl-eval (code &optional booleanp listp)
     (types:wrap-value (eval (read-from-string (types:mal-data-value code)))
                       :booleanp (and booleanp (types:mal-data-value booleanp))
                       :listp (and listp (types:mal-data-value listp))))
  -
  -(defvar ns
  -  (list
  -   (cons (types:make-mal-symbol "+") (types:make-mal-builtin-fn #'mal-add))
  -   (cons (types:make-mal-symbol "-") (types:make-mal-builtin-fn #'mal-sub))
  -   (cons (types:make-mal-symbol "*") (types:make-mal-builtin-fn #'mal-mul))
  -   (cons (types:make-mal-symbol "/") (types:make-mal-builtin-fn #'mal-div))
  -   (cons (types:make-mal-symbol "prn") (types:make-mal-builtin-fn #'mal-prn))
  -   (cons (types:make-mal-symbol "println") (types:make-mal-builtin-fn #'mal-println))
  -   (cons (types:make-mal-symbol "pr-str") (types:make-mal-builtin-fn #'mal-pr-str))
  -   (cons (types:make-mal-symbol "str") (types:make-mal-builtin-fn #'mal-str))
  -   (cons (types:make-mal-symbol "list") (types:make-mal-builtin-fn #'mal-list))
  -   (cons (types:make-mal-symbol "list?") (types:make-mal-builtin-fn #'mal-list?))
  -   (cons (types:make-mal-symbol "empty?") (types:make-mal-builtin-fn #'mal-empty?))
  -   (cons (types:make-mal-symbol "count") (types:make-mal-builtin-fn #'mal-length))
  -   (cons (types:make-mal-symbol "=") (types:make-mal-builtin-fn #'mal-=))
  -   (cons (types:make-mal-symbol "<") (types:make-mal-builtin-fn #'mal-<))
  -   (cons (types:make-mal-symbol ">") (types:make-mal-builtin-fn #'mal->))
  -   (cons (types:make-mal-symbol "<=") (types:make-mal-builtin-fn #'mal-<=))
  -   (cons (types:make-mal-symbol ">=") (types:make-mal-builtin-fn #'mal->=))
  -   (cons (types:make-mal-symbol "read-string") (types:make-mal-builtin-fn #'mal-read-string))
  -   (cons (types:make-mal-symbol "slurp") (types:make-mal-builtin-fn #'mal-slurp))
  -   (cons (types:make-mal-symbol "atom") (types:make-mal-builtin-fn #'mal-atom))
  -   (cons (types:make-mal-symbol "atom?") (types:make-mal-builtin-fn #'mal-atom?))
  -   (cons (types:make-mal-symbol "deref") (types:make-mal-builtin-fn #'mal-deref))
  -   (cons (types:make-mal-symbol "reset!") (types:make-mal-builtin-fn #'mal-reset!))
  -   (cons (types:make-mal-symbol "swap!") (types:make-mal-builtin-fn #'mal-swap!))
  -   (cons (types:make-mal-symbol "cons") (types:make-mal-builtin-fn #'mal-cons))
  -   (cons (types:make-mal-symbol "concat") (types:make-mal-builtin-fn #'mal-concat))
  -   (cons (types:make-mal-symbol "nth") (types:make-mal-builtin-fn #'mal-nth))
  -   (cons (types:make-mal-symbol "first") (types:make-mal-builtin-fn #'mal-first))
  -   (cons (types:make-mal-symbol "rest") (types:make-mal-builtin-fn #'mal-rest))
  -   (cons (types:make-mal-symbol "throw") (types:make-mal-builtin-fn #'mal-throw))
  -   (cons (types:make-mal-symbol "apply") (types:make-mal-builtin-fn #'mal-apply))
  -   (cons (types:make-mal-symbol "map") (types:make-mal-builtin-fn #'mal-map))
  -   (cons (types:make-mal-symbol "nil?") (types:make-mal-builtin-fn #'mal-nil?))
  -   (cons (types:make-mal-symbol "true?") (types:make-mal-builtin-fn #'mal-true?))
  -   (cons (types:make-mal-symbol "false?") (types:make-mal-builtin-fn #'mal-false?))
  -   (cons (types:make-mal-symbol "symbol") (types:make-mal-builtin-fn #'mal-symbol))
  -   (cons (types:make-mal-symbol "symbol?") (types:make-mal-builtin-fn #'mal-symbol?))
  -   (cons (types:make-mal-symbol "keyword") (types:make-mal-builtin-fn #'mal-keyword))
  -   (cons (types:make-mal-symbol "keyword?") (types:make-mal-builtin-fn #'mal-keyword?))
  -   (cons (types:make-mal-symbol "vector") (types:make-mal-builtin-fn #'mal-vector))
  -   (cons (types:make-mal-symbol "vector?") (types:make-mal-builtin-fn #'mal-vector?))
  -   (cons (types:make-mal-symbol "hash-map") (types:make-mal-builtin-fn #'mal-hash-map))
  -   (cons (types:make-mal-symbol "map?") (types:make-mal-builtin-fn #'mal-map?))
  -   (cons (types:make-mal-symbol "assoc") (types:make-mal-builtin-fn #'mal-assoc))
  -   (cons (types:make-mal-symbol "dissoc") (types:make-mal-builtin-fn #'mal-dissoc))
  -   (cons (types:make-mal-symbol "get") (types:make-mal-builtin-fn #'mal-get))
  -   (cons (types:make-mal-symbol "contains?") (types:make-mal-builtin-fn #'mal-contains?))
  -   (cons (types:make-mal-symbol "keys") (types:make-mal-builtin-fn #'mal-keys))
  -   (cons (types:make-mal-symbol "vals") (types:make-mal-builtin-fn #'mal-vals))
  -   (cons (types:make-mal-symbol "sequential?") (types:make-mal-builtin-fn #'mal-sequential?))
  -   (cons (types:make-mal-symbol "readline") (types:make-mal-builtin-fn #'mal-readline))
  -   (cons (types:make-mal-symbol "string?") (types:make-mal-builtin-fn #'mal-string?))
  -   (cons (types:make-mal-symbol "time-ms") (types:make-mal-builtin-fn #'mal-time-ms))
  -   (cons (types:make-mal-symbol "conj") (types:make-mal-builtin-fn #'mal-conj))
  -   (cons (types:make-mal-symbol "seq") (types:make-mal-builtin-fn #'mal-seq))
  -   (cons (types:make-mal-symbol "with-meta") (types:make-mal-builtin-fn #'mal-with-meta))
  -   (cons (types:make-mal-symbol "meta") (types:make-mal-builtin-fn #'mal-meta))
  -   (cons (types:make-mal-symbol "cl-eval") (types:make-mal-builtin-fn #'mal-cl-eval))))
  
positive.code:         :types
          :reader
          :printer
          :genhash)
    (:export :ns))
  
  (in-package :core)
  
  (defmacro wrap-boolean (form)
    `(if ,form mal-true mal-false))
  
  (define-condition index-error (types:mal-error)
    ((size :initarg :size :reader index-error-size)
  
negative.code:                               strings)))
    mal-nil)
  
  (defmal pr-str (&rest strings)
    (make-mal-string (format nil
                             "~{~a~^ ~}"
                             (mapcar (lambda (string) (printer:pr-str string t))
                                     strings))))
  
  (defmal str (&rest strings)
    (make-mal-string (format nil
                             "~{~a~}"
                             (mapcar (lambda (string) (printer:pr-str string nil))
                                     strings))))
  
  (defmal list (&rest values)
    (make-mal-list values))
  
  (defmal list? (value)
    (wrap-boolean (or (types:mal-nil-p value) (types:mal-list-p value))))
  
  (defmal empty? (value)
    (wrap-boolean (zerop (length (types:mal-data-value value)))))
  
  (defmal count (value)
    (types:apply-unwrapped-values 'length value))
  
  (defmal = (value1 value2)
    (wrap-boolean (types:mal-data-value= value1 value2)))
  
  (defmal < (value1 value2)
    (wrap-boolean (< (mal-data-value value1) (mal-data-value value2))))
  
  (defmal > (value1 value2)
    (wrap-boolean (> (mal-data-value value1) (mal-data-value value2))))
  
  (defmal <= (value1 value2)
    (wrap-boolean (<= (mal-data-value value1) (mal-data-value value2))))
  
  (defmal >= (value1 value2)
    (wrap-boolean (>= (mal-data-value value1) (mal-data-value value2))))
  
  (defmal read-string (value)
    (reader:read-str (types:mal-data-value value)))
  
  (defmal slurp (filename)
    (types:apply-unwrapped-values 'read-file-string filename))
  
  (defmal atom (value)
    (types:make-mal-atom value))
  
  (defmal atom? (value)
    (wrap-boolean (types:mal-atom-p value)))
  
  (defmal deref (atom)
    (types:mal-data-value atom))
  
  (defmal reset! (atom value)
    (setf (types:mal-data-value atom) value))
  
  (defmal swap! (atom fn &rest args)
    (setf (types:mal-data-value atom)
          (apply (types:mal-data-value fn)
                 (append (list (types:mal-data-value atom)) args))))
  
  (defmal cons (element list)
    (types:make-mal-list (cons element (listify (types:mal-data-value list)))))
  
  (defmal concat (&rest lists)
    (types:make-mal-list (apply #'concatenate 'list (mapcar #'types:mal-data-value lists))))
  
  (defmal nth (sequence index)
    (or (nth (types:mal-data-value index)
             (listify (types:mal-data-value sequence)))
        (error 'index-error
  