Example UTF-8 string for tests, etc.

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"

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

Returns given ?arg as `java.util.Date`, or nil.

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

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

Version check for dependency conflicts, etc.

Assocs each kv to given ?map iff its key doesn't already exist.

Assocs each kv to given ?map iff its value is not nil.

Assocs each kv to given ?map iff its val is truthy.

Returns byte[] for given hex string.

Returns hash int of given byte[].

Returns true iff given two byte[]s with the same content.

Repeatedly executes fn and returns time taken to complete execution.

For Clj: faster version of `core/binding`.
For Cljs: identical to `core/binding`.

Returns true iff given byte[] argument.

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`.

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.

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

Like `case` but test expressions are evaluated for their compile-time value.

Returns true iff given strings are equal, ignoring case.

Terse, cross-platform (try* expr (catch :all _)).
See also `try*` for more flexibility.

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`.

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>
    <...>)

Returns true iff given a `clojure.core.async` channel.

Returns true with given probability ∈ ℝ[0,1].

Returns all logical false/throwing expressions (ids/forms), or nil.

Returns first logical false/throwing expression (id/form), or nil.

Returns class name symbol of given argument.

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.

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

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.

Like `cond` but throws on non-match like `case` and `condp`.

Conjoins each non-nil value.

Conjoins each truthy value.

Constant-time `ba=`.
Useful to prevent timing attacks, etc.

Constant-time string equality checker.
Useful to prevent timing attacks, etc.

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}.

Declares given ns-qualified symbols, preserving metadata.
Clj only. Useful for circular dependencies.

Like `core/def` but supports attrs map.

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`.

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"}})

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).

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))

Like `core/defonce` but supports docstring and attrs map.

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).

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

Cross between `doto`, `cond->` and `as->`.

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

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

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

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

Returns root cause of given platform error.

Returns binary exponential backoff value for n<=36.

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

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

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

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

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

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

Like `force` for refs.

Like `force` for vars.

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`!).

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".

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`)!

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

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`.

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`.

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.

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)

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.

Returns last-modified time for file backing given named resource, or nil
if file doesn't exist.

Returns POM version string for given Maven dependency, or nil.

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

Returns current value of dynamic assertion data.

Like `get` but returns val for first key that exists in map.
Useful for key aliases or fallbacks. See also `get*`.

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!`.

Like `have` but ignores `*assert*` value (so can never be elided!).
Useful for important conditions in production (e.g. security checks).

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.

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

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

Returns hex string of given Object's `identityHashCode` (e.g. "5eeb49f2").

Returns hex string for given byte[].

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.

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.

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.

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)`

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])

Supersets `core/if-not` functionality.
Same as `encore/if-let` with `then` `and `else` forms swapped.

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])

Returns given `java.time.Instant` as milliseconds since Unix epoch.

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

If (instance? class arg) is true, returns arg.
Otherwise throws runtime `ExceptionInfo` with `unexpected-arg!`.
See `unexpected-arg!` for more info.

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

Like `interleave` but includes all items (i.e. stops when the longest
rather than shortest coll has been consumed).

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.

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

Like `into` but supports multiple "from"s.

Simple Hiccup-like string templating to complement Tempura.

Returns given ?map with keys and vals inverted, dropping non-unique vals!

Like `invert-map` but throws on non-unique vals.

Lightweight `have!` that provides less diagnostic info.

Returns Java's major version integer (8, 17, etc.).

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

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 ...]}

Returns {(f x) x} ?map for xs in `coll`.

Returns a `MapEntry` with given key and value.

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

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

Like `apply` but calls `seq-kvs` on final arg.

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?`.

Alternative way to call `cache`, provided mostly for back compatibility.
See `cache` docstring for details.

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.

Like `core/merge` but:
- Supports `:merge/dissoc` vals.
- Often faster, with much better worst-case performance.

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.

Like `core/merge-with` but:
- Supports `:merge/dissoc` vals.
- Often faster, with much better worst-case performance.

Returns ~number of milliseconds in period defined by given args.

Macro version of `ms`.

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.*"}}.

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

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`.

Like `core/merge` but:
- Recursively merges nested maps.
- Supports `:merge/dissoc` vals.
- Often faster, with much better worst-case performance.

Like `core/merge-with` but:
- Recursively merges nested maps.
- Supports `:merge/dissoc` vals.
- Often faster, with much better worst-case performance.

