io.jesi.backpack — io.jesi/backpack 7.5.0

->camelCase clj/s≠

clj

(->camelCase s)

cljs

->camelCase-key clj/s

->comparator clj/s≠

clj

(->comparator val-fn)

cljs

Returns a comparator where values returning from a value function are compared against

->kebab-case clj/s≠

clj

(->kebab-case s)

cljs

->kebab-case-key clj/s

->proper-case clj/s≠

clj

(->proper-case s)

cljs

->snake_case clj/s≠

clj

(->snake_case s)

cljs

->snake_case-key clj/s

->uri clj/s≠

clj

(->uri s)

cljs

->uuid clj/s multimethod

Coerces a value into a UUID if possible, otherwise returns nil

->uuid-or-not clj/s≠

clj

(->uuid-or-not id)

cljs

add-shutdown-hook clj macro

(add-shutdown-hook & body)

Adds a shutdown hook using java.lang.Runtime.addShutdownHook. Returns the created Thread

add-shutdown-hook-fn clj

(add-shutdown-hook-fn f)

Adds a shutdown hook using java.lang.Runtime.addShutdownHook. Takes a function f, and returns the created Thread

and-fn clj/s≠

clj

(and-fn pred & more)

cljs

Higher order and. Takes any number of predicates and returns a function that takes a value and returns true if ALL individual predicates return true, else return false.

any? clj/s≠

clj

(any? pred coll)

cljs

Returns true if any item in coll returns true for pred, otherwise false

apply-when clj/s≠

clj

(apply-when f v)

cljs

Invokes f when it's truthy

assoc-in clj/s≠

clj

(assoc-in m & kvs)

cljs

assoc-some! clj/s≠

clj

(assoc-some! tmap k v)

cljs

Assocs some value into a transitive map

blank? clj/s

Similar to clojure.string/blank? but returns false if given a non-string

call clj/s≠

clj

(call f v)

cljs

Calls the function f with a value v

class->clj cljs

clj->js cljs

Transforms ClojureScript to JavaScript. Converting keys to camelCase by default

close clj/s multimethod

collify clj/s≠

clj

(collify)

(collify v)

cljs

Puts value v in a vector if it is not a collection. Returns nil if no value

compr clj/s≠

clj

(compr)

(compr f)

(compr f g)

(compr f g & more)

cljs

Composes functions left to right, the opposite of comp

concat! clj/s≠

clj

(concat!)

(concat! tcoll)

(concat! tcoll seq)

(concat! tcoll seq & more)

cljs

Adds the values to the transient collection, returning tcoll. Concatenates of the elements in the supplied sequences

conj! clj/s≠

clj

(conj!)

(conj! tcoll)

(conj! tcoll val)

(conj! tcoll val & more)

cljs

Adds val to the transient collection, and return tcoll. The 'addition' may happen at different 'places' depending on the concrete type.

conj-some! clj/s≠

clj

(conj-some! tcoll v)

cljs

Adds a value to the transitive collection if some

contains-any? clj/s≠

clj

(contains-any? map & keys)

cljs

d# clj/s≠

clj

