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

cl-exception clj/s

(cl-exception cl-format-string & format-args)

deep-merge clj/s

(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/s macro

(do1 form-1 & other-forms)

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

do2 clj/s macro

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

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

dotdot clj/s macro

(dotdot x)

(dotdot x & forms)

Like .. but allows only a single arg, so (dotdot foo) expands to foo.

drop-nth clj/s

(drop-nth n coll)

Return a lazy sequence of all items in coll apart from the n'th item.

dups clj/s

(dups coll)

Return the items that are duplicated in coll, in the order that the first duplicates appear.

econd clj/s macro

(econd & clauses)

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

edit-nth clj/s

(edit-nth n coll f)

Return a lazy sequence of all items in coll, with the n'th item replaced with the value of applying f to it.

emacs-temp-file-path? clj

(emacs-temp-file-path? path)

emacs-temp-file? clj

(emacs-temp-file? file)

Exception-or-js-Error clj/s

fun-with-extras clj/s

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

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

(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/s

(group-by-k f m)

group-by-kv clj/s

(group-by-kv f m)

group-by-v clj/s

(group-by-v f m)

indexed clj/s

(indexed coll)

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

invert-function clj/s

(invert-function f domain-subset)

invert-relation clj/s

(invert-relation rel domain-subset)

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

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

limiting-n-executions clj/s

(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/s

(map-keys f m)

Apply f to each of the keys of m.

map-keys-recursively clj/s

(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/s

(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/s

(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/s

(map-kv-recursively f x)

Walk x, applying f to any map entries.

map-vals clj/s

(map-vals f m)

Apply f to each of the vals of m.

map-vals-recursively clj/s

(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/s

(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/s

(member? item coll)

my-error clj/s deprecated

(my-error cl-format-string & format-args)

only-once clj/s

(only-once f)

f is a function of no args. Return a function that on its first invocation calls f, and on subsequent invocations does nothing and returns ::already-run. Unlike memoize, the function is called only once even if invoked from multiple threads at the same time.

position clj/s

(position pred coll)

Return the index of the first item in 'coll' that satisfies 'pred', or nil if there is no such item.

positions clj/s

(positions pred coll)

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

select-keys-recursively clj/s

(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/s

(submap? m1 m2)

submap?-v2 clj/s

(submap?-v2 m1 m2)

transitive-closure clj/s

(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/s

(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/s

(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/s macro

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

Does before, then body, then after. Returns the result of body. Within after, the result of body is available as _result_. In the event of a non-local exit, the value of _result_ is ::non-local-exit.

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

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

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