missing.core — org.clojars.rutledgepaulv/missing 0.1.35

*preempt* clj

=ic clj

(=ic _)

(=ic s1 s2)

(=ic s1 s2 & ss)

Like = but ignores casing.

ascending-by? clj

(ascending-by? key-fn coll)

(ascending-by? key-fn comparator coll)

Is coll ascending according to the supplied key-fn and comparator?

ascending? clj

(ascending? coll)

(ascending? comparator coll)

Is coll ascending according to the supplied comparator?

assoc* clj

(assoc* m k v)

(assoc* map key val & kvs)

Like assoc, but assumes associng into nil with an integer key means 'I want a vector' and not 'I want a map'

assoc-in* clj

(assoc-in* m [k & ks] v)

Like assoc-in but with assoc* semantics.

attempt clj macro

(attempt)

(attempt x)

(attempt x & next)

Returns result of first form that doesn't throw and doesn't return nil.

backoff clj macro

(backoff max & body)

Runs body up to max times with an exponential backoff strategy.

backoff-seq clj

(backoff-seq)

(backoff-seq max)

Returns an infinite seq of exponential back-off timeouts with random jitter.

base64->bytes clj

(base64->bytes b64)

Converts a base64 encoded string into a byte array.

basename clj

(basename filename)

Get the filename (without extension) from a filename

bfs clj

(bfs pred form)

(bfs pred form default)

Breadth first search through a form for the first form that matches pred.

binary-search clj

(binary-search coll x)

(binary-search compare coll x)

Implements a generic binary search algorithm. Find a value in coll for which (compare value x) is 0, else nil. coll should already be sorted.

bytes->base64 clj

(bytes->base64 bites)

Converts a byte array into a base64 encoded string.

bytes->hex clj

(bytes->hex bites)

Converts a byte array into a hex encoded string.

cascade-by clj

(cascade-by key-fns coll)

Group coll using all prefix lists of key-fns. The result being a map with which you can look up groups to any depth.

clamp clj

(clamp start end x)

Returns x if in range or returns start or end (whichever x is nearest).

Both bounds are inclusive.

collate clj

(collate f+colls)

Given a map or sequence of [key-fn coll] pairs, create a lookup table from disparate data sets. Define how to compute the primary key from each set and it'll give you back a map of primary key to vector of 'columns'.

concatv clj

(concatv & xs)

Returns the concatenation as a vector.

contains-all? clj

(contains-all? coll [k & more :as keys])

Does coll contain every key?

contiguous-by clj

(contiguous-by f-start f-stop)

(contiguous-by f-start f-stop coll)

Transducer that partitions collections into contiguous segments according to the comparables returned by f-start and f-stop.

dedupe-by clj

(dedupe-by f)

(dedupe-by f coll)

Like dedupe but according to a key-fn instead of the element itself.

deep-merge clj

(deep-merge & maps)

Merges nested maps.

default clj macro

(default f default)

Wrap f to return a default value if f returns nil.

defmemo clj macro

(defmemo & defnargs)

Define a function with a memoized implementation.

defmethodset clj macro

(defmethodset symbol dispatch-keys & body)

Like defmethod but allows for specifying implementations of multiple dispatch keys at once.

defmulti* clj macro

(defmulti* symbol dispatch-fn)

Like clojure.core/defmulti, but actually updates the dispatch value when you reload it.

defonce-protocol clj macro

(defonce-protocol sym & body)

Like defprotocol but won't reload the protocol when you reload the ns.

defpatch clj macro

(defpatch symbol bindings & body)

An anaphoric macro for patching existing functions. Original function is bound to the symbol 'this'. Safe to execute multiple times, 'this' will always refer to the original implementation and never the previously patched implementation.

defpatchmethod clj macro

(defpatchmethod multifn dispatch-val bindings & body)

An anaphoric macro for patching existing multimethods. Original method is bound to the symbol 'this'. Safe to execute multiple times, 'this' will always refer to the original implementation and never the previously patched implementation.

