 
 
 ;; Interning copies in this namespace allows codox to find them.
-(defmacro ^:private local-copy [var doc-string]
+(defmacro ^:private update-and-make-local-copy! [var doc-string]
   `(let [var-name# (:name (meta ~var))]
      (alter-meta! ~var assoc :doc ~doc-string)
      (ns-unmap *ns* var-name#)
      (intern *ns* (with-meta var-name#
                     (assoc (meta ~var) :doc ~doc-string)) (vars/root-value ~var))))
 
-(local-copy #'clojure.core/ns-name
+(update-and-make-local-copy! #'clojure.core/ns-name
   "`ns` *must* be either a namespace or a symbol naming a namespace.
    If the namespace exists, its symbol-name is returned. If not, an exception is thrown.
    Note: the more common `name` function cannot be applied to namespaces.

")


(local-copy #'clojure.core/symbol
  "Creates a symbol from its arguments, which *must* be strings.
   The name of that result is `name`. In the one-argument version,
   the result's namespace is `nil`. In the two-argument version, it's

         (symbol \"no.such.namespace\" \"the\") => 'no.such.namespace/the
")

(update-and-make-local-copy! #'clojure.core/butlast
  "Return a seq of all but the last item in coll, in linear time.
   If you are working on a vector and want the result to be a vector, use `pop`.")

    
(update-and-make-local-copy! #'clojure.core/every-pred
   "Take N functions and produce a single predicate - call it `result`. `result`
    will return `true` iff each of the original functions returns a truthy 
    value. `result` evaluates the functions in order, and the first one that produces
    a falsey value stops any further checking. In that case, `false` is returned.
    
    See also [[some-fn]].
    
         ( (every-pred integer? even? pos?) \"hi\") => false
         ( (every-pred integer? even? pos?) 4) => true
")

    
(update-and-make-local-copy! #'clojure.core/some-fn
   "Take N functions and produce a single function - call it `result`. `result`
    evaluates the N functions in order. When one returns a truthy result, `result`
    skips the remaining functions and returns that result. If none of the functions
    returns a truthy value, `result` returns a falsey value.
    
    This function is called `some-fn` because it does not produce a pure (true/false)
    result. See also [[every-pred]].
    
         ( (some-fn even? pos?) 3) => true
         ( (some-fn even? pos?) -3) => false
