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

taoensso.encore

Extended core library for Clojure/Script that emphasizes:
  * Cross platform API compatibility
  * 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.

Quick Taoensso naming conventions:
  **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):
  ~      - 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)
  [nop]  - Unmodified behaviour (=>      non-breaking implementation or 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

<*clj/smacro

(<* x y z)
source

<=*clj/smacro

(<=* x y z)
source

>*clj/smacro

(>* x y z)
source

>=*clj/smacro

(>=* x y z)
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-litecljs

(ajax-lite uri
           {:as opts
            :keys [method params headers timeout-ms resp-type with-credentials?
                   xhr-pool xhr-cb-fn xhr-timeout-ms]
            :or {method :get
                 timeout-ms 10000
                 resp-type :auto
                 xhr-pool default-xhr-pool_
                 xhr-timeout-ms 2500}}
           callback-fn)
Alpha, subject to change.
Simple, lightweight Ajax via Google Closure.

Returns nil, or resulting `goog.net.XhrIo` instance if one was
immediately available.

(ajax-lite "/my-post-route"
  {:method     :post
   :params     {:username "Rich Hickey" :type "Awesome"}
   :headers    {"Foo" "Bar"}
   :resp-type  :text
   :timeout-ms 7000
   :with-credentials? false ; Enable if using CORS (requires xhr v2+)

   :xhr-pool       my-xhr-pool ; `goog.net.XhrIoPool` instance or delay
   :xhr-cb-fn      (fn [xhr])  ; Called with `XhrIo` from pool when available
   :xhr-timeout-ms 2500        ; Max msecs to wait on pool for `XhrIo`
  }
  (fn async-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-?emailclj/s

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

as-?floatclj/s

(as-?float x)
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)
source

as-boolclj/s

(as-bool x)
source

as-emailclj/s

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

as-floatclj/s

(as-float x)
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 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

as-pnum!clj/s

(as-pnum! x)
source

as-pnum-complementclj/s

(as-pnum-complement 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-rnum!clj/s

(as-rnum! x)
source

as-udtclj/s

(as-udt x)
source

assert-min-encore-versionclj/s

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

assoc-nxclj/s

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

assoc-someclj/s

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

assoc-whenclj/s

(assoc-when m kvs)
(assoc-when m k v)
(assoc-when m k v & kvs)
Assocs each kv 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)
source

ba-splitclj

(ba-split ba idx)
source

ba=clj

(ba= x y)
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

boolean?clj/s

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

bytes-classclj

source

bytes?clj

(bytes? x)
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

can-meta?clj/s

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

case-evalclj/smacro

(case-eval expr & clauses)
Like `case` but evals test constants 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 try-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)
Cross-platform try/catch/finally.
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

caught-error-dataclj/smacro

(caught-error-data & body)
Handy for error-throwing unit tests.
source

chan?clj/s

(chan? x)
source (clj)source (cljs)

chanceclj/s

(chance p)
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

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

compiling-cljs?clj

(compiling-cljs?)
Return truthy iff currently generating Cljs code.
See also `if-cljs`, `if-clj`.
source

condclj/smacro

(cond & clauses)
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 int value:
- (<counter>    ) -> add 1, return old val
- (<counter> <n>) -> add n, return old val

Experimental 3-arity version takes an `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. Useful for
circular dependencies.
source

def*clj/smacro

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

defaliasclj/smacro

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

For Clj:
  - Source var's metadata will be preserved (docstring, arglists, etc.).
  - Changes to source var's value will also be applied to alias.
source

defaliasesclj/smacro

(defaliases & aliases)
Bulk version of `defalias`.
Takes source symbols or {:keys [alias src attrs]} 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 sym)
Experimental!!
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).
Handy 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)

dis-assoc-someclj/s

(dis-assoc-some m kvs)
(dis-assoc-some m k v)
(dis-assoc-some m k v & kvs)
Assocs each kv if its value is not nil, otherwise dissocs it.
source

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

do-falseclj/smacro

(do-false & body)
source

do-nilclj/smacro

(do-nil & body)
source

do-trueclj/smacro

(do-true & body)
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-dataclj/s

(error-data x)
Returns data map iff `x` is an error of any type on platform.
source

error?clj/s

(error? x)
source (clj)source (cljs)

ex-causeclj/s

(ex-cause ex)
Copy of `core/ex-cause` (added in Clojure v1.10)
source

ex-messageclj/s

(ex-message ex)
Copy of `core/ex-message` (added in Clojure v1.10)
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 the given named resources have changed
since last call.
source

filter-keysclj/s

(filter-keys pred m)
source

filter-valsclj/s

(filter-vals pred m)
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: just passes through to `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-query-stringclj/s

(format-query-string m)
source

future-poolclj

(future-pool n-threads)
Returns a simple semaphore-limited wrapper of Clojure's standard `future`:
  (fn
    [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 variants are also provided.
source

get-dynamic-assertion-datacljdeprecated

(get-dynamic-assertion-data)
Prefer `get-data`
source

get-envclj/smacro

(get-env)
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-hostnameclj

(get-hostname)
Returns local hostname string, or nil.
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 macro-env)
Returns {:keys [ns line column file]} callsite and file info given a
macro's compile-time `&form` and `&env` vals. See also `keep-callsite`.
source

get-substr-by-idxclj/s

(get-substr-by-idx s start-idx)
(get-substr-by-idx s start-idx end-idx)
Returns ?substring from given string.

Like `subs` but:
  - Provides consistent clj/s behaviour.
  - Never throws (snaps to valid indexes).
  - Indexes may be -ive (=> indexed from end of string).

Returns nil when requested substring would be empty.
source

get-substr-by-lenclj/s

(get-substr-by-len s start-idx)
(get-substr-by-len s start-idx sub-len)
Returns ?substring from given string.
Like `get-substr-by-idx`, but takes a substring-length 3rd argument.
source

get-subvecclj/s

(get-subvec v start)
(get-subvec v start end)
Like `subvec` but never throws (snaps to valid start and end indexes).
source

get-subvectorclj/s

(get-subvector v start)
(get-subvector v start length)
Like `get-subvec` but:
- Takes `length` instead of `end` (index).
- -ive `start` => index from right of vector.
source

get-sys-bool*clj/smacro

(get-sys-bool* default prop)
(get-sys-bool* default prop env)
(get-sys-bool* default prop env res)
Returns nil, or the first of the following:
  - Named JVM         property value   (parsed as boolean)
  - Named environment variable value   (parsed as boolean)
  - Named classpath   resource content (parsed as boolean)
  - Provided `default` value

Vectors may be used to provide descending-preference alternatives:
  (get-sys-bool* #?(:clj  [:my-app.config.clj.bool  :my-app.config.bool]
                    :cljs [:my-app.config.cljs.bool :my-app.config.bool]))

Match order: [<prop1> <env1> <res1> <prop2> <env2> <res2> ...].

Parsing logic:
  - Return `true`  if value is ∈ #{"true"  "1" "t" "T" "TRUE"}
  - Return `false` if value is ∈ #{"false" "0" "f" "F" "FALSE"}
  - Throws for all other values
source

get-sys-val*clj/smacro

(get-sys-val* prop)
(get-sys-val* prop env)
(get-sys-val* prop env res)
Returns nil, or the first of the following:
  - Named JVM         property value   (as string)
  - Named environment variable value   (as string)
  - Named classpath   resource content (as string)

Vectors may be used to provide descending-preference alternatives:
  (get-sys-val* #?(:clj  [:my-app.config.clj.txt  :my-app.config.txt]
                   :cljs [:my-app.config.cljs.txt :my-app.config.txt]))

