anchor.diff:           `(cl:let  ,bindings ,@body)))
   
     (defun macro?    (s) (when (macro-function s) 't))
  -  (defun function? (s) (fboundp s)))
  +  (defun function? (s) (fboundp s))
  +  ;;weak hack around lack of read-time vector creation.
  +  (defun vector-form? (expr) (or (vector? expr) (eq (first expr) 'persistent-vector))))
   
   (define-condition not-implemented (error) ())
   (define-condition uneven-arguments (error) ())
  
positive.code: ;;   no collection is provided."
  ;; {:added "1.0"
  ;; :static true}
  ;; (defn map
  ;;   ([f]
  ;;    (fn [rf]
  ;;        (fn
  ;;         ([] (rf))
  ;;         ([result] (rf result))
  ;;         ([result input]
  ;;                  (rf result (f input)))
  ;;         ([result input & inputs]
  ;;                  (rf result (apply f input inputs))))))
  ;;   ([f coll]
  ;;       (lazy-seq
  ;;        (when-let [s (seq coll)]
  ;;          (if (chunked-seq? s)
  ;;              (let [c (chunk-first s)
  ;;                size (int (count c))
  ;;                b (chunk-buffer size)]
  ;;                (dotimes [i size]
  ;;                  (chunk-append b (f (.nth c i))))
  ;;                (chunk-cons (chunk b) (map f (chunk-rest s))))
  ;;              (cons (f (first s)) (map f (rest s)))))))
  ;;   ([f c1 c2]
  ;;       (lazy-seq
  ;;        (let [s1 (seq c1) s2 (seq c2)]
  ;;          (when (and s1 s2)
  ;;            (cons (f (first s1) (first s2))
  ;;                  (map f (rest s1) (rest s2)))))))
  ;;   ([f c1 c2 c3]
  ;;       (lazy-seq
  ;;        (let [s1 (seq c1) s2 (seq c2) s3 (seq c3)]
  ;;          (when (and  s1 s2 s3)
  ;;            (cons (f (first s1) (first s2) (first s3))
  ;;                  (map f (rest s1) (rest s2) (rest s3)))))))
  ;;   ([f c1 c2 c3 & colls]
  ;;       (let [step (fn step [cs]
  ;;                      (lazy-seq
  ;;                       (let [ss (map seq cs)]
  ;;                         (when (every? identity ss)
  ;;                           (cons (map first ss) (step (map rest ss)))))))]
  ;;         (map #(apply f %) (step (conj colls c3 c2 c1))))))
  
  (defn concat
      ([] nil)
  
negative.code:  IMapEntry
   (-key [coll] (first coll))
   (-val [coll] (second coll))
   ISeq
   (-first [coll]  (sequences::first coll))
   (-rest  [coll]  (sequences::rest coll))
   )
  
  (extend-type
  