Single system newline

Double system newline

Returns first non-nil arg, or nil.

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.

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

Returns current system instant as `java.util.Date`.

Returns current system instant as `java.time.Instant`.

Returns current value of best-resolution time source as nanoseconds.

Returns current system instant as milliseconds since Unix epoch.

Like `or`, but returns the first non-nil form (may be falsey).

Based on `ring-codec/form-decode`.

Returns true iff given number in unsigned unit proportion interval ∈ℝ[0,1].

Experimental, subject to change without notice!
Returns new `java.util.concurrent.ThreadPoolExecutor` with given opts.

Like `core/pr` but faster, and atomic (avoids interleaved content from different threads).

Prints given arg to an edn string readable with `read-edn`.

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.

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`.

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

Public version of `core/preserving-reduced`.

Like `core/print` but faster, and atomic (avoids interleaved content from different threads).

Like `core/println` but faster, and atomic (avoids interleaved content from different threads).

Like `core/prn` but faster, and atomic (avoids interleaved content from different threads).

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

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]

Returns a new `PersistentQueue`.

Returns a new `PersistentQueue` given items.

Returns true iff given a `PersistentQueue`.

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]

Returns a random byte array of given size.

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`.

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

Reverse comparator.

Reads given edn string to return a Clj/s value.

Assocs each kv to given ?map if its value is nil, otherwise dissocs it.

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.

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

Reduces given `java.util.Iterator`, mutating it. Note that most colls
providing iterators implement `java.lang.Iterable`, so support `seq` directly.

Like `reduce-kv` but takes a flat sequence of kv pairs.

Like `reduce` but supports separate simultaneous accumulators
as a micro-optimization when reducing a large collection multiple
times.

No longer useful with Clojure 1.7+, just use (reduce f init (range ...)).

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 ...)).

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`.

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

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

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

Like `repeatedly` but faster and `conj`s items into given collection.

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

Like `reset!` but supports `update-in` semantics, returns <old-key-val>.

Like `reset-in!` but returns true iff the atom's value changed.

Like `reset-in!` but optimized for single-key case.

Like `reset-in!?` but optimized for single-key case.

Returns resolved qualified Clj/s symbol, or nil.

Returns true iff given number in signed unit proportion interval ∈ℝ[-1,1].

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.

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`.

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).

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)

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.

If (satisfies? protocol arg) is true, returns arg.
Otherwise throws runtime `ExceptionInfo` with `unexpected-arg!`.
See `unexpected-arg!` for more info.

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

Appends given string/s to given string builder. See also `str-builder.`

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

Returns ~number of seconds in period defined by given args.

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

Returns **INSECURE** `java.security.SecureRandom` mock instance backed by
a seeded deterministic `java.util.Random`. Useful for testing, etc.

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.

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

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).

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

Returns a thread-local `java.text.SimpleDateFormat`.

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

Returns slurped named resource on classpath, or nil when resource not found.

Same as `core/some?` (added in Clojure v1.6).

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`.

Returns given String encoded as a UTF-8 byte[].

Returns (first/last) ?index of substring if it exists within given string.

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

See also `sb-append`.

Faster generalization of `clojure.string/join` with transducer support.

Like `string/join` but skips nils and duplicate separators.

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.

String builder reducing fn.

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.

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

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`.

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`.

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

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

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.

Returns true iff given `Swapped` argument.

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))

Returns long id of current `Thread`.

Returns {:keys [group name id]} for current `Thread`.

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!

Low-level, see `thread-local` instead.

Low-level, see `thread-local` instead.

Returns string name of current `Thread`.

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?`.

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`.

Returns number of milliseconds it took to execute body.

Returns number of nanoseconds it took to execute body.

Returns a sorted vector of the top `n` items from `coll` using `reduce-top`.

Conjoins the top `n` items from `coll` into `to` using `reduce-top`.

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).

Returns given milliseconds since Unix epoch as `java.time.Instant`.

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!`.

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`.

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!`.

Stolen from <http://goo.gl/99NSR1>.

Based on <https://goo.gl/fBqy6e>.

Returns String by decoding given UTF-8 byte[].

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`.

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

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.

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

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`.

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])

Supersets `core/when-not` functionality.
Same as `encore/if-let` with `body` as `else` form.

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])

Executes body with dynamic assertion data bound to given value.
This data will be included in any violation errors thrown by body.

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