defweakmemo clj macro

(defweakmemo & defnargs)

Define a function with a weakly memoized implementation.

descending-by? clj

(descending-by? key-fn coll)

(descending-by? key-fn comparator coll)

Is coll descending according to the supplied key-fn and comparator?

descending? clj

(descending? coll)

(descending? comparator coll)

Is coll descending according to the supplied comparator?

dfs clj

(dfs pred form)

(dfs pred form default)

Depth first search through a form for the first form that matches pred.

diff-by clj

(diff-by key-fn a b)

Like clojure.data/diff when used on sets except keyed by key-fn instead of the elements themselves.

dissoc-in clj

(dissoc-in m [k & ks])

Dissociate a key/value from a map at a given path.

distinct-by clj

(distinct-by f)

(distinct-by f coll)

Like distinct but according to a key-fn instead of the element itself.

distinct-by? clj

(distinct-by? f coll)

Like distinct? but according to a key-fn instead of the element itself.

doforce clj macro

(doforce)

(doforce x)

(doforce x & next)

Execute each top-level form of the body even if they throw, and return nil if there was an error.

drop* clj

(drop* n coll)

An alternative implementation of clojure.core/drop that provides a more efficient implementation for certain types of coll.

drop-until clj

(drop-until pred)

(drop-until pred coll)

Like clojure.core/drop-while, except inverted pred.

drop-upto clj

(drop-upto pred)

(drop-upto pred coll)

Returns a lazy sequence of the items in coll starting after the first item for which (pred item) returns true.

duration-explain clj

(duration-explain duration)

Converts millis or a java.time.Duration into a human readable description.

duration-parts clj

(duration-parts duration)

Given millis or a java.time.Duration return a map of time unit to amount of time in that unit. Bucket the duration into larger time units before smaller time units.

exclusive? clj

(exclusive? s1 s2 & ss)

Returns true if the provided collections are mutually exclusive.

extrema clj

(extrema coll)

Returns a tuple of [smallest largest] element in the collection.

extrema-by clj

(extrema-by f coll)

Returns a tuple of [smallest largest] in coll according to some fn of an element.

filter-entries clj

(filter-entries pred m)

filter-groups clj

(filter-groups f m)

Filter items in groups for the groups in a map of category to group.

filter-keys clj

(filter-keys pred m)

Filter a map by a predicate on its keys

filter-nth clj

(filter-nth n pred coll)

Filters a seq based on a function of the nth position.

filter-vals clj

(filter-vals pred m)

Filter a map by a predicate on its values

filter1 clj

(filter1 pred coll)

Filters a seq of tuples on a predicate of the first elements.

filter2 clj

(filter2 pred coll)

Filters a seq of tuples on a predicate of the second elements.

firsts-by clj

(firsts-by key-fn coll)

Filter a sequence to only the first elements of each partition determined by key-fn.

fixed-point clj

(fixed-point f x)

(fixed-point max f x)

Finds the fixed point of f given initial input x. Optionally provide a max number of iterations to attempt before returning nil, else runs indefinitely if no fixed point is found.

flatten1 clj

(flatten1 coll)

Flattens one level of nested collections.

flip clj

(flip f)

Returns a new function that applies the provided arguments in reverse order.

get* clj

(get* m k)

(get* m k not-found)

Like clojure.core/get except treats strings and keywords as interchangeable and not-found as the result if there is no found value or if the found value is nil.

get-extension clj

(get-extension filename)

Get the file extension from a filename.

get-field clj

(get-field obj field)

Access an object field, even if private or protected.

get-filename clj deprecated

(get-filename filename)

Get the filename (without extension) from a filename

get-in* clj

(get-in* m ks)

(get-in* m ks not-found)

Like clojure.core/get-in except built atop get*.

get-jar-version clj

(get-jar-version dep)

Returns the version of a jar. Dep should be the same symbol that appears in leiningen/deps dependencies.

glob-matcher clj

(glob-matcher glob)

(glob-matcher dir glob)

