taoensso.encore — hswick/jutsu 0.1.3

Some tools I use often, w/o any external deps.

*log-level* cljs

DEPRECATED

->?singleton cljs

(->?singleton coll)

->vec cljs

(->vec x)

abs cljs

(abs n)

ajax-lite cljs

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

Alpha - subject to change. Simple+lightweight Ajax via Google Closure. Returns nil, or the xhr instance. Ref. https://developers.google.com/closure/library/docs/xhrio.

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

as-?bool cljs

(as-?bool x)

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

(as-?nblank x)

as-bool cljs

(as-bool x)

as-float cljs

(as-float x)

as-int cljs

(as-int x)

as-map cljs

(as-map kvs & [kf vf])

Cross between hash-map & map-kvs.

assert-min-encore-version cljs

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

assertion-error cljs

(assertion-error msg)

assoc-some cljs

(assoc-some m & kvs)

Assocs each kv iff its value is not nil.

assoc-when cljs

(assoc-when m & kvs)

Assocs each kv iff its val is truthy.

atom? cljs

(atom? x)

backport-run! cljs

(backport-run! proc coll)

run! from Clojure 1.7+

bench cljs macro

(bench nlaps bench*-opts & body)

case-eval cljs macro

(case-eval e & clauses)

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

catch-errors cljs macro

(catch-errors & body)

Experimental. Returns [<?result> <?error>].

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)

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

check-some cljs macro

(check-some test)

(check-some test & more)

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

Workaround for Clojure versions [1.4, 1.5) that blow up on reduce-kvs against a nil coll, Ref. http://dev.clojure.org/jira/browse/CLJ-1098.

compile-if cljs macro

(compile-if test then & [?else])

Evaluates test. If it doesn't error and returns logical true, expands to then, otherwise expands to else. Stolen from clojure.core.reducers. (compile-if (Class/forName "java.util.concurrent.ForkJoinTask") (do-cool-stuff-with-fork-join) (fall-back-to-executor-services))

cond! cljs macro

(cond! & clauses)

Like cond but throws on no-match like case, condp.

cond-throw cljs macro

(cond-throw & args)

conj-some cljs

(conj-some coll ?x)

(conj-some coll ?x & ?xs)

contains-in? cljs

(contains-in? coll ks)

count-words cljs

(count-words s)

debugf cljs

(debugf fmt & xs)

declare-remote cljs macro

(declare-remote & names)

Declares the given ns-qualified names, preserving symbol metadata. Useful for circular dependencies.

defalias cljs macro

(defalias target)

(defalias name target)

(defalias name target doc)

Defines an alias for a var, preserving metadata. Adapted from clojure.contrib/def.clj, Ref. http://goo.gl/xpjeH

defonce* cljs macro

(defonce* name expr)

Like clojure.core/defonce but supports optional docstring and attributes map for name symbol.

dissoc-in cljs

(dissoc-in m ks & dissoc-ks)

distinct-by cljs

(distinct-by keyfn coll)

Like sort-by for distinct. Based on clojure.core/distinct.

distinct-elements? cljs

(distinct-elements? x)

distinctv cljs

(distinctv coll)

(distinctv keyfn coll)

Prefer set when order doesn't matter (much faster).

doto-cond cljs macro

(doto-cond [name x] & clauses)

Diabolical cross between doto, cond-> and as->.

encore-version cljs

Used for lib-consumer version assertions

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)

exp-backoff cljs

(exp-backoff nattempt
             &
             [{:keys [factor] min' :min max' :max :or {factor 1000}}])

Returns binary exponential backoff value.

explode-keyword cljs

(explode-keyword k)

fatalf cljs

(fatalf fmt & xs)

filter-keys cljs

(filter-keys pred m)

filter-kvs cljs

(filter-kvs predk predv m)

filter-vals cljs

(filter-vals pred m)

format cljs

(format fmt & args)

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

(fq-name x)

Like name but fully qualified: includes namespace in string when present.

fzipmap cljs

(fzipmap ks vs)

Faster zipmap using transients.

gc-now? cljs

(gc-now?)

get-window-location cljs

(get-window-location)

Returns browser window's current location. Forgeable.

greatest cljs

(greatest coll & [?comparator])

Returns the 'greatest' element in coll in O(n) time.

have cljs macro

(have (:!) x)

(have (:!) pred (:in) x)

(have (:!) pred (:in) x & more-xs)

EXPERIMENTAL. Takes a pred and one or more xs. Tests pred against each x, trapping errors. If any pred test fails, throws a detailed error. Otherwise returns input x/xs for convenient inline-use/binding.

Options:

• By default throws AssertionErrors subject to *assert* value (useful for catching errors during dev). Use a :! first arg to instead throw RuntimeExceptions irrespective of *assert* value (useful for important conditions in production).
• Use an :in arg after pred to treat x/xs as evaluated coll/colls.
• See hpred for various convenient pred modifier forms.

Provides a small, simple, deeply flexible alternative to heavier tools like core.typed, Prismatic/schema.

(fn square [x] (let [x (have integer? x)] (* x x))) (fn mult [x y] (let [[x y] (have integer? x y)] (* x y))) (fn mult-many [& xs] (reduce * (have :! [:or integer? float?] :in xs)))

have! cljs macro

(have! & args)

have!? cljs macro

(have!? & args)

have-in cljs macro

(have-in a1 & an)

have-in! cljs macro

(have-in! & args)

have? cljs macro

(have? (:!) x)

(have? (:!) pred (:in) x)

(have? (:!) pred (:in) x & more-xs)

EXPERIMENTAL. Like have but returns true rather than input on success (convenient for use in :pre/:post conds).

NB Be cautious using :! tests in :pre/:post conds since :pre/:post conds are themselves subject to *assert* val.

(fn square [x] {:pre [(have? integer? x)]} (* x x)) (fn mult [x y] {:pre [(have? integer? x y)]} (* x y))

hcond cljs

(hcond hard? ns-str line x_ x-form pred pred-form)

Implementation detail.

hpred cljs

(hpred pred-form)

Implementation detail.

hthrow cljs

(hthrow hard? ns-str ?line form val & [?err])

Implementation detail.

if-cljs cljs macro

(if-cljs then else)

Executes then clause iff generating ClojureScript code. Useful for writing macros that can produce different Clj/Cljs code (this isn't something Cljx currently provides support for). Stolen from Prismatic code, Ref. http://goo.gl/DhhhSN, http://goo.gl/Bhdyna.

if-lets cljs macro

(if-lets bindings then)

(if-lets bindings then else)

Like if-let but binds multiple values iff all tests are true.

infof cljs

(infof fmt & xs)

interleave-all cljs

(interleave-all)

(interleave-all c1)

(interleave-all c1 c2)

(interleave-all c1 c2 & colls)

Greedy version of interleave, Ref. http://goo.gl/KvzqWb.

into-all cljs

(into-all to from)

(into-all to from & more)

Like into but supports multiple "from"s.

join-once cljs

(join-once separator & coll)

Like clojure.string/join but ensures no double separators.

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

least cljs

(least coll & [?comparator])

Returns the 'least' element in coll in O(n) time.

log cljs

(log & xs)

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)

map-vals cljs

(map-vals f m)

mapply cljs

(mapply f & args)

Like apply but assumes last arg is a map whose elements should be applied to f as an unpaired seq: (mapply (fn [x & {:keys [y z]}] (str x y z)) 1 {:y 2 :z 3}) where fn will receive args as: (1 :y 2 :z 3).

max* cljs macro

(max* n1 n2)

memoize* cljs

(memoize* f)

(memoize* ttl-ms f)

(memoize* cache-size ttl-ms f)

Like clojure.core/memoize but:

• Uses delays to prevent race conditions on writes.
• Supports auto invalidation & gc with ttl-ms option.
• Supports manual invalidation by prepending args with :mem/del or :mem/fresh.
• Supports cache size limit & gc with cache-size option.

memoize-1 cljs

memoize1 cljs

(memoize1 f)

Great for Reactjs render op caching on mobile devices, etc.

memoize_ cljs

(memoize_ f)

As clojure.core/memoize but uses delays to avoid write races.

memoized cljs

(memoized cache f & args)

Like (memoize* f) but takes an explicit cache atom (possibly nil) and immediately applies memoized f to given arguments.

merge-deep cljs

merge-deep-with cljs

merge-keywords cljs

(merge-keywords ks & [no-slash?])

merge-url-with-query-string cljs

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

min* cljs macro

(min* n1 n2)

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 name macro-args)

Handles optional docstrings & attr maps for a macro def's name. Stolen from clojure.tools.macro.

nano-time cljs

nblank-str? cljs

(nblank-str? x)

nblank? cljs

(nblank? x)

nested-merge cljs

nested-merge-with cljs

(nested-merge-with f & maps)

nil->str cljs

(nil->str x)

nneg-int? cljs

(nneg-int? x)

nneg-num? cljs

(nneg-num? x)

nneg? cljs

(nneg? x)

nnil-set cljs

(nnil-set x)

nnil= cljs

(nnil= x y)

(nnil= x y & more)

nnil? cljs

(nnil? x)

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

(now-udt)

now-udt-mock-fn cljs

