anchor.diff:               :index (types:mal-data-value index)
                :sequence sequence)))
   
  -(defun mal-first (sequence)
  +(defmal first (sequence)
     (or (first (listify (types:mal-data-value sequence))) mal-nil))
   
  -(defun mal-rest (sequence)
  +(defmal rest (sequence)
     (types:make-mal-list (rest (listify (types:mal-data-value sequence)))))
   
  -(defun mal-throw (value)
  -  (error 'types:mal-user-exception
  -         :data value))
  -
  -(defun mal-apply (fn &rest values)
  +(defmal throw (value)
  +  (error 'types:mal-user-exception :data value))
  +
  +(defmal apply (fn &rest values)
     (let ((last (listify (types:mal-data-value (car (last values)))))
           (butlast (butlast values)))
  -    (apply (types:mal-data-value fn)
  -           (append butlast last))))
  -
  -(defun mal-map (fn sequence)
  +    (apply (types:mal-data-value fn) (append butlast last))))
  +
  +(defmal map (fn sequence)
     (let ((applicants (listify (types:mal-data-value sequence))))
  -    (types:make-mal-list (mapcar (types:mal-data-value fn)
  -                                 applicants))))
  -
  -(defun mal-nil? (value)
  +    (types:make-mal-list (mapcar (types:mal-data-value fn) applicants))))
  +
  +(defmal nil? (value)
     (wrap-boolean (types:mal-nil-p value)))
   
  -(defun mal-true? (value)
  -  (wrap-boolean (and (types:mal-boolean-p value)
  -                     (types:mal-data-value value))))
  -
  -(defun mal-false? (value)
  -  (wrap-boolean (and (types:mal-boolean-p value)
  -                     (not (types:mal-data-value value)))))
  -
  -(defun mal-symbol (string)
  +(defmal true? (value)
  +  (wrap-boolean (and (types:mal-boolean-p value) (types:mal-data-value value))))
  +
  +(defmal false? (value)
  +  (wrap-boolean (and (types:mal-boolean-p value) (not (types:mal-data-value value)))))
  +
  +(defmal symbol (string)
     (types:make-mal-symbol (types:mal-data-value string)))
   
  -(defun mal-symbol? (value)
  +(defmal symbol? (value)
     (wrap-boolean (types:mal-symbol-p value)))
   
  -(defun mal-keyword (keyword)
  +(defmal keyword (keyword)
     (if (types:mal-keyword-p keyword)
         keyword
         (types:make-mal-keyword (format nil ":~a" (types:mal-data-value keyword)))))
   
  -(defun mal-keyword? (value)
  +(defmal keyword? (value)
     (wrap-boolean (types:mal-keyword-p value)))
   
  -(defun mal-vector (&rest elements)
  +(defmal vector (&rest elements)
     (types:make-mal-vector (map 'vector #'identity elements)))
   
  -(defun mal-vector? (value)
  +(defmal vector? (value)
     (wrap-boolean (types:mal-vector-p value)))
   
  -(defun mal-hash-map (&rest elements)
  +(defmal hash-map (&rest elements)
     (let ((hash-map (types:make-mal-value-hash-table)))
  -    (loop
  -       for (key value) on elements
  +   (loop for (key value) on elements
          by #'cddr
          do (setf (genhash:hashref key hash-map) value))
       (types:make-mal-hash-map hash-map)))
   
  -(defun mal-map? (value)
  +(defmal map? (value)
     (wrap-boolean (types:mal-hash-map-p value)))
   
  -(defun mal-assoc (hash-map &rest elements)
  +(defmal assoc (hash-map &rest elements)
     (let ((hash-map-value (types:mal-data-value hash-map))
           (new-hash-map (types:make-mal-value-hash-table)))
   
  
positive.code:            :meta meta
             :attrs (types:mal-data-attrs value)))
  
  (defun mal-meta (value)
    (or (types:mal-data-meta value)
        types:mal-nil))
  
  ;; 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)
    (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))))
  
negative.code:                               strings)))
    mal-nil)
  
  (defmal println (&rest strings)
    ;; Using write-line instead of (format *standard-output* ... ) since the later prints
    ;; and extra newline at start in GNU CLISP, if environment variable PERL_RL is true
    ;; or terminal is dumb
  