(d# a)

cljs

Derefs a value if it is derefable

default-changed-merger clj/s

default-comparator clj/s

defkw-type clj

(defkw-type type kw & args)

diff clj/s≠

clj

(diff existing updated)

(diff leaf-pred existing updated)

(diff leaf-pred comparator existing updated)

(diff leaf-pred comparator changed-merger existing updated)

cljs

Returns a map of paths which have changed :added, :changed, :removed, and :same

dissoc-all clj/s≠

clj

(dissoc-all map & keys)

cljs

dissoc-in clj/s≠

clj

(dissoc-in m path & paths)

cljs

Dissociates paths from a map. Any empty maps produced will be removed

distinct-by clj/s≠

clj

(distinct-by key entities)

cljs

distinct-vals? clj/s≠

clj

(distinct-vals? m)

cljs

Returns true if all the map values are unique

empty->nil clj/s≠

clj

(empty->nil x)

cljs

Returns nil if argument returns true for (clojure.core/empty?)

exception? clj/s≠

clj

(exception? x)

cljs

Returns true if x is a Clojure Throwable or ClojureScript js/Error

filter-by clj/s≠

clj

(filter-by key-fn pred coll)

cljs

Filters a collection where a key matches a predicate e.g. (let [coll [{:id 1} {:id 2}] (filter-by :id (bp/p= 1) coll)) ; returns `({:id 1})

filter-empty clj/s

filter-key= clj/s≠

clj

(filter-key= key-fn value coll)

cljs

Filters a collection where a key matches a value e.g. (let [coll [{:id 1} {:id 2}] (filter-key= :id 1 coll)) ; returns `({:id 1})

filter-nil-keys clj/s≠

clj

(filter-nil-keys map)

cljs

Filters out all nil key values from a map

filter-values clj/s≠

clj

(filter-values pred map)

cljs

first-some clj/s≠

clj

(first-some m & ks)

cljs

if-fn clj/s≠

clj

(if-fn pred then)

(if-fn pred then else)

cljs

Higher-order if function. Takes a predicate (pred), calling then or (optionally) else based on the predicate. Returns nil if no else defined.

in? clj/s≠

clj

(in? col el)

cljs

infinity clj/s

Java's Integer/MAX_VALUE for consistence use in Clojure(Script) projects

java->clj clj

(java->clj j)

(java->clj j key-fn)

Transforms Java to Clojure. Converting keys to kebab-case keywords by default

js->clj cljs

Transforms JavaScript to ClojureScript. Converting keys to kebab-case keywords by default

kebab->proper-case clj/s≠

clj

(kebab->proper-case s)

cljs

kebab-case->Proper-Kebab-Case clj/s≠

clj

(kebab-case->Proper-Kebab-Case kebab-case-str)

cljs

macro? clj

(macro? sym)

True if the provided sym is a macro

map-if clj/s≠

clj

(map-if pred f col)

cljs

map-key-walker clj/s

map-leaves clj/s≠

clj

(map-leaves f coll)

(map-leaves f leaf-pred coll)

cljs

Traverses and applies the mapping function to each leaf of a data structure. The mapping function is given the path and value at that path

map-walker clj/s

mod clj/s≠

clj

(mod num div)

cljs

Modulus of num and div supporting float and decimal values. Truncates toward negative infinity.

named? clj/s≠

clj

(named? x)

cljs

Returns true if x is named (can be passed to name)

namespaced? clj/s≠

clj

(namespaced? named)

cljs

Returns true if the named has a namespace

noop clj/s

not-blank? clj/s

or-fn clj/s≠

clj

(or-fn pred & more)

cljs

Higher order or. Takes any number of predicates and returns a function that takes a value and returns true if ANY individual predicates return true, else return false.

p= clj/s≠

clj

(p= & x)

cljs

Partial =

partial-right clj/s≠

clj

(partial-right f & args)

cljs

pass clj/s≠

clj

(pass f)

cljs

pass-if clj/s≠

clj

(pass-if pred f)

cljs

path-walker clj/s

A spectre recursive path navigator, that collects all paths to the occurrences of leaves that match the given predicate. Does not traverse deeper into the matched structures.

pprint-str clj

(pprint-str object)

pprint-str-code clj

(pprint-str-code object)

prefix clj/s

re-quote clj/s≠

clj

(re-quote s)

cljs

Quotes the regex string

redact clj/s≠

clj

(redact keys m)

(redact keys m redacted-value)

cljs

Deeply replaces value of all the keys in m with the redacted-value

reduce-leaves clj/s≠

clj

(reduce-leaves f coll)

(reduce-leaves f init coll)

(reduce-leaves f init leaf-pred coll)

cljs

Traverses and reduces a data structure where the reducing function is given an accumulator, vector path and value at that path

remove-empty clj/s≠

clj

(remove-empty x)

cljs

remove-nil-vals clj/s≠

clj

(remove-nil-vals map)

cljs

Shallowly removes nil values from a map

remove-prefix clj/s≠

clj

(remove-prefix prefix s)

(remove-prefix prefix separator s)

cljs

Removes the prefix if the string starts with it otherwise ignores, is case sensitive

rename-keys! clj/s≠

clj

(rename-keys! tmap kmap)

cljs

Returns the transient map with the keys in kmap renamed to the vals in kmap

round-to clj/s≠

clj

(round-to precision d)

cljs

Rounds a given value 'd' to the specified 'precision'

safe-empty? clj/s≠

clj

(safe-empty? x)

cljs

select-non-nil-keys clj/s≠

clj

(select-non-nil-keys m keys)

cljs

select-vals clj/s≠

clj

(select-vals m ks)

cljs

Selects all values from a map using specified keys. Missing keys return nil

sorted-map-by-index clj/s≠

clj

(sorted-map-by-index idx & keyvals)

cljs

sorted-map-by-order clj/s≠

clj

(sorted-map-by-order ks & keyvals)

cljs

sorted? clj/s≠

clj

(sorted? coll)

(sorted? comp coll)

cljs

True if a collection is sorted by means of a 2 or 3 way comparator

split-at-first clj/s≠

clj

(split-at-first value s)

cljs

Splits s at the first occurrence of value, returns nil when s is empty

subs clj/s≠

clj

(subs s start)

(subs s start end)

cljs

subs-inc clj/s≠

clj

(subs-inc match s)

cljs

Returns the substring of 's' up to and including the 'match' or nil

subs-to clj/s≠

clj

(subs-to match s)

cljs

Returns the substring of 's' up until the 'match'

suffix clj/s

throw-if-throwable clj/s≠

clj

(throw-if-throwable ex)

cljs

Throw ex if it's an exception. Retains the message, data, and cause

trans-reduce clj/s≠

clj

(trans-reduce f [c & coll])

(trans-reduce f init coll)

cljs

trans-reduce-kv clj/s≠

clj

(trans-reduce-kv f init coll)

cljs

transform-keys clj/s≠

clj

(transform-keys f coll)

cljs

Recursively transforms all map keys in coll with f

translate-keys clj/s≠

clj

(translate-keys kmap map)

cljs

Updates map with the keys from kmap

true-string? clj/s≠

clj

(true-string? s)

cljs

True if 's' is the string literal 'true'

update! clj/s≠

clj

(update! tcoll k f)

(update! tcoll k f x)

(update! tcoll k f x y)

(update! tcoll k f x y z)

(update! tcoll k f x y z & more)

cljs

'Updates' a value in an transient associative structure, where k is a key and f is a function that will take the old value and any supplied args and return the new value, and returns a new structure. If the key does not exist, nil is passed as the old value.

update-some clj/s≠

clj

(update-some m k f & args)

cljs

Updates a key in a map with a function, only if the key is present and the result of f is not nil.

update-some! clj/s≠

clj

(update-some! tmap k f)

cljs

Replaces the value of a key in a transitive map if the result of the function is some

uuid-str? clj/s≠

clj

(uuid-str? s)

cljs

True if 's' is a string and matches the UUID format

xor clj/s≠

clj

(xor)

(xor x)

(xor x y)

(xor x y & more)

cljs

Returns true only if one argument is true