taoensso.encore — com.taoensso/encore 3.10.0

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 returns a truthy val. Note: !?, not ?!. foo$ - Fn that's notably expensive to compute (e.g. hits db). foo_ - Dereffable val (e.g. atom, volatile, delay, 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 - 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.

*log-level* cljs

DEPRECATED

->?singleton clj/s

(->?singleton coll)

->vec clj/s

(->vec x)

-as-throw clj/s

(-as-throw as-name x)

-assert-unstub-val clj/s≠

clj

(-assert-unstub-val s)

cljs

(-assert-unstub-val f)

-core-merge clj/s

-core-update-in clj/s

-gc-now? clj/s macro

(-gc-now?)

-if-cas! clj/s macro

(-if-cas! atom_ old-val new-val then & [?else])

Micro optimization, mostly for cljs.

-intern-stub clj/s macro

(-intern-stub ns stub-sym stub-var src)

-matching-throwable clj/s

(-matching-throwable ex)

(-matching-throwable c ex)

(-matching-throwable c pattern ex)

-merge-with clj/s

(-merge-with nest? f maps)

-new-stubfn_ cljs

(-new-stubfn_ name)

-swap-cache! clj/s

-swap-k! clj/s

-swap-val! clj/s

(-swap-val! atom_ k f)

Used internally by memoization utils.

-unswapped clj/s

-vol! clj/s macro

(-vol! val)

-vol-reset! clj/s macro

(-vol-reset! vol_ val)

-vol-swap! clj/s macro

(-vol-swap! vol_ f & args)

-vswapped clj/s

<* clj/s macro

(<* x y z)

<=* clj/s macro

(<=* x y z)

>* clj/s macro

(>* x y z)

>=* clj/s macro

(>=* x y z)

?substr<idx clj/s

?substr<len clj/s

?subvec<idx clj/s

?subvec<len clj/s

a0-memoize_ clj/s

a1-memoize_ clj/s

abs clj/s

(abs n)

after-timeout clj/s macro

(after-timeout msecs & body)

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

ajax-lite cljs

(ajax-lite uri
           {:keys [method params headers timeout-ms resp-type with-credentials?]
            :as opts
            :or {method :get timeout-ms 10000 resp-type :auto}}
           callback-fn)

Alpha, subject to change. Simple, lightweight Ajax via Google Closure. Returns the resulting XhrIo[1] instance, or nil.

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

[1] Ref. https://developers.google.com/closure/library/docs/xhrio

approx= clj/s

(approx= x y)

(approx= x y signf)

approx== clj/s

(approx== x y)

(approx== signf x y)

as-?bool clj/s

(as-?bool x)

as-?email clj/s

(as-?email ?s)

(as-?email max-len ?s)

as-?float clj/s

(as-?float x)

as-?int clj/s

(as-?int x)

as-?kw clj/s

(as-?kw x)

as-?name clj/s

(as-?name x)

as-?nat-float clj/s

(as-?nat-float x)

as-?nat-int clj/s

(as-?nat-int x)

as-?nblank clj/s

(as-?nblank x)

as-?nblank-trim clj/s

(as-?nblank-trim x)

as-?nemail clj/s

(as-?nemail ?s)

(as-?nemail max-len ?s)

as-?nempty-str clj/s

(as-?nempty-str x)

as-?nzero clj/s

(as-?nzero x)

as-?pfloat clj/s

as-?pint clj/s

as-?pnum clj/s

(as-?pnum x)

as-?pos-float clj/s

(as-?pos-float x)

as-?pos-int clj/s

(as-?pos-int x)

as-?pval clj/s

as-?qname clj/s

(as-?qname x)

as-?rnum clj/s

(as-?rnum x)

as-?udt clj/s

(as-?udt x)

as-?ufloat clj/s

as-?uint clj/s

as-bool clj/s

(as-bool x)

as-email clj/s

(as-email x)

(as-email n x)

as-float clj/s

(as-float x)

as-int clj/s

(as-int x)