Returns a predicate that will match a file against a glob pattern.

glob-seq clj

(glob-seq dir & globs)

Returns a sequence of files and directories nested within dir that match one of the provided glob patterns.

greatest clj

(greatest coll)

Returns the largest element in the collection.

greatest-by clj

(greatest-by f coll)

Returns the largest element according to some fn of the element

group-by-labels clj

(group-by-labels f coll)

Groups elements in coll according to all of the submaps of the map returned by f.

groupcat-by clj

(groupcat-by f coll)

Like group-by except f is expected to return a sequence of keys that the element should be bucketed by.

grouping->pairs clj

(grouping->pairs m)

Turn a map of groupings into a flat sequence of pairs of key and single value.

gt clj

(gt)

(gt _)

(gt a b)

(gt a b & more)

Like > but for comparables.

gte clj

(gte)

(gte _)

(gte a b)

(gte a b & more)

Like >= but for comparables.

hex->bytes clj

(hex->bytes hex)

Converts a hex encoded string into a byte array.

if-let* clj macro

(if-let* bindings then)

(if-let* bindings then else)

Like clojure.core/if-let except supports multiple bindings.

if-seq clj macro

(if-seq bindings then)

(if-seq bindings then else)

Like if-some* but takes the else branch if seq is empty.

if-some* clj macro

(if-some* bindings then)

(if-some* bindings then else)

Like clojure.core/if-some except supports multiple bindings.

if-text clj macro

(if-text bindings then)

(if-text bindings then else)

Like if-some* but takes the else branch if text is blank.

index-by clj

(index-by key-fn coll)

Index the items of a collection into a map by a key

index-values-by-paths clj

(index-values-by-paths form)

Returns a map of path => value at path for any data structure

indexcat-by clj

(indexcat-by f coll)

Like index-by except f is expected to return a sequence of keys that the element should be indexed by.

indexed clj

(indexed coll)

Creates a [index item] seq of tuples.

indexes-by clj

(indexes-by key-fns coll)

Index coll by multiple keys to create a nested lookup path.

intersect? clj

(intersect? s1 s2 & ss)

Returns true if the provided collections overlap.

iterable? clj

(iterable? x)

Is collection like or a single value?

jaccard-coefficient clj

(jaccard-coefficient s1 s2)

Returns a ratio between 0 and 1 representing the degree of overlap between sets.

join-paths clj

(join-paths & paths)

Join paths together. Accepts string arguments or collections (which will be flattened). '/' delimiters already at the beginning or end of a segment will be removed leaving only a single '/' between each segment.

keep-entries clj

(keep-entries f m)

Map and only keep entries with non-nil keys and values.

keep-keys clj

(keep-keys f m)

Map and only keep non-nil keys.

keep-vals clj

(keep-vals f m)

Map and only keep non-nil values.

keepcat clj

(keepcat f)

(keepcat f & colls)

A transducer like mapcat except removes nil elements.

key= clj

(key= & more)

Equality after conversion to keywords. Use when you're unsure if the arguments are strings or keywords

keyed clj macro

(keyed & keys)

Creates a map of keyword => value from symbol names and the values they refer to.

keyset clj

(keyset m)

Returns the keys of a map as a set.

last* clj

(last* coll)

lasts-by clj

(lasts-by key-fn coll)

Filter a sequence to only the last elements of each partition determined by key-fn.

least clj

(least coll)

Returns the smallest element in the collection.

least-by clj

(least-by f coll)

Returns the smallest element according to some fn of the element

left-pad clj

(left-pad s length pad)

Pad a string on the left until it satisfies a desired width.

letd clj macro

(letd bindings & body)

Like clojure.core/let except delays and forces each binding value. Use this when you don't want to evaluate potentially expensive bindings until you refer to their value in the body of the code. Supports nesting, dependencies between bindings, shadowing, destructuring, and closures.

letp clj macro

(letp bindings & body)

Like clojure.core/let but allows early returns via (preempt return-value)

lift-by clj

(lift-by lift f)