Match order: [<prop1> <env1> <res1> <prop2> <env2> <res2> ...].
source

get-truss-dataclj/s≠

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

get-win-loccljs

(get-win-loc)
Returns `js/window`'s current location as a map.
source

get1clj/s

(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 given key that exists in map.
Useful for key aliases or fallbacks when vals may be falsey.
Equivalent to (if (contains? m k1) (get m k1)
                (if (contains? m k2) (get m k2) ...)).
source

haveclj/smacro

(have x)
(have pred (:in) x)
(have pred (:in) x & more-xs)
Takes a pred and one or more vals. Tests pred against each val,
trapping errors. If any pred test fails, throws a detailed assertion error.
Otherwise returns input val/vals for convenient inline-use/binding.

Respects *assert* value so tests can be elided from production for zero
runtime costs.

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

  ;; Will throw a detailed error message on invariant violation:
  (fn my-fn [x] (str/trim (have string? x)))

You may attach arbitrary debug info to assertion violations like:
  `(have string? x :data {:my-arbitrary-debug-info "foo"})`

Re: use of Truss assertions within other macro bodies:
  Due to CLJ-865, call site information (e.g. line number) of
  outer macro will unfortunately be lost.

  See `keep-callsite` util for a 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)
Specialized cross between `have?` and `have!`. Not used often but can be
handy for semantic clarification and/or to improve multi-val performance
when the return vals aren't necessary.