as-kw clj/s

(as-kw x)

as-map clj/s

(as-map kvs & [kf vf])

Deprecated, prefer reduce-kvs

as-name clj/s

(as-name x)

as-nat-float clj/s

(as-nat-float x)

as-nat-int clj/s

(as-nat-int x)

as-nblank clj/s

(as-nblank x)

as-nblank-trim clj/s

(as-nblank-trim x)

as-nemail clj/s

(as-nemail x)

(as-nemail n x)

as-nempty-str clj/s

(as-nempty-str x)

as-nzero clj/s

(as-nzero x)

as-pfloat clj/s

as-pint clj/s

as-pnum clj/s

(as-pnum x)

as-pos-float clj/s

(as-pos-float x)

as-pos-int clj/s

(as-pos-int x)

as-pval clj/s

as-qname clj/s

(as-qname x)

as-rnum clj/s

(as-rnum x)

as-udt clj/s

(as-udt x)

as-ufloat clj/s

as-uint clj/s

assert-min-encore-version clj/s

(assert-min-encore-version min-version)

Version check for dependency conflicts, etc.

assoc-nx clj/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.

assoc-some clj/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.

assoc-when clj/s

(assoc-when m kvs)

(assoc-when m k v)

(assoc-when m k v & kvs)

Assocs each kv iff its val is truthy.

atom? clj/s

(atom? x)

ba-concat clj

(ba-concat ba1 ba2)

ba-split clj

(ba-split ba idx)

ba= clj

(ba= x y)

backport-run! clj/s

bench clj/s macro

(bench nlaps opts & body)

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.

boolean? clj/s

(boolean? x)

bytes-class clj

bytes? clj

(bytes? x)

call-after-timeout clj/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.

case-eval clj/s macro

(case-eval expr & clauses)

Like case but evals test constants for their compile-time value.

catch-errors clj/s macro

(catch-errors & body)

catch-errors* clj/s macro

(catch-errors* & args)

catching clj/s macro

(catching try-expr)

(catching try-expr error-sym catch-expr)

(catching try-expr error-sym catch-expr finally-expr)

Cross-platform try/catch/finally.

caught-error-data clj/s macro

(caught-error-data & body)

Handy for error-throwing unit tests.

chan? clj/s

(chan? x)

chance clj/s

(chance p)

check-all clj/s macro

(check-all test)

(check-all test & more)

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

check-some clj/s macro

(check-some test)

(check-some test & more)

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

clamp clj/s

(clamp nmin nmax n)

clamp* clj/s macro

(clamp* nmin nmax n)

clj1098 clj/s

(clj1098 x)

Ref. http://goo.gl/0GzRuz

compile-if clj/s macro

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

compile-ns-filter clj/s

(compile-ns-filter ns-pattern)

(compile-ns-filter whitelist blacklist)

Deprecated, prefer compile-str-filter instead.

compile-str-filter clj/s

(compile-str-filter spec)

Compiles given spec and returns a fast (fn conform? [?in-str]).

Spec may be:

• A regex pattern. Will conform on match.

