anchor.diff:  ;;   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 chunked-seq? [x] nil)
  +(defn chunk-first [coll] (-chunk-first coll))
  +(defn chunk-rest [coll]  (-chunk-rest coll))
  +(defn chunk-buffer [coll])
  +
  +(defmacro lazy-seq (&rest body)
  +  `(sequences::lazy-seq ,@body))
  +
  +(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]
  +      (sequences:map f (seq coll)))
  +  ([f c1 c2]
  +      (sequences:map f (seq c1) (seq c2)))
  +  ([f c1 c2 c3]
  +      (sequences:map f (seq c1) (seq c2) (seq c3)))
  +  ([f c1 c2 c3 & colls]
  +      (sequences:map f (seq c1) (seq c2) (seq c3) colls)
  +      ))
  +
   
   (defn concat
       ([] nil)
  
positive.code: ;;   `(make-fn-def :args   (quoted-vec ,arg-vec) 
  ;; 		:body   (quote ,body)))
  
  (defun read-fn (arg-vec body)
    (make-fn-def :args   arg-vec
                 :body   body))
  
  (defgeneric arity (fd))
  (defmethod  arity ((fd clclojure.pvector::pvec))  
  
negative.code:  IMapEntry
   (-key [coll] (first coll))
   (-val [coll] (second coll))
   ISeq
   (-first [coll]  (sequences::first coll))
   (-rest  [coll]  (sequences::rest coll))
   )
  
  (extend-type
  