(now-udt-mock-fn & [mock-udts])

Useful for testing.

nvec? cljs

(nvec? n x)

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.

path cljs

(path & parts)

Joins string paths (URLs, file paths, etc.) ensuring correct "/" interposition.

pos-int? cljs

(pos-int? x)

pos-num? cljs

(pos-num? x)

pow cljs

(pow n exp)

qb cljs macro

(qb & args)

qb-min-times cljs

(qb-min-times times)

qbench cljs macro

(qbench nlaps form)

(qbench nlaps form & more)

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

queue cljs

(queue)

(queue coll)

Returns a PersistentQueue.

queue* cljs

(queue* & items)

queue? cljs

(queue? x)

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)

Takes one or more rate specs of form [ncalls-limit window-ms ?spec-id] and returns a (fn [& [req-id])) that returns nil (=> all rate limits passed), or [<ms-wait> <worst-offending-spec-id>] / <ms-wait>.

rcompare cljs

(rcompare x y)

Reverse comparator.

re-pattern? cljs

(re-pattern? x)

read-edn cljs

(read-edn s)

remove-vals cljs

(remove-vals pred m)

Smaller, common-case version of filter-vals. Esp useful with nil?/blank? pred when constructing maps: {:foo (when _ <...>) :bar (when _ <...>)} in a way that preservers :or semantics.

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)

replace-in cljs

(replace-in m & ops)

Experimental. For use with swap!, etc.

reportf cljs

(reportf fmt & xs)

reset-in! cljs

(reset-in! atom_ ks new-val)

(reset-in! atom_ ks new-val & more)

Is to reset! as swap-in! is to swap!.

round cljs

(round n & [type nplaces])

round* cljs

round1 cljs

(round1 n)

Optimized common case.

round2 cljs

(round2 n)

Optimized common case.

sayf cljs

(sayf fmt & xs)

sayp cljs

(sayp & xs)

secs cljs

secs->ms cljs

(secs->ms secs)

seq-kvs cljs

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

set* cljs

(set* x)

set-exp-backoff-timeout! cljs

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

singleton? cljs

(singleton? coll)

spaced-str cljs

(spaced-str xs)

spaced-str-with-nils cljs

(spaced-str-with-nils xs)

str-?index cljs

(str-?index s substr & [start-idx last?])

str-contains? cljs

(str-contains? s substr)

str-ends-with? cljs

(str-ends-with? s substr)

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

Returns [<inclusive-start-idx*> <exclusive-end-idx*>] for counted 0-indexed input (str, vec, etc.) with support for:

• Clamping of indexes beyond limits.
• Max-length -> end-index.
• -ive indexes (as +ive indexes but work from back of input): (+0) (+1) (+2) (+3) (+4) ; inclusive +ive indexes h e l l o ; 5 count (-5) (-4) (-3) (-2) (-1) ; inclusive -ive indexes

substr cljs

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

Gives a consistent, flexible, cross-platform substring API built on sub-indexes.

subvec* cljs

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

Like subvec but uses sub-indexes.

swap-in! cljs

(swap-in! atom_ ks f)

(swap-in! atom_ ks f & more)

More powerful version of swap!:

• Supports optional update-in semantics.
• Swap fn can return (swapped <new-val> <return-val>) rather than just <new-val>. This is useful when writing atomic pull fns, etc.

swap-val! cljs

(swap-val! atom_ k f)

Swaps associative value at key and returns the new value. Specialized, fast swap-in! for use mostly by memoization utils.

swapped cljs

(swapped new-val return-val)

Swapped cljs

swapped* cljs

(swapped* x)

swapped? cljs

(swapped? x)

takev cljs

(takev n coll)

thread-local-proxy cljs macro

(thread-local-proxy & body)

Thread-safe proxy wrapper, Ref. http://goo.gl/CEBJnQ (instant.clj).

time-ms cljs macro

(time-ms & body)

Returns number of milliseconds it takes to execute body.

time-ns cljs macro

(time-ns & body)

Returns number of nanoseconds it takes to execute body.

tracef cljs

(tracef fmt & xs)

udt? cljs

undefined->nil cljs

(undefined->nil x)

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.

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

(vec* x)

vec2? cljs

(vec2? x)

vec3? cljs

(vec3? x)

vsplit-first cljs

(vsplit-first v)

warnf cljs

(warnf fmt & xs)

when-lets cljs macro

(when-lets bindings & body)

Like when-let but binds multiple values iff all tests are true.

xdistinct cljs

(xdistinct)

(xdistinct keyfn)

(xdistinct keyfn coll)

distinctv` transducer.

zero-num? cljs

(zero-num? x)