Returns a function that first applies the lift to each argument before applying the original function.

llast clj

(llast coll)

The complement to clojure.core/ffirst.

load-edn-resource clj

(load-edn-resource path)

Load and parse an edn file from the filesystem if given an absolute path or the classpath otherwise. See read-edn-string for notes on tagged literals.

locate-file clj

(locate-file path)

Given a path attempts to find the best matching file. file: prefix to mandate file system path classpath: prefix to mandate classpath leading slash presumes file system otherwise, check classpath first, then filesystem

lstrip clj

(lstrip s strip)

Strip a prefix from a string.

lt clj

(lt)

(lt _)

(lt a b)

(lt a b & more)

Like < but for comparables.

lte clj

(lte)

(lte _)

(lte a b)

(lte a b & more)

Like <= but for comparables.

map-entries clj

(map-entries f m)

Transform the entries of a map

map-entry clj

(map-entry k v)

Creates a map entry from key k and value v.

map-groups clj

(map-groups f m)

Map items in groups for the groups in a map of category to group.

map-keys clj

(map-keys f m)

Transform the keys of a map

map-nth clj

(map-nth n f coll)

Updates the nth position of each element in a seq of tuples.

map-vals clj

(map-vals f m)

Transform the values of a map

map1 clj

(map1 f coll)

Updates the first position of each element in a seq of tuples.

map2 clj

(map2 f coll)

Updates the second position of each element in a seq of tuples.

mapcat-groups clj

(mapcat-groups f m)

Mapcat items in groups for the groups in a map of category to group.

md5-checksum clj

(md5-checksum bites)

Hashes a byte array and returns the md5 checksum (hex encoded)

merge-sort clj

(merge-sort colls)

(merge-sort comparator colls)

Lazily produces a sorted sequence from many sorted input sequences according to comp.

merge-sort-by clj

(merge-sort-by key-fn colls)

(merge-sort-by key-fn comparator colls)

Lazily produces a sorted sequence from many sorted input sequences according to key-fn and comp.

n? clj

(n? n pred coll)

Are there exactly n things in coll that satisfy pred?

nor clj macro

(nor & more)

Expands to (and (not form1) (not form2) ...)

not-blank? clj

(not-blank? s)

not-empty? clj

(not-empty? coll)

once clj macro

(once & body)

Runs a piece of code that evaluates only once (per ns) until the source changes.

one? clj

(one? pred coll)

Is there exactly one thing in coll that satisfies pred?

only clj

(only coll)

Returns the only item from a collection if the collection only consists of one item, else nil.

paging clj

(paging f)

(paging limit f)

(paging offset limit f)

A function that returns a lazily generating sequence backed by a paged source. Takes a function that receives an offset and limit and returns the page for those parameters.

:f A function of two arguments (offset and limit) that fetches some kind of results.

:limit A number representing how many objects to fetch per page. Defaults to 512.

:offset A number representing what index to start getting results from. Defaults to 0.

parse-best-guess clj

(parse-best-guess s)

parse-boolean clj

(parse-boolean s)

parse-number clj

(parse-number s)

partition-all* clj

(partition-all* n coll)

An alternative implementation of clojure.core/partition-all that provides a more efficient implementation for certain types of coll.

partition-with clj

(partition-with pred)

(partition-with pred coll)

Returns a lazy sequence of partitions where a new partition is created every time pred returns true. Returns a transducer when only provided pred.

paths clj

(paths form)

Returns all the paths into a data structure. Paths are compatible with (get-in form path).

piecewise clj

(piecewise f & colls)

Applies f to respective elements across each provided collection. f should be an associative function of two arguments.

pivot-grouping clj

(pivot-grouping m)

Take a map of categories to items and turn it into a map of items to categories.

pmapcat clj

(pmapcat f coll)

(pmapcat f coll & colls)

Like pmap, but for mapcatting.

pp clj

(pp x)

Prints the argument and returns it.

preempt clj

(preempt result)

