fooheads.stdlib — com.fooheads/stdlib 0.4.1

apply-if clj/s

(apply-if pred f & args)

Returns a function that applies f if pred returns true for the specified value.

Usually used in combination with clojure.walk/postwalk, e.g.

(postwalk (apply-if keyword? str) coll)

binding-map clj/s

(binding-map symbols)

cljs-env? clj/s

(cljs-env? env)

Take the &env from a macro, and tell whether we are expanding into cljs.

conj-some clj/s

(conj-some coll x)

Like conj but does not add x if x is nil.

conjt clj/s

(conjt coll x)

Like conj, keeps the collection type and throws error for seq? collections, since it would be very slow (and in the "wrong" order). If coll is nil, defaults to vector (instead of list as conj does).

conjt-some clj/s

(conjt-some coll x)

Like conjt but does not add x if x is nil.

cons-some clj/s

(cons-some x coll)

Like cons but does not add x if x is nil.

const clj/s

(const x coll)

Like cons but keeps the collection type.

const-some clj/s

(const-some x coll)

Like const but does not add x if x is nil.

dissoc-vals clj/s

(dissoc-vals m pred)

Dissoc elements from m for which value matches pred

dprn clj/s macro

(dprn msg-template & symbols)

Renders the template using the scoped vars, println's the msg and pprint's the arg-map

empty clj/s

(empty coll)

Like clojure.core/empty with support for map-entry.

empty-vec clj/s

(empty-vec & _args)

Create an empty vector

exactly= clj/s

(exactly= x y)

Checks that = is true and that both x and y are of the same type.

exceptional clj/s

(exceptional f success? get)

Returns a function that applies f and uses the specified get function to retrieve the value if success? returns true for the function application.

Throws an exception if success? returns something falsy.

filter-indexes clj/s

(filter-indexes indexes xs)

Selects the items at the indexes.

Example: (select-indexes [0 2] [:a :b :c :d]) ; => [:a :c]

filtert clj/s

(filtert pred coll)

Like filter but keeps the collection type.

guard clj/s macro

(guard pred v msg)

(guard pred v msg data-map)

A guard that throws an exception (with msg) if v does not meet pred.

index-of clj/s

(index-of pred coll)

Returns the index of the first element matching pred in coll

index-of-all clj/s

(index-of-all pred coll)

Returns the indexes of all elements matching pred in coll

into clj/s

(into)

(into to)

(into to from)

Like clojure.core/into, but keeps the original order for lists. Does not support transducers.

map-keys clj/s

(map-keys f m)

Apply f to all keys in m

map-vals clj/s

(map-vals f m)

Apply f to all values in m

mapt clj/s

(mapt f coll)

(mapt f c1 c2)

(mapt f c1 c2 c3)

(mapt f c1 c2 c3 & colls)

Like map but keeps the collection type. For maps, it assumes that f returns a pair/map-entry, in order to successfully turn the values into a map again. When multiple collections are provided, the type of the first collection determines the return type.

named? clj/s

(named? x)

Returns true if clojure.core/name can be called on x.

partition-indexes clj/s

(partition-indexes indexes xs)

Partitions the seq into the number of specified index partitions. If the index is not specified, it will be put in the last partition.

Example: (partition-indexes [[0 3] [1]] [:a :b :c :d :e]) ;=> [[:a :d] [:b] [:c :e]]

partition-using clj/s

(partition-using pred coll)

Collects values to a partition until the pred is true for the partition, and then starts a new partition. If pred never is true, all values ends up in a single partition. Returns a lazy seq of partitions.

When I grow up, I want to return a (stateful) transducer when only pred is provided.

qualified-name clj/s

(qualified-name ident)

Returns a string with the qualified name of the ident

qualify-ident clj/s

(qualify-ident nspace nameable)

Qualifies an ident. nspace and nameable must of same type. The nspace must be a simple-ident? and nameable can be either simple-ident? or qualified-ident?.

If nameable is already qualified, it will change namespace.

qualify-keys clj/s

(qualify-keys m nspace)

Qualify all the keys in a map

re->str clj/s

regex? clj/s

(regex? x)

Test whether x is a regular expression

remove-indexes clj/s

(remove-indexes indexes xs)

Removes the items at the indexes.

Example: (remove-indexes [0 2] [:a :b :c :d]) ; => [:b :d]

removet clj/s

(removet pred coll)

Like remove but keeps the collection type.

render-template clj/s

(render-template template args)

Renders the template using args for data. Example:

(render-template "Error: {error-code}" {:error-code 11}) ; => "Error: 11"

seq-> clj/s macro

(seq-> expr & forms)

When expr is a seq (clojure.core/seq not returns nil), threads it into the first form (via ->), and when that result is a seq, through the next etc

seq->> clj/s macro

(seq->> expr & forms)

When expr is a seq (`clojure.core/seq not returns nil), threads it into the first form (via ->>), and when that result is a seq, through the next etc

seqt clj/s

(seqt coll)

Like seq but returns the original coll if not empty

simple-ident clj/s

(simple-ident ident)

Takes an ident and unqualifies it (removed the namespace). Returns the same type of ident as was provided. Returns nil if ident is not an ident.

simple-keyword clj/s

(simple-keyword s)

Forces a simple keyword. Useful when forward slashes can be present in the string s

simple-symbol clj/s

(simple-symbol s)

Forces a simple symbol Useful when forward slashes can be present in the string s

singleton? clj/s

(singleton? coll)

Returns true if the coll has exactly one element, false otherwise.

substring clj/s

(substring s start end)

template-params clj/s

(template-params template)

Calculate a sequence of params required by the template

throw-ex clj/s macro

(throw-ex msg-template & symbols)

Throw an exception with a msg template and optional vars. The msg template will be rendered using the scoped vars and the template args and vars will be put in the map to ex-info.

Example:

`(let [namn "foohead" age 8] (throw-ex "Hello {namn}" age))

; => {:age 8, :namn "foohead", :msg "Hello foohead"}`

transpose clj/s

(transpose xs)

Transpose a seq of seqs. Returns a vector of vectors.

unqualify-ident clj/s

(unqualify-ident ident)