**WARNING**: Do NOT use in :pre/:post conds since those are ALWAYS subject
to *assert*, directly contradicting the intention of the bang (`!`) here.
source

have-core-async?clj

source

have?clj/smacro

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

hex-str->baclj

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

ident-hex-strclj

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

ident?clj/s

(ident? x)
source (clj)source (cljs)

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)
Like `core/if-let` but can bind multiple values for `then` iff all tests
are truthy, supports internal unconditional `:let`s.
source

if-notclj/smacro

(if-not test-or-bindings then)
(if-not test-or-bindings then else)
Like `core/if-not` but acts like `if-let` when given a binding vector
as test expr.
source

if-someclj/smacro

(if-some bindings then)
(if-some bindings then else)
Like `core/if-some` but can bind multiple values for `then` iff all tests
are non-nil, supports internal unconditional `:let`s.
source

indexed?clj/s

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

instance!clj/s

(instance! class arg & {:as details})
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 [public private impl test]}, 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 from)
(into! to xform from)
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)
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

js-?wincljs

source

keep-callsiteclj/smacro

(keep-callsite & body)
The long-standing CLJ-865 unfortunately means that it's currently
not possible for an inner macro to access the &form metadata of an
outer macro.

This means that inner macros lose call site information like the
line number of the outer macro.