To be used inside of a preemptable. Call preempt within a preemptable to deliver a return value for the entire preemptable and abort further computation by interrupting the thread.

preemptable clj macro

(preemptable & body)

Mark a point in the stack that can be the target of a preemption. Calling preempt within a preemptable will result in the value of the preemptable being the value passed to preempt if called, otherwise the value of the preemptable will be the result of the complete evaluation of the interior.

prefixes clj

(prefixes coll)

Returns all prefixes of coll.

qualify-ident clj

(qualify-ident prefix k)

Adds a namespace prefix to a given key.

qualify-keys clj

(qualify-keys prefix form)

Adds a namespace prefix to all map keys throughout form.

qualify-top-keys clj

(qualify-top-keys prefix m)

Adds a namespace prefix to all top level keys in m.

quietly clj macro

(quietly & body)

Execute the body and return nil if there was an error

range-search clj

(range-search coll x)

From an ordered set of ranges, find the range which contains x, else nil.

range? clj

(range? coll)

read-edn-string clj

(read-edn-string s)

Reads a string of edn and returns the parsed data. Applies all loaded data readers and falls back to blindly forwarding tagged literals when no applicable reader exists. Be careful to only call this when you either trust the input or know that you have no data readers loaded that can invoke dangerous code for arbitrary input.

reduce-groups clj

(reduce-groups f m)

(reduce-groups f val m)

Reduce items in groups for the groups in a map of category to group.

remove-groups clj

(remove-groups f m)

Remove items from groups in a map of category to group.

remove-keys clj

(remove-keys pred m)

Filter a map by the complement of predicate on its keys

remove-vals clj

(remove-vals pred m)

Filter a map by the complement of predicate on its values

reset-var! clj

(reset-var! v value)

Sets the root value of a var.

returning clj macro

(returning value & body)

A macro that computes value, executes body, then returns value.

reverse* clj

(reverse* coll)

An alternative implementation of clojure.core/reverse that provides a more efficient implementation for certain types of coll.

reverse-grouping clj

(reverse-grouping m)

Take a map of categories to items and turn it into a map of item to category.

reverse-map clj

(reverse-map m)

Invert a map

right-pad clj

(right-pad s length pad)

Pads a string on the right until it satisfies a desired width.

rstrip clj

(rstrip s strip)

Strip a suffix from a string.

run-par! clj

(run-par! f coll)

Like run! but executes each element concurrently.

seek clj

(seek pred coll)

(seek pred coll not-found)

Find the first element in the collection that matches pred, else returns not-found. Note that using seek can lead to poor performance and you should always use indexed data structures instead of multiple seeks over the same data.

seek-indexed clj

(seek-indexed pred coll)

Returns [index item] for the first item that matches pred.

single? clj

(single? x)

Is this a collection of a single value?

sliding-iterate clj

(sliding-iterate f init)

Iterate, but each new term is a function of the last N terms.

f should be a function of N arguments that computes the next term. init should be a sequence of length N containing the first N terms.

sorted-map-by-value clj

(sorted-map-by-value m)

(sorted-map-by-value m comparator)

Returns a sorted map with entries sorted by values. Supply your own comparator if you want to reverse order or customize the sort.

split-at* clj

(split-at* index coll)

An alternative implementation of clojure.core/split-at that provides a more efficient implementation for certain types of coll.

stringed clj macro

(stringed & keys)

Creates a map of string => value from symbol names and the values they refer to.

stringify-ident clj

(stringify-ident ident)

Converts a keyword / symbol into a full string representation (including namespaces if qualified).

stringify-key clj

(stringify-key k)

Convert a keyword to a string, preserve namespaces.

stringify-keys clj

(stringify-keys form)

Converts all map keys into strings throughout form.

submap? clj

(submap? m1 m2)

Is m1 a submap of m2?

submaps clj

(submaps m)

Returns all the submaps of a map

subsets clj

(subsets coll)

Returns all the subsets of a collection

subvec* clj

(subvec* vec start)

(subvec* vec start end)

