Liking cljdoc? Tell your friends :D
Mostly clj/s.
Exceptions indicated.

taoensso.encore

Extended core library for Clojure/Script that emphasizes:
  * Cross-platform API
  * Flexibility
  * Performance
  * Backwards compatibility

This lib's mostly for my own use and for advanced users that feel
comfortable reading this source. Not providing much beginner-oriented
documentation for this, sorry.

Common naming conventions used across my libs:
  **foo** - Dynamic var
  foo!    - Fn with side-effects, or that should otherwise be used cautiously
  foo?    - Truthy val or fn that returns truthy val
  foo!?   - Fn that has side-effects (or requires caution) and that return
            a truthy val. Note: !?, not ?!
  foo$    - Fn that's notably expensive to compute (e.g. hits db)
  foo_    - Derefable val (e.g. atom, volatile, delay, etc.)
  foo__   - Derefable in a derefable (e.g. delay in an atom), etc.
  _       - Unnamed val
  _foo    - Named but unused val
  ?foo    - Optional val (emphasize that val may be nil)
  foo*    - A variation of `foo` (e.g. `foo*` macro vs `foo` fn)
  foo'    - ''
  -foo    - Public implementation detail or intermediate (e.g. uncoerced) val
  >foo    - Val "to   foo" (e.g. >sender, >host), or fn to  put/coerce/transform
  <foo    - Val "from foo" (e.g. <sender, <host), or fn to take/coerce/transform
  ->foo   - Fn to put/coerce/transform

Type affixes may be used for clarity:
  <prefix>-<name>  - m-users,   v-users,   n-users,    etc. (also nusers when unambiguous)
  <name>-<postfix> - users-map, users-vec, user-count, etc.

Regarding name heirarchy:
  When there's a significant num of syms with a meaningful hierarchy,
  prefer names with descending hierarchy to emphasize structure and
  related groups/functionality, e.g.:
    `user-add`, `user-remove`, `user-mod` vs
    `add-user`, `remove-user`, `mod-user`, etc.

Commit message tags (in priority order):
  [wip]   - Work-in-progress (still under development)

  [mod]   - Modify     behaviour (=>          breaking), [mod!], [mod!!], etc. for attention
  [fix]   - Fix broken behaviour (=> usu. non-breaking)
  [new]   - Add new    behaviour (=>      non-breaking)

  [doc]   - Documentation changes besides those better labelled as [mod], [fix], or [new]
  [nop]   - Other non-breaking changes (to implementation details, non-code changes, etc.)

  [x] [y] - Single commit with multiple tags (in priority order), try avoid

