taoensso.encore — district0x/cljs-ipfs-native 0.0.6

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 cljs

(->?singleton coll)

->vec cljs

(->vec x)

-as-throw cljs

(-as-throw as-name x)

-assert-unstub-val cljs

(-assert-unstub-val f)

-cas! cljs macro

(-cas! atom_ old-val new-val)

Micro optimization.

-core-merge cljs

-core-update-in cljs

-gc-now? cljs macro

(-gc-now?)

-intern-stub cljs macro

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

-merge-with cljs

(-merge-with nest? f maps)

-new-stubfn_ cljs

(-new-stubfn_ name)

-swap-cache! cljs

-swap-k! cljs

-swap-val! cljs

(-swap-val! atom_ k f)

Used internally by memoization utils.

-unswapped cljs

-vol! cljs macro

(-vol! val)

-vol-reset! cljs macro

(-vol-reset! vol_ val)

-vol-swap! cljs macro

(-vol-swap! vol_ f & args)

-vswapped cljs

<* cljs macro

(<* x y z)

<=* cljs macro

(<=* x y z)

>* cljs macro

(>* x y z)

>=* cljs macro

(>=* x y z)

?substr<idx cljs

?substr<len cljs

?subvec<idx cljs

?subvec<len cljs

a0-memoize_ cljs

a1-memoize_ cljs

abs cljs

(abs n)

after-timeout cljs 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= cljs

(approx= x y)

(approx= x y signf)

approx== cljs

(approx== x y)

(approx== signf x y)

as-?bool cljs

(as-?bool x)

as-?email cljs

(as-?email ?s)

as-?float cljs

(as-?float x)

as-?int cljs

(as-?int x)

as-?kw cljs

(as-?kw x)

as-?name cljs

(as-?name x)

as-?nat-float cljs

(as-?nat-float x)

as-?nat-int cljs

(as-?nat-int x)

as-?nblank cljs

(as-?nblank x)

as-?nemail cljs

(as-?nemail ?s)

as-?nempty-str cljs

(as-?nempty-str x)

as-?nzero cljs

(as-?nzero x)

as-?pfloat cljs

as-?pint cljs

as-?pos-float cljs

(as-?pos-float x)

as-?pos-int cljs

(as-?pos-int x)

as-?pval cljs

(as-?pval x)

as-?qname cljs

(as-?qname x)

as-?udt cljs

(as-?udt x)

as-?ufloat cljs

as-?uint cljs

as-bool cljs

(as-bool x)

as-email cljs

(as-email x)

as-float cljs

(as-float x)

as-int cljs

(as-int x)

as-kw cljs

(as-kw x)

as-map cljs

(as-map kvs & [kf vf])

Deprecated, prefer reduce-kvs

as-name cljs

(as-name x)

as-nat-float cljs

(as-nat-float x)

as-nat-int cljs

(as-nat-int x)

as-nblank cljs

(as-nblank x)

as-nemail cljs

(as-nemail x)

as-nempty-str cljs

(as-nempty-str x)

as-nzero cljs

(as-nzero x)

as-pfloat cljs

as-pint cljs

as-pos-float cljs

(as-pos-float x)

as-pos-int cljs

(as-pos-int x)

as-pval cljs

(as-pval x)

as-qname cljs

(as-qname x)

as-udt cljs

(as-udt x)

as-ufloat cljs

as-uint cljs

assert-min-encore-version cljs

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

Version check for dependency conflicts, etc.

assoc-nx cljs

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

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

(assoc-when m kvs)

(assoc-when m k v)

(assoc-when m k v & kvs)

Assocs each kv iff its val is truthy.

atom? cljs

(atom? x)

backport-run! cljs

bench cljs macro

(bench nlaps opts & body)

boolean? cljs

(boolean? x)

call-after-timeout cljs