Like clojure.core/subvec but clamped.

supermap? clj

(supermap? m1 m2)

Is m1 a supermap of m2?

symmetric-difference clj

(symmetric-difference s1 s2)

Returns the union of the exclusive portions of s1 and s2.

take* clj

(take* n coll)

An alternative implementation of clojure.core/take that provides a more efficient implementation for certain types of coll.

take-until clj

(take-until pred)

(take-until pred coll)

Like clojure.core/take-while, except inverted pred.

take-upto clj

(take-upto pred)

(take-upto pred coll)

Returns a lazy sequence of successive items from coll up to and including the first item for which (pred item) returns true.

tap clj

(tap f)

(tap f coll)

A transducer that applies side-effects to each element.

template clj

(template text context)

A simple string templating function that replaces {x.y.z} placeholders with values from the context.

timing clj macro

(timing & body)

Returns a vector of [millis-taken result]

together clj macro

(together & expressions)

Executes each top level form in body concurrently and returns a sequence of the results.

touch clj

(touch x)

Realizes all delays within a structure.

touch-realized clj

(touch-realized x)

Unwraps all realized delays within a structure.

tree-seq-bf clj

(tree-seq-bf branch? children root)

Like clojure.core/tree-seq, but breadth first.

trie clj

(trie coll)

Returns a trie structure as a map. coll must be a collection of sequentials.

trie-by clj

(trie-by f coll)

Returns a trie structure as a map. f is a function of an element in coll that returns an ordered sequence by which the element will be positioned in the trie.

try-root clj macro

(try-root & body)

Used just like the special form try, except pulls out the root cause and catches on that instead of whatever exception might wrap it. Useful for catching exceptions surrounding futures and the like.

tuxt clj

(tuxt & fns)

Returns a new function that applies each fn against respective positions in a tuple.

update! clj

(update! m k f)

(update! m k f x)

(update! m k f x y)

(update! m k f x y z)

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

Like clojure.core/update but for transients.

uuid clj

(uuid)

Get a uuid as string

walk-keys clj

(walk-keys f form)

Applies f to all keys in all maps within form.

walk-seq clj

(walk-seq form)

Returns a lazy depth-first sequence of all forms within a data structure.

walk-seq-bf clj

(walk-seq-bf form)

Returns a lazy breadth-first sequence of all forms within a data structure.

walk-vals clj

(walk-vals f form)

Applies f to all vals in all maps within form.

weakly-memoize clj

(weakly-memoize f)

(weakly-memoize f cache-key-fn)

Returns a memoized version of f with weak retention of return values. As long as a strong reference to the return value remains, further invocations with the same cache key will return the cached value. However, once no strong references to the value are retained the value will become a candidate for garbage collection and a future invocation with the same arguments will necessarily recompute f.

The cache key defaults to the arguments provided but a custom cache-key-fn may be supplied instead. A cache-key-fn is a function that will be invoked with the sequence of arguments and should return the desired cache key.

when-let* clj macro

(when-let* bindings & body)

Like clojure.core/when-let except supports multiple bindings.

when-seq clj macro

(when-seq bindings & body)

Like if-seq but there's only one branch with an implicit do

when-some* clj macro

(when-some* bindings & body)

Like clojure.core/when-some except supports multiple bindings.

when-text clj macro

(when-text bindings & body)

Like if-text but there's only one branch with an implicit do

with-temp-files clj macro

(with-temp-files symbols & body)

Binds temporary files to each symbol in the symbols vector and then executes body using those bindings. All bound temporary files are deleted before returning with the return value of body.

with-timeout clj macro

(with-timeout millis & body)

Run body on a separate thread subject to a timeout. If reaches timeout a vector of [false nil] will be returned, otherwise [true result]

zip clj

(zip & colls)

Create tuples from sequences.

|intersection| clj

(|intersection| s)

(|intersection| s1 s2)

Computes the cardinality of the intersection.

|union| clj

(|union| s)

(|union| s1 s2)

Computes the cardinality of the union.