      (assoc m k (apply f (get m k) args)))))
 
 
-(defn empty?
+#_(defn empty?
   "Returns true if coll has no items - same as (not (seq coll)).
   Please use the idiom (seq x) rather than (not (empty? x))"
   {:added "1.0"
    :static true}
   [coll] (not (seq coll)))
 
-(defn coll?
+#_(defn coll?
   "Returns true if x implements IPersistentCollection"
   {:added "1.0"
    :static true}
   [x] (instance? clojure.lang.IPersistentCollection x))
 
-(defn list?
+#_(defn list?
   "Returns true if x implements IPersistentList"
   {:added "1.0"
    :static true}
   [x] (instance? clojure.lang.IPersistentList x))
 
-(defn set?
+#_(defn set?
   "Returns true if x implements IPersistentSet"
   {:added "1.0"
    :static true}
   [x] (instance? clojure.lang.IPersistentSet x))
 
-(defn ifn?
+#_(defn ifn?
   "Returns true if x implements IFn. Note that many data structures
   (e.g. sets and maps) implement IFn"
   {:added "1.0"
    :static true}
   [x] (instance? clojure.lang.IFn x))
 
-(defn fn?
+#_(defn fn?
   "Returns true if x implements Fn, i.e. is an object created via fn."
   {:added "1.0"
    :static true}
   [x] (instance? clojure.lang.Fn x))
 
 
-(defn associative?
+#_(defn associative?
  "Returns true if coll implements Associative"
  {:added "1.0"
   :static true}
   [coll] (instance? clojure.lang.Associative coll))
 
-(defn sequential?
+#_(defn sequential?
  "Returns true if coll implements Sequential"
  {:added "1.0"
   :static true}
   [coll] (instance? clojure.lang.Sequential coll))
 
-(defn sorted?
+#_(defn sorted?
  "Returns true if coll implements Sorted"
  {:added "1.0"
    :static true}
   [coll] (instance? clojure.lang.Sorted coll))
 
-(defn counted?
+#_(defn counted?
  "Returns true if coll implements count in constant time"
  {:added "1.0"
    :static true}
   [coll] (instance? clojure.lang.Counted coll))
 
-(defn reversible?
+#_(defn reversible?
  "Returns true if coll implements Reversible"
  {:added "1.0"
    :static true}

  [^java.util.Map$Entry e]
    (. e (getValue)))

(defn rseq
  "Returns, in constant time, a seq of the items in rev (which
  can be a vector or sorted-map), in reverse order. If rev is empty returns nil"
  {:added "1.0"

       (cat (concat x y) zs))))

;;;;;;;;;;;;;;;;at this point all the support for syntax-quote exists;;;;;;;;;;;;;;;;;;;;;;
#_(defmacro delay
  "Takes a body of expressions and yields a Delay object that will
  invoke the body only the first time it is forced (with force or deref/@), and
  will cache the result and return it on all subsequent force