This util offers a workaround for macro authors:

  (defmacro inner  [] (meta &form))
  (defmacro outer1 []                `(inner))
  (defmacro outer2 [] (keep-callsite `(inner)))

  (inner)  => {:line _, :column _}
  (outer1) => nil
  (outer2) => {: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

kw-identical?clj/s

source (clj)source (cljs)

lazy-seq?clj/s

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

limiterclj/s

(limiter spec)
(limiter opts spec)
Rate limiter.
Takes {<limit-id> [<n-max-reqs> <msecs-window>]}, and returns a rate
limiter (fn check-limits! [req-id]) -> nil (all limits pass), or
[<worst-limit-id> <worst-backoff-msecs> {<limit-id> <backoff-msecs>}].

Limiter fn commands:
  :rl/peek  <req-id> - Check limits w/o side effects.
  :rl/reset <req-id> - Reset all limits for given req-id.
source

logcljs

source

logfcljs

(logf fmt & xs)
source

logpcljs

(logp & xs)
source

map-keysclj/s

(map-keys f m)
source

map-valsclj/s

(map-vals f m)
source

mapplyclj/s

(mapply f & args)
Like `apply` but calls `seq-kvs` on final arg.
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 fn's most recent call.
Great for Reactjs render op caching on mobile devices, etc.
source

mergeclj/s

(merge & maps)
Like `core/merge` but faster, supports `:merge/dissoc` rvals.
source

merge-keywordsclj/s

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

merge-metaclj/s

(merge-meta x m)
source

merge-url-with-query-stringclj/s

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

merge-withclj/s

(merge-with f & maps)
Like `core/merge-with` but faster, supports `:merge/dissoc` rvals.
source

min*clj/smacro

(min* n1 n2)
source

min-longclj/s

source

msclj/s

(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)
Compile-time version of `ms`
source

name-filterclj/s

(name-filter spec)
Given filter `spec`, returns a compiled (fn conform? [name]) that takes
any name type (string, keyword, symbol).

Spec may be:
  - A regex pattern. Will conform on match.
  - A str/kw/sym, in which any "*"s will act as #".*" wildcards.
    Will conform on match.

  - A vector or set of regex patterns or strs/kws/syms.
    Will conform on ANY match.
    If you need literal "*"s, use #"\*" regex instead.

  - {:allow <allow-spec> :deny <deny-spec>}.
    Will conform iff `allow-spec` matches AND `deny-spec` does NOT.

Resulting conform fn is useful as allowlist and/or denylist.
Example inputs: namespace strings, class names, ids, etc.

Spec examples:
  #{}, "*", "foo.bar", "foo.bar.*", #{"foo" "bar.*"},
  {:allow #{"foo" "bar.*"} :deny #{"foo.*.bar.*"}},
  #"(foo1|foo2)\.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

named?clj/s

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

nanoidclj/s

(nanoid)
(nanoid len)
Experimental. Optimized variant of `secure-rand-id` that returns Nano IDs,
Ref. <https://github.com/ai/nanoid>.
source

nanoid-alphabetclj/s

source

nat-float?clj/s

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

nat-int?clj/s

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

nat-num?clj/s

(nat-num? x)
source (clj)source (cljs)

nblank-str?clj/s

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

nblank?clj/s

(nblank? x)
source (clj)source (cljs)

neg-float?clj/s

(neg-float? x)
source (clj)source (cljs)

neg-int?clj/s

(neg-int? x)
source (clj)source (cljs)

neg-num?clj/s

(neg-num? x)
source (clj)source (cljs)

nempty-str?clj/s

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

nested-mergeclj/s

(nested-merge & maps)
Like `merge` but does nested merging.
source

nested-merge-withclj/s

(nested-merge-with f & maps)
Like `merge-with` but does nested merging.
source

new-objectclj/smacro

(new-object)
source

nneg?clj/s

(nneg? x)
source (clj)source (cljs)

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

now-dtclj/s

(now-dt)
source

now-dt*clj/smacro

(now-dt*)
source

now-instclj/smacro

(now-inst)
Returns current `java.time.Instant` (Clj), or epoch millis (Cljs).
source

now-nanoclj/s≠

clj
(now-nano)
cljs
Uses window context as epoch, Ref. <http://goo.gl/mWZWnR>
source (clj)source (cljs)

now-nano*clj/smacro

(now-nano*)
source

now-udtclj/s

(now-udt)
source

now-udt*clj/smacro

(now-udt*)
source

nzero-num?clj/s

(nzero-num? x)
source (clj)source (cljs)

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. Like `assoc-in` for JS objects.
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

pos-float?clj/s

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

pos-int?clj/s

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

pos-num?clj/s

(pos-num? x)
source (clj)source (cljs)

powclj/s

(pow n exp)
source

pr-ednclj/s

(pr-edn x)
(pr-edn _opts x)
Prints arg to an edn string readable with `read-edn`.
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

preserve-reducedclj/s

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

pull-val!clj/s

(pull-val! atom_ k)
(pull-val! atom_ k not-found)
Removes and returns value mapped to key.
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 (clj)source (cljs)

qualified-keyword?clj/s

(qualified-keyword? x)
source (clj)source (cljs)

qualified-symbol?clj/s

(qualified-symbol? x)
source (clj)source (cljs)

queueclj/s

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

queue*clj/s

(queue* & items)
source

queue?clj/s

(queue? x)
source (clj)source (cljs)

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

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

(read-edn s)
(read-edn opts s)
Attempts to pave over differences in:
 `clojure.edn/read-string`, `clojure.tools.edn/read-string`,
 `cljs.reader/read-string`, `cljs.tools.reader/read-string`.
`cljs.reader` in particular can be a pain.
source

read-sys-val*clj/smacro

(read-sys-val* prop)
(read-sys-val* prop env)
(read-sys-val* prop env res)
Returns nil, or the first of the following:
  - Named JVM         property value   (read as edn)
  - Named environment variable value   (read as edn)
  - Named classpath   resource content (read as edn)

Vectors may be used to provide descending-preference alternatives:
  (read-sys-val* #?(:clj  [:my-app.config.clj.edn  :my-app.config.edn]
                    :cljs [:my-app.config.cljs.edn :my-app.config.edn]))

Match order: [<prop1> <env1> <res1> <prop2> <env2> <res2> ...].

If result is a single symbol, it must resolve to an available Clj var.
The var's value will then be returned, or an exception will be thrown.

NB: when targeting Cljs, the final value must be something that can be
safely embedded in code during macro expansion.
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-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-optimisation 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)
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)
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 pred m)
source

remove-valsclj/s

(remove-vals pred m)
source

rename-keysclj/s