(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 cljs macro

(case-eval expr & clauses)

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

catch-errors cljs macro

(catch-errors & body)

catch-errors* cljs macro

(catch-errors* & args)

catching cljs 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 cljs macro

(caught-error-data & body)

Handy for error-throwing unit tests.

chan? cljs

(chan? x)

check-all cljs macro

(check-all test)

(check-all test & more)

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

check-some cljs macro

(check-some test)

(check-some test & more)

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

clamp cljs

(clamp nmin nmax n)

clamp* cljs macro

(clamp* nmin nmax n)

clj1098 cljs

(clj1098 x)

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

compile-if cljs 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 cljs

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

compile-when cljs macro

(compile-when test & body)

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

cond! cljs macro

(cond! & clauses)

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

cond* cljs macro

(cond* & args)

cond-throw cljs macro

(cond-throw & args)

conj-some cljs

(conj-some)

(conj-some coll)

(conj-some coll x)

(conj-some coll x & more)

Conjoins each non-nil value.

conj-when cljs

(conj-when)

(conj-when coll)

(conj-when coll x)

(conj-when coll x & more)

Conjoins each truthy value.

contains-in? cljs

(contains-in? coll ks)

(contains-in? coll ks k)

count-words cljs

(count-words s)

debugf cljs

(debugf fmt & xs)

declare-remote cljs macro

(declare-remote & syms)

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

defalias cljs macro

(defalias src)

(defalias sym src)

(defalias sym src attrs)

Defines an alias for a var, preserving its metadata.

default-timeout-impl_ cljs

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

(defonce sym & args)

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

defonce* cljs macro

(defonce* & args)

defstub cljs 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 cljs macro

(deprecated & body)

Elides body when TAOENSSO_ELIDE_DEPRECATED sys val is truthy.

derefable? cljs

(derefable? x)

dissoc-in cljs

(dissoc-in m ks dissoc-k)

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

distinct-by cljs

(distinct-by keyfn coll)

Deprecated, prefer xdistinct

distinct-elements? cljs

(distinct-elements? x)

distinctv cljs

(distinctv coll)

(distinctv keyfn coll)

Deprecated, prefer xdistinct

do-false cljs macro

(do-false & body)

do-nil cljs macro

(do-nil & body)

do-true cljs macro

(do-true & body)

doto-cond cljs macro

(doto-cond [sym x] & clauses)

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

dswap! cljs

editable? cljs

(editable? x)

encore-version cljs

error-data cljs

(error-data x)

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

error? cljs

(error? x)

errorf cljs

(errorf fmt & xs)

every cljs

exp-backoff cljs

(exp-backoff n-attempt)

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

Returns binary exponential backoff value for n<=36.

expect cljs macro

(expect expr)

(expect val expr)

(expect bindings val expr)

explode-keyword cljs

(explode-keyword k)

fatalf cljs

(fatalf fmt & xs)

filter-keys cljs

(filter-keys pred m)

filter-kvs cljs

(filter-kvs pred m)

filter-vals cljs

(filter-vals pred m)

float? cljs

(float? x)

force-ref cljs

(force-ref x)

Like force for refs.

format cljs

(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* cljs

(format* fmt args)

format-query-string cljs

(format-query-string m)

fq-name cljs

fzipmap cljs

(fzipmap ks vs)

get-env cljs macro

(get-env)

get-substr cljs

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

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

(get-subvec v start)

(get-subvec v start end)

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

get-subvector cljs

(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-win-loc cljs

(get-win-loc)

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

get-window-location cljs

greatest cljs

(greatest coll & [?comparator])

have cljs 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! cljs 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!? cljs 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-in cljs macro

(have-in a1 & an)

have-in! cljs macro

(have-in! a1 & an)

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

(ident? x)

idx-fn cljs

(idx-fn)

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

if-clj cljs macro

(if-clj then & [else])

if-cljs cljs macro

(if-cljs then & [else])

if-let cljs 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 :lets.

if-lets cljs macro

(if-lets & args)

if-not cljs 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* cljs macro

(if-not* & args)

if-some cljs 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 :lets.

indexed? cljs

(indexed? x)

infof cljs

(infof fmt & xs)

int? cljs

(int? x)

interleave-all cljs

(interleave-all)

(interleave-all c1)

(interleave-all c1 c2)

(interleave-all c1 c2 & colls)

Greedy version of interleave.

into! cljs

(into! to from)

(into! to xform from)

into-all cljs

(into-all to from)

(into-all to from & more)

Like into but supports multiple "from"s.

into-str cljs

(into-str & xs)

Simple Hiccup-like string templating to complement Tempura.

is! cljs

(is! x)

(is! pred x)

(is! pred x fail-?data)

Cheaper have! that provides less diagnostic info.

ITimeoutFuture cljs protocol

tf-cancel! cljs

(tf-cancel! _)

Returns true iff the timeout was successfully cancelled (i.e. was previously pending).

tf-poll cljs

(tf-poll _)

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

tf-done? cljs

(tf-done? _)

Returns true iff the timeout is not pending (i.e. has a completed result or is cancelled).

tf-state cljs

(tf-state _)

Returns a map of timeout's public state.

tf-pending? cljs

(tf-pending? _)

Returns true iff the timeout is pending.

tf-cancelled? cljs

(tf-cancelled? _)

Returns true iff the timeout is cancelled.

ITimeoutImpl cljs protocol

-schedule-timeout cljs

(-schedule-timeout _ msecs f)

join-once cljs

(join-once sep & coll)

js-?win cljs

keys-by cljs

(keys-by f coll)

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

keys<= cljs

(keys<= m ks)

keys= cljs

(keys= m ks)

keys=nnil? cljs

(keys=nnil? m ks)

keys>= cljs

(keys>= m ks)

keywordize-map cljs

(keywordize-map m)

ks-nnil? cljs

(ks-nnil? ks m)

ks<= cljs

(ks<= ks m)

ks= cljs

(ks= ks m)

ks>= cljs

(ks>= ks m)

kw-identical? cljs

lazy-seq? cljs

(lazy-seq? x)

least cljs

(least coll & [?comparator])

LimitEntry cljs

limiter cljs

(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* cljs

(limiter* specs)

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

LimitHits cljs

LimitSpec cljs

log cljs

logf cljs

(logf fmt & xs)

logging-level cljs

logp cljs

(logp & xs)

map-keys cljs

(map-keys f m)

map-kvs cljs

(map-kvs kf vf m)

Deprecated, prefer reduce-kv

map-vals cljs

(map-vals f m)

mapply cljs

(mapply f & args)

Like apply but calls seq-kvs on final arg.

max* cljs macro

(max* n1 n2)

max-long cljs

memoize* cljs

(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-1 cljs

memoize-a0_ cljs

memoize-a1_ cljs

memoize-last cljs

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

memoize_ cljs

(memoize_ f)

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

memoized cljs

(memoized cache f & args)

merge cljs

(merge & maps)

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

merge-deep cljs

merge-deep-with cljs

merge-keywords cljs

(merge-keywords ks)

(merge-keywords ks omit-slash?)

merge-meta cljs

(merge-meta x m)

merge-url-with-query-string cljs

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

merge-with cljs

(merge-with f & maps)

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

min* cljs macro

(min* n1 n2)

min-long cljs

ms cljs

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

(ms->secs ms)

name-with-attrs cljs

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

(named? x)

nano-time cljs

nano-time* cljs macro

(nano-time* & args)

nat-float? cljs

(nat-float? x)

nat-int? cljs

(nat-int? x)

nat-num? cljs

(nat-num? x)

nblank-str? cljs

(nblank-str? x)

nblank? cljs

(nblank? x)

neg-float? cljs

(neg-float? x)

neg-int? cljs

(neg-int? x)

neg-num? cljs

(neg-num? x)

nempty-str? cljs

(nempty-str? x)

nested-merge cljs

(nested-merge & maps)

Like merge but does nested merging.

nested-merge-with cljs

(nested-merge-with f & maps)

Like merge-with but does nested merging.

new-object cljs macro

(new-object)

nil->sentinel cljs

(nil->sentinel x)

nil->str cljs

(nil->str x)

nil/undefined -> "nil"

nneg-float? cljs

nneg-int? cljs

nneg-num? cljs

nneg? cljs

(nneg? x)

nnil cljs

(nnil)

(nnil x)

(nnil x y)

(nnil x y z)

(nnil x y z & more)

Returns first non-nil arg, or nil.

nnil-set cljs

(nnil-set x)

nnil= cljs

nnil? cljs

node-target? cljs

norm-word-breaks cljs

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

now-dt cljs

(now-dt)

now-dt* cljs macro

(now-dt*)

now-nano cljs

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

now-nano* cljs macro

(now-nano*)

now-udt cljs

(now-udt)

now-udt* cljs macro

(now-udt*)

nvec? cljs

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

parse-bool cljs

parse-float cljs

parse-int cljs

parse-query-params cljs

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

Based on ring-codec/form-decode.

parse-version cljs

(parse-version x)

path cljs

(path & parts)

pint? cljs

pos-float? cljs

(pos-float? x)

pos-int? cljs

(pos-int? x)

pos-num? cljs

(pos-num? x)

pow cljs

(pow n exp)

pr-edn cljs

(pr-edn x)

(pr-edn _opts x)

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

preserve-reduced cljs

(preserve-reduced rf)

As core/preserving-reduced.

pull-val! cljs

(pull-val! atom_ k)

(pull-val! atom_ k not-found)

Removes and returns value mapped to key.

pval? cljs

(pval? x)

qb cljs macro

(qb & args)

qbench cljs macro

(qbench & args)

qname cljs

qualified-ident? cljs

(qualified-ident? x)

qualified-keyword? cljs

(qualified-keyword? x)

qualified-symbol? cljs

(qualified-symbol? x)

queue cljs

(queue)

(queue coll)

Returns a PersistentQueue.

queue* cljs

(queue* & items)

queue? cljs

(queue? x)

quick-bench cljs macro

(quick-bench nlaps form)

(quick-bench nlaps form & more)

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

rate-limit cljs

(rate-limit specs f)

rate-limited cljs

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

rate-limiter cljs

(rate-limiter ncalls-limit window-ms)

rate-limiter* cljs

(rate-limiter* specs)

Deprecated, prefer limiter

rcompare cljs

(rcompare x y)

Reverse comparator.

re-pattern? cljs

(re-pattern? x)

read-edn cljs

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

reduce-indexed cljs

(reduce-indexed rf init coll)

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

reduce-kvs cljs

(reduce-kvs rf init kvs)

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

reduce-n cljs

(reduce-n rf init n)

reduce-obj cljs

(reduce-obj f init o)

Like reduce-kv but for JavaScript objects.

reduce-top cljs

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

(remove-keys pred m)

remove-kvs cljs

(remove-kvs pred m)

remove-vals cljs

(remove-vals pred m)

removev cljs

(removev pred coll)

repeatedly* cljs macro

(repeatedly* n & body)

repeatedly-into cljs

(repeatedly-into coll n f)

Like repeatedly but faster and conjs items into given collection.

repeatedly-into* cljs macro

(repeatedly-into* coll n & body)

Deprecated

replace-in cljs

(replace-in m & ops)

reportf cljs

(reportf fmt & xs)

reset-in! cljs

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

(reset-val! atom_ k val)

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

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

reset-val!? cljs

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

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

revery cljs

(revery pred coll)

revery-kv cljs

(revery-kv pred coll)

revery-kv? cljs

(revery-kv? pred coll)

revery? cljs

(revery? pred coll)

rfirst cljs

(rfirst pred coll)

rfirst-kv cljs

(rfirst-kv pred coll)

round cljs

(round n & [type nplaces])

round* cljs

(round* n)

(round* type n)

(round* type nplaces n)

round0 cljs

(round0 n)

round1 cljs

(round1 n)

round2 cljs

(round2 n)

rsome cljs

(rsome pred coll)

rsome-kv cljs

(rsome-kv pred coll)

run! cljs

(run! proc coll)

run!* cljs

run-kv! cljs

(run-kv! proc m)

run-kvs! cljs

(run-kvs! proc kvs)

run-obj! cljs

(run-obj! proc obj)

sayf cljs

(sayf fmt & xs)

sayp cljs

(sayp & xs)

sb-append cljs

(sb-append str-builder s)

(sb-append str-builder s & more)

For cross-platform string building

secs cljs

secs->ms cljs

(secs->ms secs)

sentinel cljs

sentinel->nil cljs

(sentinel->nil x)

sentinel? cljs

(sentinel? x)

seq-kvs cljs

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

set* cljs

set-exp-backoff-timeout! cljs

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

simple-ident? cljs

(simple-ident? x)

simple-keyword? cljs

(simple-keyword? x)

simple-symbol? cljs

(simple-symbol? x)

SimpleCacheEntry cljs

singleton? cljs

(singleton? coll)

some= cljs

(some= x y)

(some= x y & more)

some? cljs

(some? x)

spaced-str cljs

(spaced-str xs)

spaced-str-with-nils cljs

(spaced-str-with-nils xs)

str-?index cljs

(str-?index s substr)

(str-?index s substr start-idx)

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

str-builder cljs

For cross-platform string building

str-builder? cljs

(str-builder? x)

str-contains? cljs

(str-contains? s substr)

str-ends-with? cljs

(str-ends-with? s substr)

str-join cljs

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

(str-join-once separator coll)

Like string/join but skips duplicate separators.

str-replace cljs

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

String builder reducing fn

str-starts-with? cljs

(str-starts-with? s substr)

stringy? cljs

(stringy? x)

sub-indexes cljs

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

substr cljs

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

Deprecated, prefer get-substr or get-substring

subvec* cljs

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

Deprecated, prefer get-subvec or get-subvector

swap!* cljs

swap-in! cljs

(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!* cljs

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

(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!* cljs

(swap-val!* atom_ k f)

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

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

swapped cljs

(swapped new-val return-val)

Swapped cljs

swapped* cljs

swapped-vec cljs

(swapped-vec x)

swapped? cljs

(swapped? x)

takev cljs

(takev n coll)

thread-local-proxy cljs macro

(thread-local-proxy & body)

TickedCacheEntry cljs

time-ms cljs macro

(time-ms & body)

Returns number of milliseconds it took to execute body.

time-ns cljs macro

(time-ns & body)

Returns number of nanoseconds it took to execute body.

timeout-future? cljs

(timeout-future? x)

TimeoutFuture cljs

top cljs

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

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

(udt? x)

uint? cljs

undefined->nil cljs

(undefined->nil x)

update-in cljs

(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* cljs

url-decode cljs

(url-decode s & [encoding])

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

url-encode cljs

(url-encode s)

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

use-fixtures cljs macro

(use-fixtures fixture-type & fixtures)

Cross-platform test/use-fixtures

use-fixtures* cljs macro

(use-fixtures* & args)

uuid-str cljs

(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* cljs

vec2? cljs

(vec2? x)

vec3? cljs

(vec3? x)

vinterleave-all cljs

(vinterleave-all c1 c2)

vnext cljs

(vnext v)

vrest cljs

(vrest v)

vsplit-first cljs

(vsplit-first v)

vsplit-last cljs

(vsplit-last v)

warnf cljs

(warnf fmt & xs)

when cljs macro

(when test-or-bindings & body)

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

when-let cljs macro

(when-let bindings & body)

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

when-lets cljs macro

(when-lets & args)

when-not cljs 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 cljs macro

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

when? cljs

(when? pred x)

with-dynamic-assertion-data cljs 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 cljs

(without-meta x)

xdistinct cljs

(xdistinct)

(xdistinct keyfn)

zero-num? cljs

(zero-num? x)