Example commit messages:
  v1.0.0 (2022-01-27) ; Tagged release
  [new] [#122] Add new feature x (@contributor)

Version numbers:
  Ver tables:  X.Y.Z (without backticks)
     Min ver: vX.Y.Z+
   Elsewhere: vX.Y.Z

-condclj/smacro

(-cond throw? & clauses)
source

<*clj/smacro

(<* x y z)
source

<=*clj/smacro

(<=* x y z)
source

>*clj/smacro

(>* x y z)
source

>=*clj/smacro

(>=* x y z)
source

a-utf8-strclj/s

Example UTF-8 string for tests, etc.
source

abbreviate-nsclj/s

(abbreviate-ns x)
(abbreviate-ns n-full x)
Give any nameable type (string, keyword, symbol), returns the same
type with at most `n-full` (default 1) unabbreviated namespace parts.

Example:
  (abbreviate-ns 0  :foo.bar/baz)   => :f.b/baz
  (abbreviate-ns 1  'foo.bar/baz)   => 'f.bar/baz
  (abbreviate-ns 2 "foo.bar/baz") => "foo.bar/baz"
source

absclj/s

(abs n)
source

after-timeoutclj/smacro

(after-timeout msecs & body)
Alpha, subject to change.
Returns a TimeoutFuture that will execute body after timeout.
Body must be non-blocking or cheap.
source

ajax-callcljs

(ajax-call url
           {:keys [method params headers timeout-ms resp-type with-credentials?
                   xhr-pool xhr-cb-fn xhr-timeout-ms]
            :as opts
            :or {method :get
                 timeout-ms 10000
                 resp-type :auto
                 xhr-pool default-xhr-pool_
                 xhr-timeout-ms 2500}}
           callback-fn)
Queues a lightweight Ajax call with Google Closure's `goog.net.XhrIo` and
returns nil, or the resulting `goog.net.XhrIo` instance if one was
immediately available from the XHR pool:

  (ajax-call
    "http://localhost:8080/my-post-route" ; Endpoint URL

    {:method     :post ; ∈ #{:get :post :put}
     :resp-type  :text ; ∈ #{:auto :edn :json :xml :text}

     :params     {:username "Rich Hickey" :type "Awesome"} ; Request params
     :headers    {"Content-Type" "text/plain"} ; Request headers

     :timeout-ms 7000
     :with-credentials? false ; Enable if using CORS (requires xhr v2+)

     :xhr-pool       my-xhr-pool ; Optional `goog.net.XhrIoPool` instance or delay
     :xhr-cb-fn      (fn [xhr])  ; Optional fn to call with `XhrIo` from pool when available
     :xhr-timeout-ms 2500        ; Optional max msecs to wait on pool for `XhrIo`
    }

    (fn ajax-callback-fn [resp-map]
      (let [{:keys [success? ?status ?error ?content ?content-type]} resp-map]
        ;; ?status ; ∈ #{nil 200 404 ...}, non-nil iff server responded
        ;; ?error  ; ∈ #{nil <http-error-status-code> <exception> :timeout
                         :abort :http-error :exception :xhr-pool-depleted}
        (js/alert (str "Ajax response: " resp-map)))))
source

approx==clj/s

(approx== x y)
(approx== signf x y)
source

as-?boolclj/s

(as-?bool x)
source

as-?dtclj

(as-?dt x)
Returns given ?arg as `java.util.Date`, or nil.
source

as-?emailclj/s

(as-?email ?s)
(as-?email max-len ?s)
source

as-?floatclj/s

(as-?float x)
source

as-?instclj/s

(as-?inst x)
Returns given ?arg as platform instant (`java.time.Instant` or `js/Date`), or nil.
source

as-?intclj/s

(as-?int x)
source

as-?kwclj/s

(as-?kw x)
source

as-?nameclj/s

(as-?name x)
source

as-?nat-floatclj/s

(as-?nat-float x)
source

as-?nat-intclj/s

(as-?nat-int x)
source

as-?nblankclj/s

(as-?nblank x)
source

as-?nblank-trimclj/s

(as-?nblank-trim x)
source

as-?nemailclj/s

(as-?nemail ?s)
(as-?nemail max-len ?s)
source

as-?nempty-strclj/s

(as-?nempty-str x)
source

as-?nzeroclj/s

(as-?nzero x)
source

as-?pnumclj/s

(as-?pnum x)
source

as-?pos-floatclj/s

(as-?pos-float x)
source

as-?pos-intclj/s

(as-?pos-int x)
source

as-?qnameclj/s

(as-?qname x)
source

as-?rnumclj/s

(as-?rnum x)
source

as-?udtclj/s

(as-?udt x)
Returns given ?arg as (pos/neg) milliseconds since Unix epoch, or nil.
source

as-boolclj/s

(as-bool x)
source

as-dtclj

(as-dt x)
source

as-emailclj/s

(as-email x)
(as-email n x)
source

as-floatclj/s

(as-float x)
source (clj)source (cljs)

as-instclj/s

(as-inst x)
source

as-intclj/s

(as-int x)
source (clj)source (cljs)

as-kwclj/s

(as-kw x)
source

as-nameclj/s

(as-name x)
source

as-nat-floatclj/s

(as-nat-float x)
source (clj)source (cljs)

as-nat-intclj/s

(as-nat-int x)
source (clj)source (cljs)

as-nblankclj/s

(as-nblank x)
source

as-nblank-trimclj/s

(as-nblank-trim x)
source

as-nemailclj/s

(as-nemail x)
(as-nemail n x)
source

as-nempty-strclj/s

(as-nempty-str x)
source

as-nzeroclj/s

(as-nzero x)
source

as-pnumclj/s

(as-pnum x)
source (clj)source (cljs)

as-pnum!clj/s

(as-pnum! x)
source (clj)source (cljs)

as-pnum-complementclj/s

(as-pnum-complement x)
source

as-pos-floatclj/s

(as-pos-float x)
source (clj)source (cljs)

as-pos-intclj/s

(as-pos-int x)
source (clj)source (cljs)

as-qnameclj/s

(as-qname x)
source

as-rnumclj/s

(as-rnum x)
source (clj)source (cljs)

as-rnum!clj/s

(as-rnum! x)
source (clj)source (cljs)

as-udtclj/s

(as-udt x)
source

assert-min-encore-versionclj/smacro

(assert-min-encore-version min-version)
Version check for dependency conflicts, etc.
source

assoc-nxclj/s

(assoc-nx m m-kvs)
(assoc-nx m k v)
(assoc-nx m k v & kvs)
Assocs each kv to given ?map iff its key doesn't already exist.
source

assoc-someclj/s

(assoc-some m m-kvs)
(assoc-some m k v)
(assoc-some m k v & kvs)
Assocs each kv to given ?map iff its value is not nil.
source

assoc-whenclj/s

(assoc-when m m-kvs)
(assoc-when m k v)
(assoc-when m k v & kvs)
Assocs each kv to given ?map iff its val is truthy.
source

atom?clj/s

(atom? x)
source (clj)source (cljs)

ba->hex-strclj

(ba->hex-str ba)
Returns byte[] for given hex string.
source

ba-concatclj

(ba-concat ba1 ba2)
source

ba-hashclj

(ba-hash x)
Returns hash int of given byte[].
source

ba-splitclj

(ba-split ba idx)
source

ba=clj

(ba= x y)
Returns true iff given two byte[]s with the same content.
source

benchclj/smacro

(bench nlaps opts & body)
source

bench*clj

(bench* nlaps
        {:keys [nlaps-warmup nthreads as-ns?] :or {nlaps-warmup 0 nthreads 1}}
        f)
Repeatedly executes fn and returns time taken to complete execution.
source

bindingclj/smacro

(binding bindings & body)
For Clj: faster version of `core/binding`.
For Cljs: identical to `core/binding`.
source

boolean?clj/s

(boolean? x)
source (clj)source (cljs)

bytes-classclj

source

bytes?clj

(bytes? x)
Returns true iff given byte[] argument.
source

cacheclj/s

(cache f)
(cache {:keys [size ttl-ms gc-every] :as opts} f)
Returns a cached version of given referentially transparent function `f`.

Like `core/memoize` but:
  - Often faster, depending on options.
  - Prevents race conditions on writes.
  - Supports cache invalidation by prepending args with:
    - `:cache/del`   ; Delete cached item for subsequent args, returns nil.
    - `:cache/fresh` ; Renew  cached item for subsequent args, returns new val.

  - Supports options:
    - `ttl-ms` ; Expire cached items after <this> many msecs.
    - `size`   ; Restrict cache size to <this> many items at the next garbage
               ; collection (GC).

    - `gc-every` ; Run garbage collection (GC) approximately once every
                 ; <this> many calls to cached fn. If unspecified, GC rate
                 ; will be determined automatically based on `size`.

See also `defn-cached`, `fmemoize`, `memoize-last`.
source

call-after-timeoutclj/s

(call-after-timeout msecs f)
(call-after-timeout impl_ msecs f)
Alpha, subject to change.
Returns a TimeoutFuture that will execute `f` after given msecs.

Does NOT do any automatic binding conveyance.

Performance depends on the provided timer implementation (`impl_`).
The default implementation offers O(logn) add, O(1) cancel, O(1) tick.

See `ITimeoutImpl` for extending to arbitrary timer implementations.
source

call-on-shutdown!clj

(call-on-shutdown! f)
Registers given nullary fn as a JVM shutdown hook.
(f) will be called sometime during shutdown. While running, it will
attempt to block shutdown.
source

can-meta?clj/s

(can-meta? x)
source (clj)source (cljs)

case-evalclj/smacro

(case-eval expr & clauses)
Like `case` but test expressions are evaluated for their compile-time value.
source

case-insensitive-str=clj/s

(case-insensitive-str= s1 s2)
Returns true iff given strings are equal, ignoring case.
source

catchingclj/smacro

(catching expr)
(catching error-type expr)
(catching try-expr error-sym catch-expr)
(catching try-expr error-sym catch-expr finally-expr)
(catching try-expr error-type error-sym catch-expr finally-expr)
Terse, cross-platform (try* expr (catch :all _)).
Arities besides #{1 2} are deprecated, prefer `try*` in these cases.
source

catching-rfclj/s

(catching-rf rf)
(catching-rf error-fn rf)
Returns wrapper around given reducing function `rf` so that if `rf`
throws, (error-fn <thrown-error> <contextual-data>) will be called.

The default `error-fn` will rethrow the original error, wrapped in
extra contextual information to aid debugging.

See also `catching-xform`.
source

catching-xformclj/s

(catching-xform xform)
(catching-xform error-fn xform)
Like `catching-rf`, but applies to a transducer (`xform`).

Makes debugging transductions much easier by greatly improving
the information provided in any errors thrown by `xform` or the
reducing fn:

  (transduce
    (catching-xform (comp (filter even?) (map inc))) ; Modified xform
    <reducing-fn>
    <...>)
source

chan?clj/s

(chan? x)
Returns true iff given a `clojure.core.async` channel.
source

chanceclj/s

(chance prob)
Returns true with given probability ∈ ℝ[0,1].
source

check-allclj/smacro

(check-all test)
(check-all test & more)
Returns all logical false/throwing expressions (ids/forms), or nil.
source

check-someclj/smacro

(check-some test)
(check-some test & more)
Returns first logical false/throwing expression (id/form), or nil.
source

clampclj/s

(clamp nmin nmax n)
source

clamp*clj/smacro

(clamp* nmin nmax n)
source

clamp-floatclj/s

(clamp-float nmin nmax n)
source

clamp-intclj/s

(clamp-int nmin nmax n)
source

class-symclj

(class-sym x)
Returns class name symbol of given argument.
source

comp-middlewareclj/s

(comp-middleware fs)
(comp-middleware f1 f2)
(comp-middleware f1 f2 f3)
(comp-middleware f1 f2 f3 & fs)
Returns a single (composite) unary fn that applies all given unary fns
sequentially (left->right!: f1, f2, ...). If any given fn returns nil, the
returned composite fn immediately returns nil:

  ((comp-middleware inc #(* % 2) inc) 1) => 5 ; (inc (* (inc 1) 2))
  ((comp-middleware inc (fn [_] nil) (fn [_] (throw (Exception. "Never thrown!")))) 1) => nil

Useful for composing Ring-style middleware fns.
source

compile-ifclj/smacro

(compile-if test then)
(compile-if test then else)
Evaluates `test`. If it returns logical true (and doesn't throw), expands
to `then`, otherwise expands to `else`.
source

compile-whenclj/smacro

(compile-when test & body)
source

condclj/smacro

(cond & clauses)
Supersets `core/cond` functionality. Like `core/cond` but supports implicit
final `else` clause, and special clause keywords for advanced behaviour:

(cond
  :let     [x   "x"] ; Establish let     binding/s for remaining forms
  :binding [*x* "x"] ; Establish dynamic binding/s for remaining forms
  :do      (println (str "x value: " x)) ; Eval expr for side-effects

  :if-let [y "y"
           z nil]
  "y and z were both truthy"

  :if-some [y "y"
            z nil]
  "y and z were both non-nil")

`:let` support inspired by <https://github.com/Engelberg/better-cond>.
Simple, flexible way to eliminate deeply-nested control flow code.
source

cond!clj/smacro

(cond! & clauses)
Like `cond` but throws on non-match like `case` and `condp`.
source

conj-someclj/s

(conj-some)
(conj-some coll)
(conj-some coll x)
(conj-some coll x & more)
Conjoins each non-nil value.
source

conj-whenclj/s

(conj-when)
(conj-when coll)
(conj-when coll x)
(conj-when coll x & more)
Conjoins each truthy value.
source

const-ba=clj

(const-ba= ba1 ba2)
Constant-time `ba=`.
Useful to prevent timing attacks, etc.
source

const-str=clj/s

(const-str= s1 s2)
Constant-time string equality checker.
Useful to prevent timing attacks, etc.
source

contains-in?clj/s

(contains-in? coll ks)
(contains-in? coll ks k)
source

convey-reducedclj/s

(convey-reduced x)
source

count-wordsclj/s

(count-words s)
source

counterclj/s

(counter)
(counter init)
Returns a fast atomic `Counter` with `init` initial integer value with:
- @counter           => Return current val
- (counter)          => Add 1 and return old val
- (counter n)        => Add n and return old val
- (counter action n) => Experimental, action ∈
    {:add :set :set-get :get-set :get-add :add-get}.
source

declare-remoteclj/smacro

(declare-remote & syms)
Declares given ns-qualified symbols, preserving metadata.
Clj only. Useful for circular dependencies.
source

def*clj/smacro

(def* sym & args)
Like `core/def` but supports attrs map.
source

defaliasclj/smacro

(defalias src)
(defalias alias src)
(defalias alias src alias-attrs)
(defalias alias src alias-attrs alias-body)
Defines a local alias for the var identified by given qualified
source symbol: (defalias my-map clojure.core/map), etc.

Source var's metadata will be preserved (docstring, arglists, etc.).
Changes to Clj source var's value will also be applied to alias.
See also `defaliases`.
source

defaliasesclj/smacro

(defaliases {:keys [alias src attrs body]} ...)
Bulk version of `defalias`.
Takes source symbols or {:keys [alias src attrs body]} maps:
  (defaliases
    {:alias my-map, :src map, :attrs {:doc "My `map` alias"}}
    {:alias my-vec, :src vec, :attrs {:doc "My `vec` alias"}})
source

default-timeout-impl_clj/s

Simple one-timeout timeout implementation provided by platform timer.
O(logn) add, O(1) cancel, O(1) tick. Fns must be non-blocking or cheap.
Similar efficiency to core.async timers (binary heap vs DelayQueue).
source

defn-cachedclj/smacro

(defn-cached sym cache-opts & body)
Defines a cached function.
Like (def <sym> (cache <cache-opts> <body...>)), but preserves
:arglists (arity) metadata as with `defn`:

  (defn-cached ^:private my-fn {:ttl-ms 500}
    "Does something interesting, caches resultes for 500 msecs"
    [n]
    (rand-int n))
source

defonceclj/smacro

(defonce sym & args)
Like `core/defonce` but supports docstring and attrs map.
source

defstubclj/smacro

(defstub stub-sym)
Experimental, subject to change without notice!!
Declares a stub var that can be initialized from any namespace with
`unstub-<stub-name>`.

Decouples a var's declaration (location) and its initialization (value).
Useful for defining vars in a shared ns from elsewhere (e.g. a private
or cyclic ns).
source

deprecatedclj/smacro

(deprecated & body)
Elides body when `taoensso.elide-deprecated` JVM property or
`TAOENSSO_ELIDE_DEPRECATED` environment variable is ∈ #{"true" "TRUE"}.
source

derefable?clj/s

(derefable? x)
source (clj)source (cljs)

dissoc-inclj/s

(dissoc-in m ks)
(dissoc-in m ks dissoc-k)
(dissoc-in m ks dissoc-k & more)
source

distinct-elements?clj/s

(distinct-elements? x)
source

doto-condclj/smacro

(doto-cond [sym x] & clauses)
Cross between `doto`, `cond->` and `as->`.
source

editable?clj/s

(editable? x)
source (clj)source (cljs)

encore-versionclj/s

source

ensure-setclj/s

(ensure-set x)
source

ensure-vecclj/s

(ensure-vec x)
source

error?clj/s

(error? x)
Returns true iff given platform error (`Throwable` or `js/Error`).
source

ex-causeclj/s

(ex-cause x)
Same as `core/ex-cause` (added in Clojure v1.10).
source

ex-dataclj/s

(ex-data x)
Same as `core/ex-data` (added in Clojure v1.4).
source

ex-messageclj/s

(ex-message x)
Same as `core/ex-message` (added in Clojure v1.10).
source

ex-rootclj/s

(ex-root x)
Returns root cause of given platform error.
source

exception?clj

(exception? x)
source

exp-backoffclj/s

(exp-backoff n-attempt)
(exp-backoff n-attempt {:keys [min max factor] :or {factor 1000}})
Returns binary exponential backoff value for n<=36.
source

explode-keywordclj/s

(explode-keyword k)
source

file-resources-modified?clj

Returns true iff any files backing given named resources have changed since last call.
source

filter-keysclj/s

(filter-keys key-pred m)
Returns given ?map, retaining only keys for which (key-pred <key>) is truthy.
source

filter-valsclj/s

(filter-vals val-pred m)
Returns given ?map, retaining only keys for which (val-pred <val>) is truthy.
source

finite-num?clj/s

(finite-num? x)
Returns true iff given a number (of standard type) that is:
finite (excl. NaN and infinities).
source

float?clj/s

(float? x)
Returns true iff given a number (of standard type) that is:
a fixed-precision floating-point (incl. NaN and infinities).
source

fmemoizeclj/s

(fmemoize f)
For Clj: fastest possible memoize. Non-racey, 0-7 arity only.
For Cljs: same as `core/memoize`.
source

force-refclj/s

(force-ref x)
Like `force` for refs.
source

force-varclj/s

(force-var x)
Like `force` for vars.
source

formatclj/s

(format fmt & args)
Like `core/format` but:
* Returns "" when fmt is nil rather than throwing an NPE.
* Formats nil as "nil" rather than "null".
* Provides ClojureScript support via goog.string.format (this has fewer
  formatting options than Clojure's `format`!).
source

format*clj/s

(format* fmt args)
(format* xform fmt args)
source

format-instclj/s

(format-inst inst)
Takes a platform instant (`java.time.Instant` or `js/Date`) and
returns a formatted human-readable string in `ISO8601` format
(`YYYY-MM-DDTHH:mm:ss.sssZ`), e.g. "2011-12-03T10:15:130Z".
source

format-inst-fnclj/s≠

clj
(format-inst-fn)
(format-inst-fn {:keys [formatter zone]
                 :or {formatter java.time.format.DateTimeFormatter/ISO_INSTANT
                      zone java.time.ZoneOffset/UTC}})
cljs
(format-inst-fn)
(format-inst-fn {:keys [formatter]})
Experimental, subject to change without notice.

Returns a (fn format [instant]) that:
  - Takes a platform instant (`java.time.Instant` or `js/Date`).
  - Returns a formatted human-readable instant string.

Options:
  `:formatter`
    Clj:  `java.time.format.DateTimeFormatter`
    Cljs: `goog.i18n.DateTimeFormat`

    Defaults to `ISO8601` formatter (`YYYY-MM-DDTHH:mm:ss.sssZ`),
    e.g.: "2011-12-03T10:15:130Z".

  `:zone` (Clj only) `java.time.ZoneOffset` (defaults to UTC).
   Note that zone may be ignored by some `DateTimeFormatter`s,
   including the default (`DateTimeFormatter/ISO_INSTANT`)!
source

format-nsecsclj/s

(format-nsecs nanosecs)
Returns given nanoseconds (long) as formatted human-readable string.
Example outputs: "1.00m", "4.20s", "340ms", "822μs", etc.
source

format-query-stringclj/s

(format-query-string m)
source

future*clj/smacro

(future* form)
(future* executor-service form)
Experimental, subject to change without notice!
Like `future` but supports use of given custom
`java.util.concurrent.ExecutorService`.

Will default to using JVM 21+ virtual threads when possible,
otherwise an unbounded fixed daemon thread pool.

See also `future-call`, `virtual-executor`, `pool-executor`.
source

future-call*clj

(future-call* f)
(future-call* executor-service f)
Experimental, subject to change without notice!
Like `future-call` but supports use of given custom
`java.util.concurrent.ExecutorService`.

Will default to using JVM 21+ virtual threads when possible,
otherwise an unbounded fixed daemon thread pool.

See also `future`, `virtual-executor`, `pool-executor`.
source

future-poolclj

(future-pool n-threads)
Returns a simple semaphore-limited wrapper of Clojure's standard `future`:
  (fn future-pool-fn
    ([f] [timeout-msecs timeout-val f] [] [timeout-msecs timeout-val]))

  Arities of returned function:
    [f]  - Blocks to acquire a   future,  then executes (f) on that future.
    [ ]  - Blocks to acquire ALL futures, then immediately releases them.
           Useful for blocking till all outstanding work completes.

    [timeout-msecs timeout-val f] - Variant of [f] with timeout
    [timeout-msecs timeout-val  ] - Variant of [ ] with timeout

See also `future*` for fully custom pools, etc.
source

get*clj/smacro

(get* m k)
(get* m k not-found)
(get* m k1 k2 not-found)
(get* m k1 k2 k3 not-found)
Macro version of `get` that:

  1. Avoids unnecessary evaluation of `not-found`.
     Useful when `not-found` is expensive or contains side-effects.

  2. Supports multiple prioritized keys (k1, k2, etc.). Returns val for
     first key that exists in map. Useful for key aliases or fallbacks.

Equivalent to:

  (cond
    (contains? m k1) (get m k1)
    (contains? m k2) (get m k2)
    ...
    :else            not-found)
source

get-envclj/smacro

(get-env {:keys [as default return] :or {as :str return :value}} spec)
Flexible cross-platform util to return an environmental config value.

Given an id (const keyword/string) or vector of desc-priority alternative
ids, parse and return the first of the following that exists:
  - JVM         property value   for id
  - Environment variable value   for id
  - Classpath   resource content for id

Ids may include optional segment in `<>` tag (e.g. `<.edn>`).
Ids may include `<.?platform.?>` tag for auto replacement:
  `<.platform>` => ".clj" / ".cljs"
  `<platform->` => "clj-" / "cljs-", etc.

Search order: desc by combined [alt-index platform(y/n) optional(y/n)].

So (get-env {:as :edn} [:my-app/alt1<.platform><.edn> :my-app/alt2])
will parse and return the first of the following that exists:

  1. Alt1 +platform +optional (optional .edn suffix)
    1a. `my-app.alt1.clj.edn` JVM         property value
    1b. `MY_APP_ALT1_CLJ_EDN` environment variable value
    1c. `my-app.alt1.clj.edn` classpath   resource content

  2. Alt1 +platform -optional (optional .edn suffix)
    2a. `my-app.alt1.clj`     JVM         property value
    2b. `MY_APP_ALT1_CLJ`     environment variable value
    2c. `my-app.alt1.clj`     classpath   resource content

  3. Alt1 -platform +optional (optional .edn suffix)
    3a. `my-app.alt1.edn`     JVM         property value
    3b. `MY_APP_ALT1_EDN`     environment variable value
    3c. `my-app.alt1.edn`     classpath   resource content

  4. Alt1 -platform -optional (optional .edn suffix)
    4a. `my-app.alt1`         JVM         property value
    4b. `MY_APP_ALT1`         environment variable value
    4c. `my-app.alt1`         classpath   resource content

  5. Alt2
    5a. `my-app.alt2`         JVM         property value
    5b. `MY_APP_ALT2`         environment variable value
    5c. `my-app.alt2`         classpath   resource content

Options:
  `:as`      - Parse found value as given type ∈ #{:str :bool :edn} (default `:str`).
  `:default` - Fallback to return unparsed if no value found during search (default `nil`).
  `:return`  - Return type ∈ #{:value :map :explain} (default `:value`).

For Cljs: resulting config value must be something that can be safely
          embedded in code during macro expansion!

Advanced: if resulting config value is a single top-level symbol, it will
          be evaluated during macro expansion.

TIP!: Use the {:return :explain} option in tests or at the REPL to
      verify/inspect resulting config value, config source, and specific
      search order of prop/env/res ids.
source

get-file-resource-?last-modifiedclj

(get-file-resource-?last-modified rname)
Returns last-modified time for file backing given named resource, or nil
if file doesn't exist.
source

get-pom-versionclj

(get-pom-version dep-sym)
Returns POM version string for given Maven dependency, or nil.
source

get-sourceclj

(get-source macro-form-or-meta macro-env)
Returns {:keys [ns line column file]} source location given a macro's
compile-time `&form` and `&env` vals. See also `keep-callsite`.
source

get-truss-dataclj/s

(get-truss-data)
Returns current value of dynamic assertion data.
source

get-win-loccljs

(get-win-loc)
Returns current window location as
{:keys [href protocol hostname host pathname search hash]}.
source

get1clj/s

(get1 m k)
(get1 m k not-found)
(get1 m k1 k2 not-found)
(get1 m k1 k2 k3 not-found)
Like `get` but returns val for first key that exists in map.
Useful for key aliases or fallbacks. See also `get*`.
source

haveclj/smacro

(have x)
(have pred (:in) x)
(have pred (:in) x & more-xs)
Takes a (fn pred [x]) => truthy, and >=1 vals.
Tests pred against each val,trapping errors.

If any pred test fails, throws a detailed `ExceptionInfo`.
Otherwise returns input val/s for convenient inline-use/binding.

Respects `*assert*`, so tests can be elided from production if desired
(meaning zero runtime cost).

Provides a small, simple, flexible feature subset to alternative tools like
clojure.spec, core.typed, prismatic/schema, etc.

Examples:

  (defn my-trim [x] (str/trim (have string? x)))

  ;; Attach arb optional info to violations using `:data`:
  (have string? x
    :data {:my-arbitrary-debug-info "foo"})

  ;; Assert inside collections using `:in`:
  (have string? :in ["foo" "bar"])

Regarding use within other macros:
  Due to CLJ-865, callsite info like line number of outer macro
  will be lost. See `keep-callsite` for workaround.

See also `have?`, `have!`.
source

have!clj/smacro

(have! x)
(have! pred (:in) x)
(have! pred (:in) x & more-xs)
Like `have` but ignores `*assert*` value (so can never be elided!).
Useful for important conditions in production (e.g. security checks).
source

have!?clj/smacro

(have!? x)
(have!? pred (:in) x)
(have!? pred (:in) x & more-xs)
Returns `true` on successful tests, and ignores `*assert*` value
(so can never be elided!).

**WARNING**: Do NOT use in `:pre`/`:post` conditions since those always
respect `*assert*`, contradicting the intention of the bang (`!`) here.
source

have-core-async?clj/s

Is `clojure.core.async` present (not necessarily loaded)?
source

have?clj/smacro

(have? x)
(have? pred (:in) x)
(have? pred (:in) x & more-xs)
Like `have` but returns `true` on successful tests.
Handy for `:pre`/`:post` conditions. Compare:
  ((fn my-fn [] {:post [(have  nil? %)]} nil)) ; {:post [nil ]} FAILS
  ((fn my-fn [] {:post [(have? nil? %)]} nil)) ; {:post [true]} passes as intended
source

hex-ident-strclj

(hex-ident-str obj)
Returns hex string of given Object's `identityHashCode` (e.g. "5eeb49f2").
source

hex-str->baclj

(hex-str->ba s)
Returns hex string for given byte[].
source

host-infoclj

(host-info)
(host-info fallback-val)
(host-info timeout-msecs fallback-val)
(host-info cache-msecs timeout-msecs fallback-val)
Returns ?{:keys [ip name]} with string vals or `fallback-val` (default nil).
Arities 0 and 3 are   cached, prefer these!
Arities 1 and 2 are uncached and intended for advanced users only.
source

host-ipclj

(host-ip)
(host-ip fallback-val)
(host-ip timeout-msecs fallback-val)
(host-ip cache-msecs timeout-msecs fallback-val)
Returns local host IP string or `fallback-val` (default nil).
Arities 0 and 3 are   cached, prefer these!
Arities 1 and 2 are uncached and intended for advanced users only.
source

hostnameclj

(hostname)
(hostname fallback-val)
(hostname timeout-msecs fallback-val)
(hostname cache-msecs timeout-msecs fallback-val)
Returns local hostname string or `fallback-val` (default nil).
Arities 0 and 3 are   cached, prefer these!
Arities 1 and 2 are uncached and intended for advanced users only.
source

ident?clj/s

(ident? x)
source

identical-kw?clj/smacro

(identical-kw? x y)
Returns true iff two keywords are identical.
Portable and maximally fast.
  For Clj  this expands to: `(identical?         x y)`
  For Cljs this expands to: `(keyword-identical? x y)`
source

if-cljclj/smacro

(if-clj then & [else])
source

if-cljsclj/smacro

(if-cljs then & [else])
source

if-letclj/smacro

(if-let bindings then)
(if-let bindings then else)
Supersets `core/if-let` functionality. Like `core/if-let` but supports multiple
bindings, and unconditional bindings with `:let`:

(if-let [x       (rand-nth [:x1 :x2 false nil    ])  ; Bind truthy x, or -> `else`
         :let [y (rand-nth [:y1 :y2 false nil x  ])] ; Bind any    y
         z       (rand-nth [:z1 :z2 false nil x y])  ; Bind truthy z, or -> `else`
         ]
  [:then-clause x y z]
  [:else-clause])
source

if-notclj/smacro

(if-not test-or-bindings then)
(if-not test-or-bindings then else)
Supersets `core/if-not` functionality.
Same as `encore/if-let` with `then` `and `else` forms swapped.
source

if-someclj/smacro

(if-some bindings then)
(if-some bindings then else)
Supersets `core/if-some` functionality. Like `core/if-some` but supports multiple
bindings, and unconditional bindings with `:let`:

(if-some [x       (rand-nth [:x1 :x2 false nil    ])  ; Bind non-nil x, or -> `else`
          :let [y (rand-nth [:y1 :y2 false nil x  ])] ; Bind any     y
          z       (rand-nth [:z1 :z2 false nil x y])  ; Bind non-nil z, or -> `else`
          ]
  [:then-clause x y z]
  [:else-clause])
source

indexed?clj/s

(indexed? x)
source (clj)source (cljs)

inst->udtclj/s≠

(inst->udt inst)
clj
Returns given `java.time.Instant` as milliseconds since Unix epoch.
cljs
Returns given `js/Date` as milliseconds since Unix epoch.
source (clj)source (cljs)

inst?clj/s

(inst? x)
Returns true iff given platform instant (`java.time.Instant` or `js/Date`).
source

instance!clj/smacro

(instance! class arg)
(instance! class arg {:keys [msg context param ...]})
(instance! class arg & {:keys [msg context param ...]})
If (instance? class arg) is true, returns arg.
Otherwise throws runtime `ExceptionInfo` with `unexpected-arg!`.
See `unexpected-arg!` for more info.
source

int?clj/s

(int? x)
Returns true iff given a number (of standard type) that is:
a fixed-precision integer.
source

interleave-allclj/s

(interleave-all)
(interleave-all c1)
(interleave-all c1 c2)
(interleave-all c1 c2 & colls)
Like `interleave` but includes all items (i.e. stops when the longest
rather than shortest coll has been consumed).
source

interns-overviewclj

(interns-overview)
(interns-overview ns)
Returns {:keys [api public private impl test no-doc]}, with each key mapped
to an alphabetical list of the relevant vars in given namespace.

"impl" vars are public vars with names that begin with "-" or "_",
a naming convention commonly used to indicate vars intended to be treated
as private implementation details even when public.
source

into!clj/s

(into! to!)
(into! to! from)
(into! to! xform from)
Like `into` but assumes `to!` is a transient, and doesn't call
`persist!` when done. Useful as a performance optimization in some cases.
source

into-allclj/s

(into-all to from)
(into-all to from & more)
Like `into` but supports multiple "from"s.
source

into-strclj/s

(into-str & xs)
Simple Hiccup-like string templating to complement Tempura.
source

invert-mapclj/s

(invert-map m)
Returns given ?map with keys and vals inverted, dropping non-unique vals!
source

invert-map!clj/s

(invert-map! m)
Like `invert-map` but throws on non-unique vals.
source

is!clj/s

(is! x)
(is! pred x)
(is! pred x data)
Lightweight `have!` that provides less diagnostic info.
source

ITimeoutFutureclj/sprotocol

tf-cancel!clj/s

(tf-cancel! _)
Returns true iff the timeout was successfully cancelled (i.e. was previously pending).

tf-cancelled?clj/s

(tf-cancelled? _)
Returns true iff the timeout is cancelled.

tf-done?clj/s

(tf-done? _)
Returns true iff the timeout is not pending (i.e. has a completed result or is cancelled).

tf-pending?clj/s

(tf-pending? _)
Returns true iff the timeout is pending.

tf-pollclj/s

(tf-poll _)
Returns :timeout/pending, :timeout/cancelled, or the timeout's completed result.

tf-stateclj/s

(tf-state _)
Returns a map of timeout's public state.
source

ITimeoutImplclj/sprotocol

-schedule-timeoutclj/s

(-schedule-timeout _ msecs f)
source

java-versionclj

(java-version)
(java-version version-string)
Returns Java's major version integer (8, 17, etc.).
source

java-version>=clj

(java-version>= n)
Returns true iff Java's major version integer is >= given integer:
(if (java-version>= 21) <then> <else>)
source

keep-callsiteclj/smacro

(keep-callsite form)
The long-standing CLJ-865 means that it's not possible for an inner
macro to access the `&form` metadata of a wrapping outer macro. This
means that wrapped macros lose calsite info, etc.

This util offers a workaround for macro authors:
  (defmacro inner [] (meta &form))
  (defmacro outer [] (keep-callsite `(inner)))
  (outer) => {:keys [line column ...]}
source

keys-byclj/s

(keys-by f coll)
Returns {(f x) x} ?map for xs in `coll`.
source

ks-nnil?clj/s

(ks-nnil? ks m)
source

ks<=clj/s

(ks<= ks m)
source

ks=clj/s

(ks= ks m)
source

ks>=clj/s

(ks>= ks m)
source

lazy-seq?clj/s

(lazy-seq? x)
source (clj)source (cljs)

logcljs

source

logfcljs

(logf fmt & xs)
source

logpcljs

(logp & xs)
source

map-entryclj/s

(map-entry k v)
Returns a `MapEntry` with given key and value.
source

map-keysclj/s

(map-keys key-fn m)
Returns given ?map with (key-fn <key>) keys.
source

map-valsclj/s

(map-vals val-fn m)
Returns given ?map with (val-fn <val>) vals.
source

mapplyclj/s

(mapply f & args)
Like `apply` but calls `seq-kvs` on final arg.
source

matching-errorclj/s

(matching-error err)
(matching-error kind err)
(matching-error kind pattern err)
Given a platform error and criteria, returns the error if it matches
all criteria. Otherwise returns nil.

`kind` may be:
  - A predicate function, (fn match? [x]) -> bool
  - A class (e.g. `ArithmeticException`, `AssertionError`, etc.)
  - `:all`     => any    platform error (Throwable or js/Error, etc.)
  - `:common`  => common platform error (Exception or js/Error)
  - `:ex-info` => an `IExceptionInfo` as created by `ex-info`
  - A set of `kind`s as above, at least one of which must match

`pattern` may be:
  - A string or Regex against which `ex-message` must match
  - A map             against which `ex-data`    must match using `submap?`
  - A set of `pattern`s as above, at least one of which must match

When an error with (nested) causes doesn't match, a match will be attempted
against its (nested) causes.

Low-level util, see also `throws`, `throws?`.
source

max*clj/smacro

(max* n1 n2)
source

max-longclj/s

source

memoizeclj/s

(memoize f)
(memoize ttl-ms f)
(memoize size ttl-ms f)
Alternative way to call `cache`, provided mostly for back compatibility.
See `cache` docstring for details.
source

memoize-lastclj/s

(memoize-last f)
Like `core/memoize` but only caches the given fn's latest input.
Speeds repeated fn calls with the same arguments.
Great for ReactJS render fn caching, etc.
source

mergeclj/s

(merge)
(merge m1)
(merge m1 m2)
(merge m1 m2 m3)
(merge m1 m2 m3 & more)
Like `core/merge` but:
- Supports `:merge/dissoc` vals.
- Often faster, with much better worst-case performance.
source

merge-keywordsclj/s

(merge-keywords ks)
(merge-keywords ks omit-slash?)
source

merge-metaclj/s

(merge-meta x m)
source

merge-nxclj/s

(merge-nx)
(merge-nx m1)
(merge-nx m1 m2)
(merge-nx m1 m2 m3)
(merge-nx m1 m2 m3 & more)
Like `core/merge` but:
- Preserves existing values, e.g. (merge-nx <user-opts> <defaults>).
- Supports `:merge/dissoc` vals.
- Often faster, with much better worst-case performance.
source

merge-url-with-query-stringclj/s

(merge-url-with-query-string url m)
source

merge-withclj/s

(merge-with f)
(merge-with f m1)
(merge-with f m1 m2)
(merge-with f m1 m2 m3)
(merge-with f m1 m2 m3 & more)
Like `core/merge-with` but:
- Supports `:merge/dissoc` vals.
- Often faster, with much better worst-case performance.
source

min*clj/smacro

(min* n1 n2)
source

min-longclj/s

source

msclj/s

(ms opts)
(ms & {:as opts :keys [years months weeks days hours mins secs msecs ms]})
Returns ~number of milliseconds in period defined by given args.
source

ms->secsclj/s

(ms->secs ms)
source

msecsclj/smacro

(msecs opts)
(msecs & {:as opts :keys [years months weeks days hours mins secs msecs ms]})
Macro version of `ms`.
source

name-filterclj/s

(name-filter spec)
Given filter `spec`, returns a compiled (fn match? [x]) that:
  - Takes a string, keyword, symbol, or namespace.
  - Returns true iff input matches spec.

Useful for efficiently filtering namespaces, class names, id kws, etc.

Spec may be:
  - A namespace     to match exactly
  - A regex pattern to match
  - A str/kw/sym    to match, with "*" and "(.*)" as wildcards:
    "foo.*"   will match "foo.bar"
    "foo(.*)" will match "foo.bar" and "foo"
    If you need literal "*"s, use #"\*" regex instead.

  - A set/vector of the above to match any
  - A map, {:allow <spec> :disallow <spec>} with specs as the above:
    If present,    `:allow` spec MUST     match, AND
    If present, `:disallow` spec MUST NOT match.

Spec examples:
  *ns*, #{}, "*", "foo.bar", "foo.bar.*", "foo.bar(.*)",
  #{"foo" "bar.*"}, #"(foo1|foo2)\.bar",
  {:allow #{"foo" "bar.*"} :disallow #{"foo.*.bar.*"}}.
source

name-with-attrsclj/s

(name-with-attrs sym args)
(name-with-attrs sym args attrs-merge)
Given a symbol and args, returns [<name-with-attrs-meta> <args> <attrs>]
with support for `defn` style `?docstring` and `?attrs-map`.
source

nameable?clj/s

(nameable? x)
source

named?clj/s

(named? x)
source (clj)source (cljs)

nanoidclj/s≠

clj
(nanoid)
(nanoid len)
(nanoid secure? len)
cljs
(nanoid)
(nanoid len)
(nanoid prefer-secure? len)
Returns a random "Nano ID" of given length, Ref. <https://github.com/ai/nanoid>.
Faster, variable-length version of (rand-id-fn {:chars :nanoid}).
126 bits of entropy with default length (21).
See also `uuid-str`, `rand-id-fn`.
source

nat-float?clj/s

(nat-float? x)
source

nat-int?clj/s

(nat-int? x)
source

nat-num?clj/s

(nat-num? x)
source

nblank-str?clj/s

(nblank-str? x)
source

nblank?clj/s

(nblank? x)
source

neg-float?clj/s

(neg-float? x)
source

neg-int?clj/s

(neg-int? x)
source

neg-num?clj/s

(neg-num? x)
source

nempty-str?clj/s

(nempty-str? x)
source (clj)source (cljs)

nested-mergeclj/s

(nested-merge)
(nested-merge m1)
(nested-merge m1 m2)
(nested-merge m1 m2 m3)
(nested-merge m1 m2 m3 & more)
Like `core/merge` but:
- Recursively merges nested maps.
- Supports `:merge/dissoc` vals.
- Often faster, with much better worst-case performance.
source

nested-merge-withclj/s

(nested-merge-with f)
(nested-merge-with f m1)
(nested-merge-with f m1 m2)
(nested-merge-with f m1 m2 m3)
(nested-merge-with f m1 m2 m3 & more)
Like `core/merge-with` but:
- Recursively merges nested maps.
- Supports `:merge/dissoc` vals.
- Often faster, with much better worst-case performance.
source

new-objectclj/smacro

(new-object)
source

newlineclj/s

Single system newline
source

newlinesclj/s

Double system newline
source

nneg?clj/s

(nneg? x)
source

nnilclj/s

(nnil)
(nnil x)
(nnil x y)
(nnil x y z)
(nnil x y z & more)
Returns first non-nil arg, or nil.
source

node-pathsclj/s

(node-paths m)
(node-paths node-pred m)
(node-paths node-pred m basis)
source

node-target?cljs

source

norm-strclj

(norm-str s)
(norm-str form s)
Given a Unicode string, returns the normalized de/composed form.
It's often a good idea to normalize strings before exchange or storage,
especially if you're going to be querying against those string.

`form` is ∈ #{:nfc :nfkc :nfd :nfkd <java.text.NormalizerForm>}.
Defaults to :nfc as per W3C recommendation.
source

norm-word-breaksclj/s

(norm-word-breaks s)
Converts all word breaks of any form and length (including line breaks of any
form, tabs, spaces, etc.) to a single regular space.
source

normalize-headersclj

(normalize-headers rreq-or-rresp)
source

not-empty-collclj/s

(not-empty-coll x)
source

now-dtclj/s≠

(now-dt)
clj
Returns current system instant as `java.util.Date`.
cljs
Returns current system instant as `js/Date`.
source (clj)source (cljs)

now-instclj/s≠

(now-inst)
clj
Returns current system instant as `java.time.Instant`.
cljs
Returns current system instant as `js/Date`.
source (clj)source (cljs)

now-nanoclj/s≠

clj
(now-nano)
cljs
Returns current value of best-resolution time source as nanoseconds.
source (clj)source (cljs)

now-udtclj/s≠

(now-udt)
clj
Returns current system instant as milliseconds since Unix epoch.
cljs
Returns current system insant as milliseconds since Unix epoch.
source (clj)source (cljs)

nzero-num?clj/s

(nzero-num? x)
source

ogetcljs

(oget k)
(oget o k)
(oget o k not-found)
Like `get` for JS objects.
source

oget-incljs

(oget-in ks)
(oget-in o ks)
(oget-in o ks not-found)
Like `get-in` for JS objects.
source

or-someclj/smacro

(or-some)
(or-some x)
(or-some x & next)
Like `or`, but returns the first non-nil form (may be falsey).
source

osetcljs

(oset o k v)
Like `assoc` for JS objects.
source

oset-incljs

(oset-in o ks v)
Experimental, subject to change without notice.
Like `assoc-in` for JS objects.
source

parse-js-intcljs

(parse-js-int s)
source

parse-query-paramsclj/s

(parse-query-params s & [keywordize? encoding])
Based on `ring-codec/form-decode`.
source

parse-versionclj/s

(parse-version x)
source

pathclj/s

(path & parts)
source

percclj/s

(perc n divisor)
source

pnum-complementclj/s

(pnum-complement pnum)
source

pnum?clj/s

(pnum? x)
Returns true iff given number in unsigned unit proportion interval ∈ℝ[0,1].
source

pool-executorclj

(pool-executor {:keys [n-threads n-min-threads n-max-threads thread-name-prefix
                       daemon-threads? keep-alive-msecs queue-type queue-size]
                :or {n-threads (+ 2 (get-num-threads [:ratio 1.0]))
                     thread-name-prefix "com.taoensso/encore-pool-"
                     daemon-threads? true
                     keep-alive-msecs 60000
                     queue-type :linked}})
Experimental, subject to change without notice!
Returns new `java.util.concurrent.ThreadPoolExecutor` with given opts.
source

pos-float?clj/s

(pos-float? x)
source

pos-int?clj/s

(pos-int? x)
source

pos-num?clj/s

(pos-num? x)
source

powclj/s

(pow n exp)
source

prclj/s≠

clj
(pr & args)
Like `core/pr` but faster, and atomic (avoids interleaved content from different threads).
cljs
Identical to `core/pr`.
source (clj)source (cljs)

pr-ednclj/s

(pr-edn x)
Prints given arg to an edn string readable with `read-edn`.
source

pr-jsoncljs

(pr-json x)
Returns given Cljs argument as JSON string.
source

pre-cacheclj

(pre-cache n-capacity f)
(pre-cache n-capacity fp-or-n-threads f)
Given a nullary fn `f` that is non-idempotent and free of side-effects,
returns a wrapped version of `f` that asynchronously maintains a cache
of up to `n-capacity` pre-computed return values of (f).

Useful when `f` is expensive & may be called in a spikey fashion,
e.g. ideal for cryptographic key generators.
source

predclj/s

(pred pred-fn)
Experimental, subject to change without notice.
Wraps given predicate fn to return `Pred` for use with `submap?`, etc.
Arity of predicate fn depends on context in which it'll be used.
See also `pred-fn`.
source

pred-fnclj/s

(pred-fn pred)
Experimental, subject to change without notice.
Returns unwrapped predicate fn when given `Pred`, otherwise returns nil.
See also `pred`.
source

preserve-reducedclj/s

(preserve-reduced rf)
Public version of `core/preserving-reduced`.
source

printclj/s≠

clj
(print & args)
Like `core/print` but faster, and atomic (avoids interleaved content from different threads).
cljs
Identical to `core/print`.
source (clj)source (cljs)

printlnclj/s≠

clj
(println & args)
Like `core/println` but faster, and atomic (avoids interleaved content from different threads).
cljs
Identical to `core/println`.
source (clj)source (cljs)

prnclj/s≠

clj
(prn & args)
Like `core/prn` but faster, and atomic (avoids interleaved content from different threads).
cljs
Identical to `core/prn`.
source (clj)source (cljs)

pull-val!clj/s

(pull-val! atom_ k)
(pull-val! atom_ k not-found)
Removes and returns value mapped to key:
(let [a (atom {:k :v})]
  [(pull-val! a :k) @a]) => [:v {}]
source

qbclj/smacro

(qb spec form)
(qb spec form & more)
Simple util to benchmark/compare runtime of given form/s.

Runs sets of laps for each given form, recording the total runtime of each set.
Returns the the total runtime in msecs of the fastest set of laps for each form.

  (quick-bench [<num-sets> <num-laps>] <form1> <form2> <...>) =>
    [<total runtime msecs of fastest set of laps for form1>
     <total runtime msecs of fastest set of laps for form2>
     <...>]

   Total number of runs for each form is: `num-sets` * `num-laps`

If omitted, the default `num-sets` is 6 (to include warmup):
  (quick-bench <num-laps> <form1> <form2> <...>)

Example (comparing runtime of `first` and `nth` against vector):
  (let [v [:a]] (quick-bench 1e6 (first v) (nth v 0))) => [67.43 39.05]
source

qualified-ident?clj/s

(qualified-ident? x)
source

qualified-keyword?clj/s

(qualified-keyword? x)
source

qualified-symbol?clj/s

(qualified-symbol? x)
source

queueclj/s

(queue)
(queue coll)
Returns a new `PersistentQueue`.
source

queue*clj/s

(queue* & items)
Returns a new `PersistentQueue` given items.
source

queue?clj/s

(queue? x)
Returns true iff given a `PersistentQueue`.
source

quick-benchclj/smacro

(quick-bench spec form)
(quick-bench spec form & more)
Simple util to benchmark/compare runtime of given form/s.

Runs sets of laps for each given form, recording the total runtime of each set.
Returns the the total runtime in msecs of the fastest set of laps for each form.

  (quick-bench [<num-sets> <num-laps>] <form1> <form2> <...>) =>
    [<total runtime msecs of fastest set of laps for form1>
     <total runtime msecs of fastest set of laps for form2>
     <...>]

   Total number of runs for each form is: `num-sets` * `num-laps`

If omitted, the default `num-sets` is 6 (to include warmup):
  (quick-bench <num-laps> <form1> <form2> <...>)

Example (comparing runtime of `first` and `nth` against vector):
  (let [v [:a]] (quick-bench 1e6 (first v) (nth v 0))) => [67.43 39.05]
source

rand-bytesclj/s≠

clj
(rand-bytes secure? size)
cljs
(rand-bytes prefer-secure? size)
Returns a random byte array of given size.
source

rand-id-fnclj/s

(rand-id-fn {:keys [chars len rand-bytes-fn]
             :or
               {chars :nanoid len 21 rand-bytes-fn (partial rand-bytes true)}})
Returns a (fn rand-id []) that returns random id strings.
Options include:
  `:chars`         - ∈ #{<string> :nanoid :alphanumeric :no-look-alikes ...}
  `:len`           - Length of id strings to generate
  `:rand-bytes-fn` - Optional (fn [size]) to return random byte array of given size

See also `uuid-str`, `nano-id`.
source

rate-limiterclj/s

(rate-limiter spec)
(rate-limiter opts spec)
Takes a spec of form
  [           [<n-max-reqs> <msecs-window>] ...] or ; Unnamed limits
  {<limit-id> [<n-max-reqs> <msecs-window>]}        ;   Named limits
and returns stateful (fn a-rate-limiter [] [req-id] [command req-id]).

Call the returned limiter fn with a request id (any Clojure value!) to
enforce limits independently for each id.

For example, (limiter-fn <ip-address-string>) will return:
  - Falsey when    allowed (all limits pass for given IP), or
  - Truthy when disallowed (any limits fail for given IP):
    [<worst-limit-id> <worst-backoff-msecs> {<limit-id> <backoff-msecs>}]

Or call the returned limiter fn with an extra command argument:
  (limiter-fn :rl/peek  <req-id) - Check limits WITHOUT incrementing count
  (limiter-fn :rl/reset <req-id) - Reset all limits for given req-id
source

rcompareclj/s

(rcompare x y)
Reverse comparator.
source (clj)source (cljs)

re-pattern?clj/s

(re-pattern? x)
source (clj)source (cljs)

read-ednclj/s≠

clj
(read-edn s)
(read-edn {:keys [readers default]
           :as opts
           :or {readers clojure.core/*data-readers*
                default clojure.core/*default-data-reader-fn*}})
cljs
(read-edn s)
(read-edn {:keys [readers default]
           :as opts
           :or {readers (clojure.core/deref cljs.reader/*tag-table*)
                default (clojure.core/deref
                          cljs.reader/*default-data-reader-fn*)}})
Reads given edn string to return a Clj/s value.
source

read-jsoncljs

(read-json s)
(read-json kw-keys? s)
Reads given JSON string to return a Cljs value.
source

reassoc-someclj/s

(reassoc-some m m-kvs)
(reassoc-some m k v)
(reassoc-some m k v & kvs)
Assocs each kv to given ?map if its value is nil, otherwise dissocs it.
source

reduce-indexedclj/s

(reduce-indexed rf init coll)
Like `reduce` but takes (rf [acc idx in]) with idx as in `map-indexed`.
As `reduce-kv` against vector coll, but works on any seqable coll type.
source

reduce-interleave-allclj/s

(reduce-interleave-all rf init colls)
Reduces sequence of elements interleaved from given `colls`.
(reduce-interleave-all conj [] [[:a :b] [1 2 3]]) => [:a 1 :b 2 3]
source

reduce-iterator!clj

(reduce-iterator! rf init iterator)
Reduces given `java.util.Iterator`, mutating it. Note that most colls
providing iterators implement `java.lang.Iterable`, so support `seq` directly.
source

reduce-kvsclj/s

(reduce-kvs rf init kvs)
Like `reduce-kv` but takes a flat sequence of kv pairs.
source

reduce-multiclj/s

(reduce-multi rf init coll)
(reduce-multi rf1 init1 rf2 init2 coll)
(reduce-multi rf1 init1 rf2 init2 rf3 init3 coll)
Like `reduce` but supports separate simultaneous accumulators
as a micro-optimization when reducing a large collection multiple
times.
source

reduce-nclj/s

(reduce-n rf init end)
(reduce-n rf init start end)
(reduce-n rf init start end step)
No longer useful with Clojure 1.7+, just use (reduce f init (range ...)).
source

reduce-objcljs

(reduce-obj f init o)
Like `reduce-kv` but for JavaScript objects.
source

reduce-topclj/s

(reduce-top n rf init coll)
(reduce-top n keyfn rf init coll)
(reduce-top n keyfn cmp rf init coll)
Reduces the top `n` items from `coll` of N items.
Clj impln is O(N.logn) vs O(N.logN) for (take n (sort-by ...)).
source

reduce-zipclj/s

(reduce-zip rf init xs ys)
(reduce-zip rf init xs ys not-found)
Reduces given sequential xs and ys as pairs (e.g. key-val pairs).
Calls (rf acc x y) for each sequential pair.

Useful, among other things, as a more flexible version of `zipmap`.
source

remove-keysclj/s

(remove-keys key-pred m)
Returns given ?map, removing keys for which (key-pred <key>) is truthy.
source

remove-valsclj/s

(remove-vals val-pred m)
Returns given ?map, removing keys for which (val-pred <val>) is truthy.
source

rename-keysclj/s

(rename-keys replacements m)
Returns a map like the one given, replacing keys using
given {<old-new> <new-key>} replacements. O(min(n_replacements, n_m)).
source

repeatedly-intoclj/s

(repeatedly-into coll n f)
Like `repeatedly` but faster and `conj`s items into given collection.
source

reset!?clj/s

(reset!? atom_ val)
Atomically swaps value of `atom_` to `val` and returns
true iff the atom's value changed. See also `reset-in!?`.
source

reset-in!clj/s

(reset-in! atom_ val)
(reset-in! atom_ ks val)
(reset-in! atom_ ks not-found val)
Like `reset!` but supports `update-in` semantics, returns <old-key-val>.
source

reset-in!?clj/s

(reset-in!? atom_ val)
(reset-in!? atom_ ks val)
(reset-in!? atom_ ks not-found val)
Like `reset-in!` but returns true iff the atom's value changed.
source

reset-val!clj/s

(reset-val! atom_ k val)
(reset-val! atom_ k not-found val)
Like `reset-in!` but optimized for single-key case.
source

reset-val!?clj/s

(reset-val!? atom_ k new-val)
Like `reset-in!?` but optimized for single-key case.
source

resolve-symclj

(resolve-sym sym)
(resolve-sym macro-env sym)
(resolve-sym macro-env sym may-require-ns?)
Returns resolved qualified Clj/s symbol, or nil.
source

revery-kv?clj/s

(revery-kv? pred coll)
source

revery?clj/s

(revery? pred coll)
(revery? xform pred coll)
source

rfirstclj/s

(rfirst pred coll)
(rfirst xform pred coll)
source

rfirst-kvclj/s

(rfirst-kv pred coll)
source

ring-default-headersclj

(ring-default-headers headers rresp)
source

ring-merge-headersclj

(ring-merge-headers headers rresp)
source

ring-redirect-respclj

(ring-redirect-resp url)
(ring-redirect-resp kind url)
(ring-redirect-resp kind url flash)
source

ring-resp-mapclj

(ring-resp-map x)
source

ring-set-bodyclj

(ring-set-body body rresp)
source

ring-set-headersclj

(ring-set-headers headers rresp)
source

ring-set-statusclj

(ring-set-status code rresp)
source

rnum?clj/s

(rnum? x)
Returns true iff given number in signed unit proportion interval ∈ℝ[-1,1].
source

rolling-counterclj/s

(rolling-counter msecs)
Experimental, subject to change without notice.
Returns a RollingCounter that you can:
  - Invoke to increment count in last `msecs` window and return RollingCounter.
  - Deref  to return    count in last `msecs` window.
source

rolling-listclj

(rolling-list nmax)
(rolling-list nmax {:keys [init-val]})
Returns a stateful fn of 2 arities:
  [ ] => Returns current array in O(n).
  [x] => Adds `x` to right of list, maintaining length <~ `nmax`.
         Returns nil. Very fast (faster than `rolling-vector`).

Useful for maintaining limited-length histories, etc.
See also `rolling-vector`.
source

rolling-vectorclj/s

(rolling-vector nmax)
(rolling-vector nmax {:keys [gc-every init-val] :or {gc-every 16000.0}})
Returns a stateful fn of 2 arities:
  [ ] => Returns current sub/vector in O(1).
  [x] => Adds `x` to right of sub/vector, maintaining length <= `nmax`.
         Returns current sub/vector.

Useful for maintaining limited-length histories, etc.
See also `rolling-list` (Clj only).
source

roundclj/s

(round n)
(round kind n)
(round kind precision n)
General purpose rounding util.
Returns given number `n` rounded according to given options:
  - `kind`      - ∈ #{:round :floor :ceil :trunc}     (default `:round`)
  - `precision` - Number of decimal places to include (default `nil` => none)
source

round0clj/s

(round0 n)
source

round1clj/s

(round1 n)
source

round2clj/s

(round2 n)
source

roundnclj/s

(roundn precision n)
source

rsomeclj/s

(rsome pred coll)
(rsome xform pred coll)
source

rsome-kvclj/s

(rsome-kv pred coll)
source

run!clj/s

(run! proc coll)
source

run-kv!clj/s

(run-kv! proc m)
source

run-kvs!clj/s

(run-kvs! proc kvs)
source

run-obj!cljs

(run-obj! proc obj)
source

runnerclj

(runner {:as opts
         :keys [mode buffer-size n-threads thread-name drain-msecs auto-stop?
                convey-bindings? daemon-threads?]
         :or {mode :blocking
              buffer-size 1024
              n-threads 1
              drain-msecs 6000
              auto-stop? true
              convey-bindings? true
              daemon-threads? true}})
Experimental, subject to change without notice!
 Returns a new stateful "runner" such that:

  (runner f) ; Arity 1 call
    Requests runner to execute given nullary fn according to runner's opts.
    Returns:
      - `true`  if runner accepted fn for execution without back-pressure.
      - `false` if runner experienced back-pressure (fn may/not execute).
      - `nil`   if runner has stopped accepting new execution requests.

  (deref runner)
    Returns a promise that will be delivered once all pending execution
    requests complete.

  (runner) ; Arity 0 call
    Causes runner to permanently stop accepting new execution requests.
    On first call returns a promise that will be delivered once all pending
    execution requests complete. On subsequent calls returns nil.

Runners are a little like agents, but:
  - Take nullary fns rather than unary fns of state.
  - Have no validators or watches.
  - Have configurable back-pressure.
  - Can have >1 thread (in which case fns may execute out-of-order!).

These properties make them useful as configurable general-purpose async workers.

Options include:

  `:buffer-size` (default 1024)
    Size of request buffer, and the max number of pending requests before
    configured back-pressure behaviour is triggered (see `:mode`).

  `:mode` (default `:blocking`)
    Back-pressure mode ∈ #{:blocking :dropping :sliding}.
    Controls what happens when a new request is made while request buffer is full:
      `:blocking` => Blocks caller until buffer space is available
      `:dropping` => Drops the newest request (noop)
      `:sliding`  => Drops the oldest request

  `:n-threads` (default 1)
    Number of threads to use for executing fns (servicing request buffer).
    NB execution order may be non-sequential when n > 1.

  `:drain-msecs` (default 6000 msecs)
    Maximum time (in milliseconds) to try allow pending execution requests to
    complete when stopping runner. nil => no maximum.
source

satisfies!clj/smacro

(satisfies! protocol arg)
(satisfies! protocol arg {:keys [msg context param ...]})
(satisfies! protocol arg & {:keys [msg context param ...]})
If (satisfies? protocol arg) is true, returns arg.
Otherwise throws runtime `ExceptionInfo` with `unexpected-arg!`.
See `unexpected-arg!` for more info.
source

satisfies?clj/smacro

(satisfies? protocol x)
Faster `satisfies?` to work around CLJ-1814 until a proper upstream fix.
May cache, so possibly inappropriate for dynamic work.
source

sayfcljs

(sayf fmt & xs)
source

saypcljs

(sayp & xs)
source

sb-appendclj/s

(sb-append str-builder x)
(sb-append str-builder x & more)
Appends given string/s to given string builder. See also `str-builder.`
source

sb-lengthclj/s

(sb-length sb)
Returns given string builder's current length (character count).
source

secsclj/s

(secs opts)
(secs & {:as opts :keys [years months weeks days hours mins secs msecs ms]})
Returns ~number of seconds in period defined by given args.
source

secs->msclj/s

(secs->ms secs)
source

secure-rngclj

(secure-rng)
Returns an auto-reseeding thread-local `java.security.SecureRandom`.
Favours security over performance. May block while waiting on entropy!
source

secure-rng-mock!!!clj

(secure-rng-mock!!! long-seed)
Returns **INSECURE** `java.security.SecureRandom` mock instance backed by
a seeded deterministic `java.util.Random`. Useful for testing, etc.
source

select-nested-keysclj/s

(select-nested-keys src-map key-spec)
Like `select-keys` but supports nested key spec:

  (select-nested-keys
    {:a :A :b :B :c {:c1 :C1 :c2 :C2} :d :D} ; `src-map`
    [:a {:c [:c1], :d [:d1 :d2]}]) ; `key-spec`

    => {:a :A, :c {:c1 :C1}, :d :D}

Note that as with the `{:d [:d1 :d2]}` spec in the example above,
if spec expects a nested map but the actual value is not a map,
the actual value will be included in output as-is.

Has the same behaviour as `select-keys` when `key-spec` is a
simple vector of keys.
source

seq-kvsclj/s

(seq-kvs {:a :A}) => (:a :A).
source

session-swapclj

(session-swap rreq rresp f & args)
Util to help correctly update Ring sessions (something easy to get wrong!).

Given a Ring request (rreq) and Ring response (rresp), returns a new
Ring response with the response session updated to be (f <old-session>)
or (apply f <old-session> args).
source

set-var-root!clj/smacro

(set-var-root! var-sym root-val)
Sets root binding (value) of the var identified by given symbol, and returns
the new value. Cross-platform. See also `update-var-root!`.
source

simple-date-formatclj

(simple-date-format pattern & [{:keys [locale timezone] :as opts}])
Returns a thread-local `java.text.SimpleDateFormat`.
source

simple-date-format*clj

(simple-date-format* pattern locale timezone)
source

simple-ident?clj/s

(simple-ident? x)
source

simple-keyword?clj/s

(simple-keyword? x)
source

simple-symbol?clj/s

(simple-symbol? x)
source

slurp-file-resourceclj

Like `slurp-resource` but caches slurps against file's last-modified udt.
source

slurp-resourceclj

(slurp-resource rname)
Returns slurped named resource on classpath, or nil when resource not found.
source

some=clj/s

(some= x y)
(some= x y & more)
source

some?clj/s

(some? x)
Same as `core/some?` (added in Clojure v1.6).
source (clj)source (cljs)

sortvclj/s

(sortv coll)
(sortv comparator coll)
(sortv ?keyfn comparator coll)
Like `core/sort` but:
- Returns a vector.
- `comparator` can be `:asc`, `:desc`, or an arbitrary comparator.
- An optional `keyfn` may be provided, as in `core/sort-by`.
source

str->utf8-baclj

(str->utf8-ba s)
Returns given String encoded as a UTF-8 byte[].
source

str-?indexclj/s

(str-?index s substr)
(str-?index s substr start-idx)
(str-?index s substr start-idx last?)
Returns (first/last) ?index of substring if it exists within given string.
source

str-builderclj/s

(str-builder)
(str-builder init)
Returns a new stateful string builder:
  - `java.lang.StringBuilder`  for Clj
  - `goog.string.StringBuffer` for Cljs

See also `sb-append`.
source

str-builder?clj/s

(str-builder? x)
source

str-contains?clj/s

(str-contains? s substr)
source

str-ends-with?clj/s

(str-ends-with? s substr)
source

str-joinclj/s

(str-join xs)
(str-join separator xs)
(str-join separator xform xs)
Faster generalization of `clojure.string/join` with transducer support.
source

str-join-onceclj/s

(str-join-once separator coll)
Like `string/join` but skips nils and duplicate separators.
source

str-replaceclj/s

(str-replace s match replacement)
Like `str/replace` but provides consistent Clj/s behaviour.

Workaround for <http://dev.clojure.org/jira/browse/CLJS-794>,
               <http://dev.clojure.org/jira/browse/CLJS-911>.

Note that ClojureScript 1.7.145 introduced a partial fix for CLJS-911.
A full fix could unfortunately not be introduced w/o breaking compatibility
with the previously incorrect behaviour. CLJS-794 also remains unresolved.
source

str-rfclj/s

(str-rf)
(str-rf acc)
(str-rf acc in)
String builder reducing fn.
source

str-starts-with?clj/s≠

clj
cljs
(str-starts-with? s substr)
source (clj)source (cljs)

stringy?clj/s

(stringy? x)
source

submap?clj/s

(submap? m sub)
Returns true iff `sub` is a (possibly nested) submap of `m`,
i.e. iff every (nested) value in `sub` has the same (nested) value in `m`.
Uses stack recursion so supports only limited nesting.
source

submaps?clj/s

(submaps? maps subs)
Experimental, subject to change without notice.
Returns true iff `sub_i` is a (possibly nested) submap of `m_i`.
Uses `submap?`.
source

substrclj/s

(substr s start-idx)
(substr s start-idx end-idx)
(substr s kind start end)
Returns a non-empty sub-string, or nil.
Like `subs` but:
  - Doesn't throw when out-of-bounds (clips to bounds).
  - Returns nil rather than an empty string.
  - When given `:by-len` kind (4-arity case):
    - `start` may be -ive (=> index from right of string).
    - `end`   is desired string length, or `:max`.
source

subvecclj/s

(subvec v start-idx)
(subvec v start-idx end-idx)
(subvec v kind start end)
Returns a non-empty sub-vector, or nil.
Like `core/subvec` but:
  - Doesn't throw when out-of-bounds (clips to bounds).
  - Returns nil rather than an empty vector.
  - When given `:by-len` kind (4-arity case):
    - `start` may be -ive (=> index from right of vector).
    - `end`   is desired vector length, or `:max`.
source

swap-in!clj/s

(swap-in! atom_ f)
(swap-in! atom_ ks f)
(swap-in! atom_ ks not-found f)
Like `swap!` but supports `update-in` semantics and `swapped`.
Returns <new-key-val> or <swapped-return-val>:
  (swap-in! (atom {:k1 {:k2 5}}) [:k1 :k2] inc) => 6
  (swap-in! (atom {:k1 {:k2 5}}) [:k1 :k2]
    (fn [old] (swapped (inc old) old))) => 5
source

swap-val!clj/s

(swap-val! atom_ k f)
(swap-val! atom_ k not-found f)
Like `swap-in!` but optimized for single-key case:
(swap-val! (atom {:k 5}) :k inc) => 6
(swap-val! (atom {:k 5}) :k
  (fn [old] (swapped (inc old) old))) => 5
source

swappedclj/s

(swapped new-val return-val)
For use within the swap functions of `swap-in!` and `swap-val!`.

Allows the easy decoupling of new and returned values. Compare:
  (let [a (atom 0)] [(core/swap! a (fn [old]          (inc old)     )) @a]) [1 1] ; new=1, return=1
  (let [a (atom 0)] [(swap-in!   a (fn [old] (swapped (inc old) old))) @a]) [0 1] ; new=1, return=0

Faster and much more flexible than `core/swap-vals!`, etc.
Especially useful when combined with the `update-in` semantics of `swap-in!`, etc.
source

swapped?clj/s

(swapped? x)
Returns true iff given `Swapped` argument.
source

takevclj/s

(takev n coll)
source

test-fixturesclj/s

(test-fixtures fixtures-map)
Given a {:before ?(fn []) :after ?(fn [])} map, returns cross-platform
test fixtures for use by both `clojure.test` and `cljs.test`:

  (let [f (test-fixtures {:before (fn [] (test-setup))})]
    (clojure.test/use-fixtures :once f)
       (cljs.test/use-fixtures :once f))
source

thread-idclj

(thread-id)
Returns long id of current `Thread`.
source

thread-infoclj

(thread-info)
Returns {:keys [group name id]} for current `Thread`.
source

thread-localclj/smacro

(thread-local & body)
Given a body that returns an initial value for the current thread,
returns a `ThreadLocal` proxy that can be derefed to get the current
thread's current value.

Commonly used to achieve thread safety during Java interop.
In the common case, `body` will be a call to some Java constructor
that returns a non-thread-safe instance.

Example:
  (def thread-local-simple-date-format_
    "Deref to return a thread-local `SimpleDateFormat`"
    (thread-local (SimpleDateFormat. "yyyy-MM-dd")))

  (.format @thread-local-simple-date-format_ (Date.)) => "2023-01-24"

NB: don't pass the derefed value to other threads!
source

thread-local*clj

(thread-local* init-val-fn)
Low-level, see `thread-local` instead.
source

thread-local-proxyclj/smacro

(thread-local-proxy & body)
Low-level, see `thread-local` instead.
source

thread-nameclj

(thread-name)
Returns string name of current `Thread`.
source

throwable?clj

(throwable? x)
source

throwsclj/smacro

(throws form)
(throws kind form)
(throws kind pattern form)
Evals `form` and if it throws an error that matches given criteria using
`matching-error`, returns the matching error. Otherwise returns nil.

See also `matching-error`, `throws?`.
source

throws?clj/smacro

(throws? form)
(throws? kind form)
(throws? kind pattern form)
Evals `form` and if it throws an error that matches given criteria using
`matching-error`, returns true. Otherwise returns false.

Useful for unit tests, e.g.:
  (is (throws? {:a :b} (throw (ex-info "Test" {:a :b :c :d}))))

See also `matching-error`, `throws`.
source

time-msclj/smacro

(time-ms & body)
Returns number of milliseconds it took to execute body.
source

time-nsclj/smacro

(time-ns & body)
Returns number of nanoseconds it took to execute body.
source

timeout-future?clj/s

(timeout-future? x)
source

topclj/s

(top n coll)
(top n keyfn coll)
(top n keyfn cmp coll)
Returns a sorted vector of the top `n` items from `coll` using `reduce-top`.
source

top-intoclj/s

(top-into to n coll)
(top-into to n keyfn coll)
(top-into to n keyfn cmp coll)
Conjoins the top `n` items from `coll` into `to` using `reduce-top`.
source

transient?clj/s

(transient? x)
source (clj)source (cljs)

try*clj/smacro

(try* expr* catch-clauses* ?finally-clause)
Like `try`, but `catch` clause class may be:
  `:ex-info`          - Catches only `ExceptionInfo`
  `:common`           - Catches `js/Error` (Cljs), `Exception` (Clj)
  `:all`              - Catches `:default` (Cljs), `Throwable` (Clj)
  `:all-but-critical` - Catches `:default` (Cljs), `Exception` and `AssertionError` (Clj)

Addresses CLJ-1293 and the fact that `AssertionError`s are typically NON-critical
(so desirable to catch, in contrast to other `Error` classes).
source

udt->instclj/s≠

(udt->inst msecs-since-epoch)
clj
Returns given milliseconds since Unix epoch as `java.time.Instant`.
cljs
Returns given milliseconds since Unix epoch as `js/Date`.
source (clj)source (cljs)

udt?clj/s

(udt? x)
source

unexpected-arg!clj/s

(unexpected-arg! arg)
(unexpected-arg! arg {:keys [msg context param expected ...]})
(unexpected-arg! arg & {:keys [msg context param expected ...]})
Throws runtime `ExceptionInfo` to indicate an unexpected argument.
Takes optional kvs for merging into exception's data map.

  (let [mode :unexpected]
    (case mode
      :read  (do <...>)
      :write (do <...>)
      (unexpected-arg! mode
        {:context  `my-function
         :param    'mode
         :expected #{:read :write}}))) =>

  Unexpected argument: :unexpected
  {:arg {:value :unexpected, :type clojure.lang.Keyword},
   :context 'taoensso.encore/my-function
   :param 'mode
   :expected #{:read :write}}

See also `bad-arg!`.
source

update!clj/s

(update! m k f)
source

update-inclj/s

(update-in m ks f)
(update-in m ks not-found f)
Like `core/update-in` but:.
- Empty ks will return (f m), not act like [nil] ks.
- Adds support for `not-found`.
- Adds support for special return vals: `:update/dissoc`, `:update/abort`.
source

update-var-root!clj/smacro

(update-var-root! var-sym update-fn)
Updates root binding (value) of the var identified by given symbol, and returns
the new value:
  (update-var-root! my-var (fn [old-root-val] <new-root-val>)) => <new-root-val>

Similar to `alter-var-root` but cross-platform and takes a symbol rather than a var.
See also `set-var-root!`.
source

uri?clj

(uri? x)
source

url-decodeclj/s

(url-decode s & [encoding])
Stolen from <http://goo.gl/99NSR1>.
source

url-encodeclj/s≠

clj
(url-encode s & [encoding])
cljs
(url-encode s)
Based on <https://goo.gl/fBqy6e>.
source

utf8-ba->strclj

(utf8-ba->str ba)
Returns String by decoding given UTF-8 byte[].
source

uuidclj/s

(uuid)
For Clj: returns a random `java.util.UUID`.
For Cljs: returns a random UUID string.

Uses strong randomness when possible.
See also `uuid-str`, `nanoid`, `rand-id-fn`.
source

uuid-strclj/s

(uuid-str)
(uuid-str max-len)
Returns a random UUID string of given length (max 36).
Uses strong randomness when possible. See also `uuid`, `nanoid`, `rand-id-fn`.
source

vec2?clj/s

(vec2? x)
source

vec3?clj/s

(vec3? x)
source

vinterleave-allclj/s

(vinterleave-all colls)
(vinterleave-all c1 c2)
(vinterleave-all c1 c2 c3)
(vinterleave-all c1 c2 c3 & colls)
Like `interleave`, but:
  - Returns a vector rather than lazy seq (=> greedy).
  - Includes all items (i.e. stops when the longest rather than
    shortest coll has been consumed).

Single-arity version takes a coll of colls.
source

virtual-executorclj

(virtual-executor)
Experimental, subject to change without notice!
Returns new virtual `java.util.concurrent.ThreadPerTaskExecutor` when
possible (JVM 21+), otherwise returns nil.
source

vnextclj/s

(vnext v)
source

vrestclj/s

(vrest v)
source

vsplit-firstclj/s

(vsplit-first v)
source

vsplit-lastclj/s

(vsplit-last v)
source

whenclj/smacro

(when test-or-bindings & body)
Supersets `core/when` and `core/when-let` functionality. When `test-or-bindings` is
a vector, same as `encore/when-let`. Otherwise same as `core/when`.
source

when-letclj/smacro

(when-let bindings & body)
Supersets `core/when-let` functionality. Like `core/when-let` but supports multiple
bindings, and unconditional bindings with `:let`:

(when-let [x       (rand-nth [:x1 :x2 false nil    ])  ; Bind truthy x, or -> nil
           :let [y (rand-nth [:y1 :y2 false nil x  ])] ; Bind any    y
           z       (rand-nth [:z1 :z2 false nil x y])  ; Bind truthy z, or -> nil
           ]
  [:body x y z])
source

when-notclj/smacro

(when-not test-or-bindings & body)
Supersets `core/when-not` functionality.
Same as `encore/if-let` with `body` as `else` form.
source

when-someclj/smacro

(when-some test-or-bindings & body)
Supersets `core/when-some` functionality. Like `core/when-some` but supports multiple
bindings, and unconditional bindings with `:let`:

(when-some [x       (rand-nth [:x1 :x2 false nil    ])  ; Bind non-nil x, or -> `else`
            :let [y (rand-nth [:y1 :y2 false nil x  ])] ; Bind any     y
            z       (rand-nth [:z1 :z2 false nil x y])  ; Bind non-nil z, or -> `else`
            ]
  [:body x y z])
source

with-truss-dataclj/smacro

(with-truss-data data & body)
Executes body with dynamic assertion data bound to given value.
This data will be included in any violation errors thrown by body.
source

without-metaclj/s

(without-meta x)
source

xdistinctclj/s

(xdistinct)
(xdistinct keyfn)
Returns a stateful transducer like (core/distinct) that supports an optional
key function. Retains only items with distinct (keyfn <item>).
source

zero-num?clj/s

(zero-num? x)
source

cljdoc is a website building & hosting documentation for Clojure/Script libraries

Keyboard shortcutsReport a problemcljdoc on GitHub
× close