(rename-keys replacements m)
Returns a map like the one given, replacing keys using
the 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. 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:
  (fn [ ]) => Returns current array in O(n).
  (fn [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:
  (fn [ ]) => Returns current sub/vector in O(1).
  (fn [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

round*clj/s

(round* n)
(round* kind n)
(round* kind precision n)
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

satisfies!clj/s

(satisfies! protocol arg & {:as details})
If (satisfies? protocol arg) is true, returns arg.
Otherwise throws runtime `ExceptionInfo` with `unexpected-arg!`.
See `unexpected-arg!` for more info.
source

sayfcljs

(sayf fmt & xs)
source

saypcljs

(sayp & xs)
source

sb-appendclj/s

(sb-append str-builder s)
(sb-append str-builder s & more)
For cross-platform string building
source

secsclj/s

source

secs->msclj/s

(secs->ms secs)
source

secure-rand-bytesclj/s

(secure-rand-bytes size)
Returns `size` random bytes using `secure-rng` or `js/window.crypto`.
source

secure-rand-idclj/s

(secure-rand-id alphabet len)
Experimental.
Given `alphabet` (a string of possible characters), returns a securely
random string of length `len`.

Trying to do this the obvious/naive way (by repeatedly generating a secure
random number and mapping it to an alphabet character with modulo) actually
introduces bias into ids that can be exploited by an attacker.

The method used here is designed to eliminate that bias.
Based on <https://bit.ly/3dtYv73>.
source

secure-rngclj

(secure-rng)
Returns a thread-local `java.security.SecureRandom`.
Favours security over performance. Automatically re-seeds occasionally.
May block while waiting on system 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)
Small util to help correctly manage (modify) funtional sessions. Please use
this when writing Ring middleware! It's *so* easy to get this wrong and end up
with subtle, tough-to-diagnose issues.
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 (clj)source (cljs)

simple-keyword?clj/s

(simple-keyword? x)
source (clj)source (cljs)

simple-symbol?clj/s

(simple-symbol? x)
source (clj)source (cljs)

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

For cross-platform string building
source

str-builder?clj/s

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

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 coll)
(str-join separator coll)
(str-join separator xform coll)
Faster, transducer-based generalization of `clojure.string/join` with `xform`
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

(str-starts-with? s substr)
source

stringy?clj/s

(stringy? x)
source (clj)source (cljs)

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

Warning: uses stack recursion, so supports only limited nesting.
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,
returns <new-key-val> or <swapped-return-val>.
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.
source

swappedclj/s

(swapped new-val return-val)
source

swapped-vecclj/s

(swapped-vec x)
source

swapped?clj/s

(swapped? x)
source (clj)source (cljs)

system-newlineclj/s

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

throwable?clj

(throwable? x)
source

throwsclj/smacro

(throws form)
(throws c form)
(throws c pattern form)
Like `throws?`, but returns ?matching-error instead of true/false.
source

throws?clj/smacro

(throws? form)
(throws? c form)
(throws? c pattern form)
Evals `form` and returns true iff it throws an error that matches given
criteria:

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

  - `pattern` may be:
    - A string or Regex against which `ex-message` will be matched.
    - A map             against which `ex-data`    will be matched.

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

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

See also `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 (clj)source (cljs)

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-evalclj/smacro

(try-eval form)
Evaluates `form`. If eval doesn't throw, expands to `form`, otherwise to nil.
source

udt?clj/s

(udt? x)
source (clj)source (cljs)

unexpected-arg!clj/s

(unexpected-arg! arg & {:keys [msg] :as details})
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
        :expected #{:read :write}))) =>

  Unexpected argument: :unexpected
  {:arg {:value :unexpected, :type clojure.lang.Keyword},
   :expected #{:read :write}}
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

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

uuid-strclj/s

(uuid-str)
(uuid-str max-length)
Returns a UUIDv4 string of form "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".
Ref. <http://www.ietf.org/rfc/rfc4122.txt>,
     <https://gist.github.com/franks42/4159427>,
     <https://github.com/clojure/clojurescript/pull/194>
source

vec2?clj/s

(vec2? x)
source (clj)source (cljs)

vec3?clj/s

(vec3? x)
source (clj)source (cljs)

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

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)
Like `core/when` but acts like `when-let` when given a binding vector
as test expr.
source

when-letclj/smacro

(when-let bindings & body)
Like `core/when-let` but can bind multiple values for `body` iff all tests
are truthy, supports internal unconditional `:let`s.
source

when-notclj/smacro

(when-not test-or-bindings & body)
Like `core/when-not` but acts like `when-let` when given a binding vector
as test expr.
source

when-someclj/smacro

(when-some test-or-bindings & body)
source

when?clj/s

(when? pred x)
source (clj)source (cljs)

with-dynamic-assertion-dataclj/smacrodeprecated

(with-dynamic-assertion-data data & body)
Prefer `with-data`
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)
source

zero-num?clj/s

(zero-num? x)
source (clj)source (cljs)

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

Keyboard shortcutsReport a problemcljdoc on GitHub
× close