com.nomistech.clj-utils — com.nomistech/clj-utils 0.9.0

deep-merge clj

(deep-merge & vals)

Recursively merges maps. nil is treated as an empty map (to match the behaviour of merge). If vals are not maps, the last value wins.

do1 clj macro

(do1 form-1 & other-forms)

Evaluates all the forms and returns the result of the first form.

do2 clj macro

(do2 form-1 form-2 & other-forms)

Evaluates all the forms and returns the result of the second form.

econd clj macro

(econd & clauses)

Like cond, except throws a RuntimeException if no clause matches.

emacs-temp-file-path? clj

(emacs-temp-file-path? path)

emacs-temp-file? clj

(emacs-temp-file? file)

fun-with-extras clj

(fun-with-extras before-f after-f f)

fun-with-return-429-if-too-many-requests clj

(fun-with-return-429-if-too-many-requests options fun)

options is a map with the following keys:

• :limiter-id
• :max-concurrent-requests
• :min-retry-after-secs
• :max-retry-after-secs If we currently do not have too many concurrent executions, call fun. Otherwise return a Ring response map with status 429 and a Retry-After value that is between min-retry-after-secs and max-retry-after-secs. Not having too many concurrent executions is defined like this:
• consider the number of current executions of this function that share the supplied limiter-id
• this number must be less than max-concurrent-requests.

group-by-k clj

(group-by-k f m)

group-by-kv clj

(group-by-kv f m)

group-by-v clj

(group-by-v f m)

indexed clj

(indexed s)

Returns a lazy sequence of [index, item] pairs, where items come from 's' and indexes count up from zero. eg: (indexed '(a b c d)) => ([0 a] [1 b] [2 c] [3 d])

invert-function clj

(invert-function f domain-subset)

invert-relation clj

(invert-relation rel domain-subset)

last-index-of-char-in-string clj

(last-index-of-char-in-string char string)

limiting-n-executions clj

(limiting-n-executions limiter-id max-executions fun fun-when-too-many)

If we currently do not have too many concurrent executions, call fun. Otherwise call fun-when-too-many. Not having too many concurrent executions is defined like this:

• consider the number of current executions of this function that share the supplied limiter-id
• this number must be less than max-executions.

map-keys clj

(map-keys f m)

Apply f to each of the keys of m.

map-keys-recursively clj

(map-keys-recursively f x)

Walk x, applying f to the keys of any maps. Don't call f when the keys are themselves maps.

map-keys-recursively-applying-to-maps clj

(map-keys-recursively-applying-to-maps f x)

Walk x, applying f to the keys of any maps. Call f when the keys are themselves maps.

map-kv clj

(map-kv f m)

Apply f to each of the entries of m. f takes two args, a key and a value.

map-kv-recursively clj

(map-kv-recursively f x)

Walk x, applying f to any map entries.

map-vals clj

(map-vals f m)

Apply f to each of the vals of m.

map-vals-recursively clj

(map-vals-recursively f x)

Walk x, applying f to the vals of any maps. Don't call f when the keys are themselves maps.

map-vals-recursively-applying-to-maps clj

(map-vals-recursively-applying-to-maps f x)

Walk x, applying f to the vals of any maps. Call f when the keys are themselves maps.

member? clj

(member? item coll)

position clj

(position pred coll)

positions clj

(positions pred coll)

Returns a lazy sequence containing the positions at which pred is true for items in coll.

select-keys-recursively clj

(select-keys-recursively m key-paths)

Similar to select-keys, but with key paths digging in to a nested map. key-paths is a sequence. Each element of key-paths begins with a key, k, to be selected and is followed by a vector of key paths that specify the things to be selected from the value corresponding to k. Example: (select-keys-recursively {:k-1 "v-1" :k-2 {:k-2-1 "v-2-1" :k-2-2 {:k-2-2-1 "v-2-2-1" :k-2-2-2 "v-2-2-2" :k-2-2-3 "v-2-2-3"}} :k-3 "v-3"} [[:k-1] [:k-2 [:k-2-2 [:k-2-2-1] [:k-2-2-3]]]]) => {:k-1 "v-1" :k-2 {:k-2-2 {:k-2-2-1 "v-2-2-1" :k-2-2-3 "v-2-2-3"}}}

submap? clj

(submap? m1 m2)

submap?-v2 clj

(submap?-v2 m1 m2)

transitive-closure clj

(transitive-closure f v)

The set of values obtained by starting with v, then applying f to v, then applying f to each of the results, and so on. v and all intermediate values are included in the result.

transitive-closure-excluding-self clj

(transitive-closure-excluding-self f v)

The set of values obtained by applying f to v, then applying f to each of the results, and so on. All intermediate values are included in the result.

unchunk clj

(unchunk s)

Produce a fully-lazy sequence from s. Sometimes Clojure sequences are not fully lazy. See http://blog.fogus.me/2010/01/22/de-chunkifying-sequences-in-clojure/ for details. See also Stuart Sierra comment at https://stackoverflow.com/questions/3407876/how-do-i-avoid-clojures-chunking-behavior-for-lazy-seqs-that-i-want-to-short-ci

with-extras clj macro

(with-extras {:keys [before after]} & body)

with-return-429-if-too-many-requests clj macro

(with-return-429-if-too-many-requests options & body)

Macro wrapper for fun-with-return-429-if-too-many-requests.