taoensso.encore — com.taoensso/encore 2.108.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)

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

-unstub-stub-test cljs

(-unstub-stub-test f)

-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-?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-?nempty-str clj/s

(as-?nempty-str x)

as-?nzero clj/s

(as-?nzero x)

as-?pfloat clj/s

as-?pint clj/s

as-?pos-float clj/s

(as-?pos-float x)

as-?pos-int clj/s

(as-?pos-int x)

as-?pval clj/s

(as-?pval x)

as-?qname clj/s

(as-?qname 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-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-nempty-str clj/s

(as-nempty-str x)

as-nzero clj/s

(as-nzero x)

as-pfloat clj/s

as-pint clj/s

as-pos-float clj/s

(as-pos-float x)

as-pos-int clj/s

(as-pos-int x)

as-pval clj/s

(as-pval x)

as-qname clj/s

(as-qname 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)

clj-thing clj

clj1098 clj/s

(clj1098 x)

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

cljs-macro clj/s macro

(cljs-macro)

cljs-thing cljs

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

Returns (fn [?ns]) -> truthy.

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 test keywords: :else, :let, :do, :when, :when-not, :when-some. :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)

count-words clj/s

(count-words s)

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)

Defines an alias for a var, preserving its metadata.

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>. Separates 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 sys val is truthy.

derefable? clj/s

(derefable? x)

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

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)

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)

Experimental. 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-val clj

(get-sys-val 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

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

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

have? clj/s macro

(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

ident? clj/s

(ident? x)

idx-fn clj/s

(idx-fn)

Returns a new stateful index fn that returns: 0, 1, 2, ...

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.

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

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-target? cljs

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 req-or-resp)

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

(oget o k not-found)

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

oget-in cljs

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

pint? clj/s

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

(pval? x)

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)

redirect-resp clj

(redirect-resp url)

(redirect-resp type url & [flash])

reduce-indexed clj/s

(reduce-indexed rf init coll)

Like reduce but takes (rf [acc idx in]) with idx as in map-indexed.

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-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 into in O(N.logn) time. For comparsion, (take n (sort-by ...)) is O(N.logN).

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

ring-merge-headers clj

(ring-merge-headers headers resp)

ring-resp-map clj

(ring-resp-map x)

ring-set-body clj

(ring-set-body body resp)

ring-set-headers clj

(ring-set-headers headers resp)

ring-set-status clj

(ring-set-status code resp)

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)

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 req resp 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 resp body)

set-exp-backoff-timeout! cljs

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

set-status clj

(set-status resp 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)

spaced-str clj/s

(spaced-str xs)

spaced-str-with-nils clj/s

(spaced-str-with-nils xs)

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)

stub-test clj/s≠

clj

(stub-test x)

Returns its argument.

cljs

(stub-test & args)

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)

takev clj/s

(takev n coll)

thread-local-proxy clj/s macro

(thread-local-proxy & body)

throwable? clj

(throwable? x)

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)

udt? clj/s

(udt? x)

uint? clj/s

undefined->nil cljs

(undefined->nil x)

unstub-stub-test clj/s≠

clj

(unstub-stub-test x)

Initializes stub

cljs

(unstub-stub-test f)

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)