• A string, in which any ""s will act as wildcards (#"."). Will conform on match.

• A vector or set of regex patterns or strings. Will conform on ANY match. If you need literal "*"s, use an explicit regex pattern instead.

• {:allow <allow-spec> :deny <deny-spec> :cache? <bool>}. Will conform iff allow-spec matches AND deny-spec does NOT.

Input may be: namespace strings, class names, etc. Useful as string allowlist (whitelist) and/or denylist (blacklist).

Spec examples: #{}, "", "foo.bar", "foo.bar.", #{"foo" "bar."}, {:allow #{"foo" "bar."} :deny #{"foo..bar."}}

compile-when clj/s macro

(compile-when test & body)

compiling-cljs? clj

(compiling-cljs?)

Return truthy iff currently generating Cljs code.

cond clj/s macro

(cond & clauses)

Like core/cond but supports implicit final else clause, and special clause keywords for advanced behaviour:

(cond :let [x "x"] ; Establish bindings visible to following 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.

cond! clj/s macro

(cond! & clauses)

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

cond* clj/s macro

(cond* & args)

cond-throw clj/s macro

(cond-throw & args)

conj-some clj/s

(conj-some)

(conj-some coll)

(conj-some coll x)

(conj-some coll x & more)

Conjoins each non-nil value.

conj-when clj/s

(conj-when)

(conj-when coll)

(conj-when coll x)

(conj-when coll x & more)

Conjoins each truthy value.

const-ba= clj

(const-ba= ba1 ba2)

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

const-str= clj/s

(const-str= s1 s2)

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

contains-in? clj/s

(contains-in? coll ks)

(contains-in? coll ks k)

convey-reduced clj/s

(convey-reduced x)

count-words clj/s

(count-words s)

Counter cljs

counter clj/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

debugf cljs

(debugf fmt & xs)

declare-remote clj/s macro

(declare-remote & syms)

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

defalias clj/s macro

(defalias src)

(defalias sym src)

(defalias sym src attrs)

(defalias sym src attrs v)

Defines an alias for a var, preserving its metadata. Cannot alias macros in Cljs.

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

DefaultTimeoutImpl cljs

defonce clj/s macro

(defonce sym & args)

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

defonce* clj/s macro

(defonce* & args)

defstub clj/s macro

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

deprecated clj/s macro

(deprecated & body)

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

derefable? clj/s

(derefable? x)

dis-assoc-some clj/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.

dissoc-in clj/s

(dissoc-in m ks dissoc-k)

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

distinct-by clj/s

(distinct-by keyfn coll)

Deprecated, prefer xdistinct

distinct-elements? clj/s

(distinct-elements? x)

distinctv clj/s

(distinctv coll)

(distinctv keyfn coll)

Deprecated, prefer xdistinct

do-false clj/s macro

(do-false & body)

do-nil clj/s macro

(do-nil & body)

do-true clj/s macro

(do-true & body)

doto-cond clj/s macro

(doto-cond [sym x] & clauses)

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

dswap! clj/s

editable? clj/s

(editable? x)

encore-version clj/s

ensure-set clj/s

(ensure-set x)

ensure-vec clj/s

(ensure-vec x)

error-data clj/s

(error-data x)

Returns data map iff x is an error of any type on platform.

error? clj/s

(error? x)

errorf cljs

(errorf fmt & xs)

every clj/s

exception? clj

(exception? x)

exp-backoff clj/s

(exp-backoff n-attempt)

(exp-backoff n-attempt {:keys [min max factor] :or {factor 1000}})

Returns binary exponential backoff value for n<=36.

explode-keyword clj/s

(explode-keyword k)

fatalf cljs

(fatalf fmt & xs)

file-resources-modified? clj

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

filter-keys clj/s

(filter-keys pred m)

filter-kvs clj/s

(filter-kvs pred m)

filter-vals clj/s

(filter-vals pred m)

float? clj/s

(float? x)

fmemoize clj/s

(fmemoize f)

Fastest-possible Clj memoize. Non-racy, 0-3 arity only. Cljs just passes through to core/memoize.

force-ref clj/s

(force-ref x)

Like force for refs.

format clj/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!).

format* clj/s

(format* fmt args)

format-query-string clj/s

(format-query-string m)

fq-name clj/s

future-pool clj

(future-pool n)

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.

fzipmap clj/s

(fzipmap ks vs)

get-dynamic-assertion-data clj

(get-dynamic-assertion-data)

Returns current value of dynamic assertion data.

get-env clj/s macro

(get-env)

get-file-resource-?last-modified clj

(get-file-resource-?last-modified rname)

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

get-hostname clj

(get-hostname)

Returns local hostname string, or nil.

get-pom-version clj

(get-pom-version dep-sym)

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

get-substr clj/s

(get-substr s start)

(get-substr s start end)

Like subs but provides consistent clj/s behaviour and never throws (snaps to valid start and end indexes).

get-substring clj/s

(get-substring s start)

(get-substring s start length)

Like get-substr but:

• Takes length instead of end (index).
• -ive start => index from right of string.

get-subvec clj/s

(get-subvec v start)

(get-subvec v start end)

Like subvec but never throws (snaps to valid start and end indexes).

get-subvector clj/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.

get-sys-bool clj

(get-sys-bool default prop-id env-id)

If prop-id JVM property or env-id environment variable are set:

• Returns true if set value is e/o #{"1" "t" "true" "T" "TRUE"}
• Returns false if set value is e/o #{"0" "f" "false""F" "FALSE"}
• Otherwise throws

Returns default if neither property nor environment variable is set.

get-sys-val clj

(get-sys-val id)

(get-sys-val prop-id env-id)

get-win-loc cljs

(get-win-loc)

Returns js/window's current location as a map.

get-window-location cljs

greatest clj/s

(greatest coll & [?comparator])

have clj/s≠ macro

clj

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

See also have?, have!.

cljs

(have & args)

have! clj/s macro

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

have!? clj/s macro

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

have-core-async? clj

have-in clj/s macro

(have-in a1 & an)

have-in! clj/s macro

(have-in! a1 & an)

have-transducers? clj/s

have? clj/s≠ macro

clj

(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

cljs

(have? & args)

ident? clj/s

(ident? x)

idx-fn clj/s

if-clj clj/s macro

(if-clj then & [else])

if-cljs clj/s macro

(if-cljs then & [else])

if-let clj/s macro

(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 :lets.

if-lets clj/s macro

(if-lets & args)

if-not clj/s macro

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

if-not* clj/s macro

(if-not* & args)

if-some clj/s macro

(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 :lets.

indexed? clj/s

(indexed? x)

infof cljs

(infof fmt & xs)

int? clj/s

(int? x)

interleave-all clj/s

(interleave-all)

(interleave-all c1)

(interleave-all c1 c2)

(interleave-all c1 c2 & colls)

Greedy version of interleave.

into! clj/s

(into! to from)

(into! to xform from)

into-all clj/s

(into-all to from)

(into-all to from & more)

Like into but supports multiple "from"s.

into-str clj/s

(into-str & xs)

Simple Hiccup-like string templating to complement Tempura.

invert-map clj/s

(invert-map m)

is! clj/s

(is! x)

(is! pred x)

(is! pred x fail-?data)

Cheaper have! that provides less diagnostic info.

ITimeoutFuture clj/s protocol

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-poll clj/s

(tf-poll _)

Returns :timeout/pending, :timeout/cancelled, or the timeout's completed result.

tf-state clj/s

(tf-state _)

Returns a map of timeout's public state.

ITimeoutImpl clj/s protocol

-schedule-timeout clj/s

(-schedule-timeout _ msecs f)

join-once clj/s

(join-once sep & coll)

js-?win cljs

keys-by clj/s

(keys-by f coll)

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

keys<= clj/s

(keys<= m ks)

keys= clj/s

(keys= m ks)

keys=nnil? clj/s

(keys=nnil? m ks)

keys>= clj/s

(keys>= m ks)

keywordize-map clj/s

(keywordize-map m)

ks-nnil? clj/s

(ks-nnil? ks m)

ks<= clj/s

(ks<= ks m)

ks= clj/s

(ks= ks m)

ks>= clj/s

(ks>= ks m)

kw-identical? clj/s≠

clj

(kw-identical? x y)

Tests if 2 arguments are the same object

cljs

lazy-seq? clj/s

(lazy-seq? x)

least clj/s

(least coll & [?comparator])

LimitEntry cljs

limiter clj/s

(limiter specs)

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

limiter* clj/s

(limiter* specs)

Experimental. Like limiter but returns [<limiter> <state_>].

LimitHits cljs

LimitSpec cljs

log cljs

logf cljs

(logf fmt & xs)

logging-level clj/s

logp cljs

(logp & xs)

map-keys clj/s

(map-keys f m)

map-kvs clj/s

(map-kvs kf vf m)

Deprecated, prefer reduce-kv

map-vals clj/s

(map-vals f m)

mapply clj/s

(mapply f & args)

Like apply but calls seq-kvs on final arg.

max* clj/s macro

(max* n1 n2)

max-long clj/s

memoize clj/s

(memoize f)

(memoize ttl-ms f)

(memoize cache-size ttl-ms f)

Like core/memoize but:

• Often faster, depending on opts.
• Prevents race conditions on writes.
• Supports auto invalidation & gc with ttl-ms opt.
• Supports cache size limit & gc with cache-size opt.
• Supports invalidation by prepending args with :mem/del or :mem/fresh.

memoize* clj/s

memoize-1 clj/s

memoize-a0_ clj/s

memoize-a1_ clj/s

memoize-last clj/s

(memoize-last f)

Like memoize but only caches the fn's most recent call. Great for Reactjs render op caching on mobile devices, etc.

memoize1 clj/s

memoize_ clj/s

(memoize_ f)

Like core/memoize but faster, non-racy, and supports invalidation.

memoized clj/s

(memoized cache f & args)

merge clj/s

(merge & maps)

Like core/merge but faster, supports :swap/dissoc rvals.

merge-deep clj/s

merge-deep-with clj/s

merge-headers clj

(merge-headers rresp headers)

merge-keywords clj/s

(merge-keywords ks)

(merge-keywords ks omit-slash?)

merge-meta clj/s

(merge-meta x m)

merge-url-with-query-string clj/s

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

merge-with clj/s

(merge-with f & maps)

Like core/merge-with but faster, supports :swap/dissoc rvals.

min* clj/s macro

(min* n1 n2)

min-long clj/s

ms clj/s

(ms & {:as opts :keys [years months weeks days hours mins secs msecs ms]})

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

ms->secs clj/s

(ms->secs ms)

msecs clj/s macro

(msecs & opts)

Compile-time version of ms

name-with-attrs clj/s

(name-with-attrs sym args)

(name-with-attrs sym args attrs-merge)

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

named? clj/s

(named? x)

nano-time clj/s

nano-time* clj/s macro

(nano-time* & args)

nanoid clj/s

(nanoid)

(nanoid len)

Experimental. Optimized variant of secure-rand-id that returns Nano IDs as in https://github.com/ai/nanoid.

nanoid-alphabet clj/s

nat-float? clj/s

(nat-float? x)

nat-int? clj/s

(nat-int? x)

nat-num? clj/s

(nat-num? x)

nblank-str? clj/s

(nblank-str? x)

nblank? clj/s

(nblank? x)

neg-float? clj/s

(neg-float? x)

neg-int? clj/s

(neg-int? x)

neg-num? clj/s

(neg-num? x)

nempty-str? clj/s

(nempty-str? x)

nested-merge clj/s

(nested-merge & maps)

Like merge but does nested merging.

nested-merge-with clj/s

(nested-merge-with f & maps)

Like merge-with but does nested merging.

new-object clj/s macro

(new-object)

nil->sentinel clj/s

(nil->sentinel x)

nil->str clj/s

(nil->str x)

nil/undefined -> "nil"

nneg-float? clj/s

nneg-int? clj/s

nneg-num? clj/s

nneg? clj/s

(nneg? x)

nnil clj/s

(nnil)

(nnil x)

(nnil x y)

(nnil x y z)

(nnil x y z & more)

Returns first non-nil arg, or nil.

nnil-set clj/s

(nnil-set x)

nnil= clj/s

nnil? clj/s

node-paths clj/s

(node-paths m)

(node-paths node-pred m)

(node-paths node-pred m basis)

node-target? cljs

norm-str clj

(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 e/o #{:nfc :nfkc :nfd :nfkd <java.text.NormalizerForm>}. Defaults to :nfc as per W3C recommendation.

norm-word-breaks clj/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.

normalize-headers clj

(normalize-headers rreq-or-rresp)

now-dt clj/s

(now-dt)

now-dt* clj/s macro

(now-dt*)

now-nano clj/s≠

clj

(now-nano)

cljs

Uses window context as epoch, Ref. http://goo.gl/mWZWnR

now-nano* clj/s macro

(now-nano*)

now-udt clj/s

(now-udt)

now-udt* clj/s macro

(now-udt*)

nvec? clj/s

(nvec? n x)

oget cljs

(oget k)

(oget o k)

(oget o k not-found)

Like get for JS objects, Ref. https://goo.gl/eze8hY.

oget-in cljs

(oget-in ks)

(oget-in o ks)

(oget-in o ks not-found)

Like get-in for JS objects.

oset cljs

(oset o k v)

parse-bool clj/s

parse-float clj/s

parse-int clj/s

parse-query-params clj/s

(parse-query-params s & [keywordize? encoding])

Based on ring-codec/form-decode.

parse-version clj/s

(parse-version x)

path clj/s

(path & parts)

perc clj/s

(perc n divisor)

pint? clj/s

pnum? clj/s

(pnum? x)

pos-float? clj/s

(pos-float? x)

pos-int? clj/s

(pos-int? x)

pos-num? clj/s

(pos-num? x)

pow clj/s

(pow n exp)

pr-edn clj/s

(pr-edn x)

(pr-edn _opts x)

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

preserve-reduced clj/s

(preserve-reduced rf)

As core/preserving-reduced.

pull-val! clj/s

(pull-val! atom_ k)

(pull-val! atom_ k not-found)

Removes and returns value mapped to key.

pval? clj/s

qb clj/s macro

(qb & args)

qbench clj/s macro

(qbench & args)

qname clj/s

qualified-ident? clj/s

(qualified-ident? x)

qualified-keyword? clj/s

(qualified-keyword? x)

qualified-symbol? clj/s

(qualified-symbol? x)

queue clj/s

(queue)

(queue coll)

Returns a PersistentQueue.

queue* clj/s

(queue* & items)

queue? clj/s

(queue? x)

quick-bench clj/s macro

(quick-bench nlaps form)

(quick-bench nlaps form & more)

Returns fastest of 3 sets of times for each form, in msecs.

rate-limit clj/s

(rate-limit specs f)

rate-limited clj/s

(rate-limited ncalls-limit window-ms f)

rate-limiter clj/s

(rate-limiter ncalls-limit window-ms)

rate-limiter* clj/s

(rate-limiter* specs)

Deprecated, prefer limiter

rcompare clj/s

(rcompare x y)

Reverse comparator.

re-pattern? clj/s

(re-pattern? x)

read-edn clj/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.

read-sys-val clj

(read-sys-val id)

(read-sys-val prop-id env-id)

redirect-resp clj

reduce-indexed clj/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.

reduce-kvs clj/s

(reduce-kvs rf init kvs)

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

reduce-n clj/s

(reduce-n rf init end)

(reduce-n rf init start end)

(reduce-n rf init start end step)

reduce-obj cljs

(reduce-obj f init o)

Like reduce-kv but for JavaScript objects.

reduce-top clj/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 ...)).

regular-num? cljs

(regular-num? x)

remove-keys clj/s

(remove-keys pred m)

remove-kvs clj/s

(remove-kvs pred m)

remove-vals clj/s

(remove-vals pred m)

removev clj/s

(removev pred coll)

repeatedly* clj/s macro

(repeatedly* n & body)

repeatedly-into clj/s

(repeatedly-into coll n f)

Like repeatedly but faster and conjs items into given collection.

repeatedly-into* clj/s macro

(repeatedly-into* coll n & body)

Deprecated

replace-in clj/s

(replace-in m & ops)

reportf cljs

(reportf fmt & xs)

reset!? clj/s

(reset!? atom_ val)

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

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

reset-val! clj/s

(reset-val! atom_ k val)

(reset-val! atom_ k not-found val)

Low-level util, returns <old-key-val>.

reset-val!? clj/s

(reset-val!? atom_ k new-val)

Maps value to key and returns true iff the mapped value changed or was created.

revery clj/s

(revery pred coll)

revery-kv clj/s

(revery-kv pred coll)

revery-kv? clj/s

(revery-kv? pred coll)

revery? clj/s

(revery? pred coll)

rfirst clj/s

(rfirst pred coll)

rfirst-kv clj/s

(rfirst-kv pred coll)

ring-default-headers clj

(ring-default-headers headers rresp)

ring-merge-headers clj

(ring-merge-headers headers rresp)

ring-redirect-resp clj

(ring-redirect-resp url)

(ring-redirect-resp kind url)

(ring-redirect-resp kind url flash)

ring-resp-map clj

(ring-resp-map x)

ring-set-body clj

(ring-set-body body rresp)

ring-set-headers clj

(ring-set-headers headers rresp)

ring-set-status clj

(ring-set-status code rresp)

rnum? clj/s

(rnum? x)

rolling-counter clj/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.

RollingCounter cljs

round clj/s

(round n & [type nplaces])

round* clj/s

(round* n)

(round* type n)

(round* type nplaces n)

round0 clj/s

(round0 n)

round1 clj/s

(round1 n)

round2 clj/s

(round2 n)

rsome clj/s

(rsome pred coll)

rsome-kv clj/s

(rsome-kv pred coll)

run! clj/s

(run! proc coll)

run!* clj/s

run-kv! clj/s

(run-kv! proc m)

run-kvs! clj/s

(run-kvs! proc kvs)

run-obj! cljs

(run-obj! proc obj)

sayf cljs

(sayf fmt & xs)

sayp cljs

(sayp & xs)

sb-append clj/s

(sb-append str-builder s)

(sb-append str-builder s & more)

For cross-platform string building

secs clj/s

secs->ms clj/s

(secs->ms secs)

secure-rand-bytes clj/s

(secure-rand-bytes size)

Returns size random bytes using secure-rng or js/Crypto.

secure-rand-id clj/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.

secure-rng clj

(secure-rng)

Returns a thread-local java.security.SecureRandom. Favours security over performance. Automatically re-seeds occasionally. May block while waiting on system entropy!

sentinel clj/s

sentinel->nil clj/s

(sentinel->nil x)

sentinel? clj/s

(sentinel? x)

seq-kvs clj/s

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

session-swap clj

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

set* clj/s

set-body clj

(set-body rresp body)

set-exp-backoff-timeout! cljs

(set-exp-backoff-timeout! nullary-f & [nattempt])

set-status clj

(set-status rresp code)

simple-date-format clj

(simple-date-format pattern & [{:keys [locale timezone] :as opts}])

Returns a thread-local java.text.SimpleDateFormat.

simple-date-format* clj

(simple-date-format* pattern locale timezone)

simple-ident? clj/s

(simple-ident? x)

simple-keyword? clj/s

(simple-keyword? x)

simple-symbol? clj/s

(simple-symbol? x)

SimpleCacheEntry cljs

singleton? clj/s

(singleton? coll)

slurp-file-resource clj

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

slurp-resource clj

(slurp-resource rname)

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

some= clj/s

(some= x y)

(some= x y & more)

some? clj/s

(some? x)

sortv clj/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.

spaced-str clj/s

(spaced-str xs)

spaced-str-with-nils clj/s

(spaced-str-with-nils xs)

srng clj

str-?index clj/s

(str-?index s substr)

(str-?index s substr start-idx)

(str-?index s substr start-idx last?)

str-builder clj/s

For cross-platform string building

str-builder? clj/s

(str-builder? x)

str-contains? clj/s

(str-contains? s substr)

str-ends-with? clj/s

(str-ends-with? s substr)

str-join clj/s

(str-join coll)

(str-join separator coll)

(str-join separator xform coll)

Faster, transducer-based generalization of clojure.string/join with xform support

str-join-once clj/s

(str-join-once separator coll)

Like string/join but skips duplicate separators.

str-replace clj/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.

str-rf clj/s

String builder reducing fn

str-starts-with? clj/s

(str-starts-with? s substr)

stringy? clj/s

(stringy? x)

sub-indexes clj/s

(sub-indexes x start-idx & {:keys [max-len end-idx]})

substr clj/s

(substr s start-idx & [?max-len])

Deprecated, prefer get-substr or get-substring

subvec* clj/s

(subvec* v start-idx & [?max-len])

Deprecated, prefer get-subvec or get-subvector

swap!* clj/s

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

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 [<old-key-val> <new-key-val>].

swap-val! clj/s

(swap-val! atom_ k f)

(swap-val! atom_ k not-found f)

Low-level util, returns <new-key-val> or <swapped-return-val>.

swap-val!* clj/s

(swap-val!* atom_ k f)

(swap-val!* atom_ k not-found f)

Low-level util, returns [<old-key-val> <new-key-val>].

swapped clj/s

(swapped new-val return-val)

Swapped cljs

swapped* clj/s

swapped-vec clj/s

(swapped-vec x)

swapped? clj/s

(swapped? x)

system-newline clj/s

takev clj/s

(takev n coll)

thread-local-proxy clj/s macro

(thread-local-proxy & body)

throwable? clj

(throwable? x)

thrown clj/s macro

(thrown form)

(thrown c form)

(thrown c pattern form)

Evaluates form and returns ?throwable thrown by form that matches given criteria:

• c may be:

  • A class (e.g. ArithmeticException, AssertionError, etc.)
  • :default => default platform throwable (Exception or js/Error)
  • :any => any platform throwable (Throwable 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.

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

TickedCacheEntry cljs

time-ms clj/s macro

(time-ms & body)

Returns number of milliseconds it took to execute body.

time-ns clj/s macro

(time-ns & body)

Returns number of nanoseconds it took to execute body.

timeout-future? clj/s

(timeout-future? x)

TimeoutFuture cljs

top clj/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.

top-into clj/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.

tracef cljs

(tracef fmt & xs)

transient? clj/s

(transient? x)

udt? clj/s

(udt? x)

uint? clj/s

undefined->nil cljs

(undefined->nil x)

update-in clj/s

(update-in m ks f)

(update-in m ks not-found f)

Like core/update-in but resolves an ambiguity with empty ks, adds support for not-found, :swap/dissoc vals.

update-in* clj/s

uri? clj

(uri? x)

url-decode clj/s

(url-decode s & [encoding])

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

url-encode clj/s≠

clj

(url-encode s & [encoding])

cljs

(url-encode s)

Based on https://goo.gl/fBqy6e

use-fixtures* clj/s macro

(use-fixtures* & args)

uuid-str clj/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

vec* clj/s

vec2? clj/s

(vec2? x)

vec3? clj/s

(vec3? x)

vinterleave-all clj/s

(vinterleave-all c1 c2)

vnext clj/s

(vnext v)

vrest clj/s

(vrest v)

vsplit-first clj/s

(vsplit-first v)

vsplit-last clj/s

(vsplit-last v)

warnf cljs

(warnf fmt & xs)

when clj/s macro

(when test-or-bindings & body)

Like core/when but acts like when-let when given a binding vector as test expr.

when-let clj/s macro

(when-let bindings & body)

Like core/when-let but can bind multiple values for body iff all tests are truthy, supports internal unconditional :lets.

when-lets clj/s macro

(when-lets & args)

when-not clj/s macro

(when-not test-or-bindings & body)

Like core/when-not but acts like when-let when given a binding vector as test expr.

when-some clj/s macro

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

when? clj/s

(when? pred x)

with-dynamic-assertion-data clj/s macro

(with-dynamic-assertion-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.

without-meta clj/s

(without-meta x)

xdistinct clj/s

(xdistinct)

(xdistinct keyfn)

zero-num? clj/s

(zero-num? x)