full.core.sugar — fullcontact/full.core 1.1.1

?assoc clj/s

(?assoc m & kvs)

Same as clojure.core/assoc, but skip the assoc if v is nil

?conj clj/s

(?conj coll & xs)

Same as conj, but skip the conj if v is falsey

?hash-map clj/s

(?hash-map & keyvals)

Creates a hash-map from all key value pairs where value is not nil.

?move-in clj/s

(?move-in m from to)

Moves a value in nested assoc structure, if it is not nil.

?update clj/s

(?update m k f & args)

Performs a clojure.core/update if the original or resulting value is truthy, otherwise dissoc key.

?update-in clj/s

(?update-in m [k & ks] f & args)

Performs a clojure.core/update-in if the original or resulting value is truthy, otherwise dissoc key.

all? clj/s

as-long clj/s

(as-long s)

ascii clj

(ascii s)

Ensures all characters in the given string are converted to ASCII. For example: ā->a.

assoc-first clj/s

(assoc-first m k)

Replaces value of key k in map m with the first value sequence first item from map given key to resultant map.

byte-buffer->byte-vector clj

(byte-buffer->byte-vector bb)

byte-buffer->hex-string clj

(byte-buffer->hex-string byte-buffer)

copy-in clj/s

(copy-in m from to)

deep-merge clj/s

(deep-merge & values)

Deep merge two maps

def-name clj/s

(def-name sym)

Returns human readable name of defined symbol (such as def or defn).

dissoc-in clj/s

(dissoc-in m [k & ks])

dq clj/s

(dq s)

Converts single quotes to double quotes.

ellapsed-time clj/s

(ellapsed-time time-bookmark)

Returns ellapsed time in milliseconds since the time bookmark.

filter-indexed clj/s

(filter-indexed pred coll)

fn-name clj macro

(fn-name meta-name args & body)

format-opt-prec clj/s

(format-opt-prec n precision)

idx-of clj/s

(idx-of collection item)

Similar to .indexOf, but works with lazy collections as well.

if->> clj macro

(if->> cnd & threads)

Using if + ->> inside ->> threads Takes a single condition and one or more forms that will be executed if the condition is true. An else block can be passed in by separating forms with :else keyword. Contition can take the initial value as argument, it needs to be referenced as '%' (eg, (some-condition %) (->> (range 10) (if->> false (filter odd?) (map inc) :else (filter even?) (map dec))) => (-1 1 3 5 7)

if-cljs clj macro

(if-cljs then else)

Return then if we are generating cljs code and else for Clojure code. https://groups.google.com/d/msg/clojurescript/iBY5HaQda4A/w1lAQi9_AwsJ

index-by clj/s

(index-by kf coll)

(index-by kf vf coll)

Returns a map of the values in coll indexed by the result of applying kf. A value mapping function vf can be provided too.

insert-at clj/s

(insert-at s idx i)

Returns the sequence s with the item i inserted at 0-based index idx.

juxt-partition clj/s

(juxt-partition pred coll & fns)

Takes a predicate function, a collection and one ore more (fn predicate coll) functions that will be applied to the given collection. Example: (juxt-partition odd? [1 2 3 4] filter remove) => [(1 3) (2 4)].

map-map clj/s

(map-map key-fn m)

(map-map key-fn value-fn m)

map-value clj/s

(map-value value-fn m)

mapply clj/s

(mapply f & args)

mname clj/s

(mname obj)

Meta name for the object.

move-in clj/s

(move-in m from to)

Moves a value in nested assoc structure.

move-map-in clj/s

(move-map-in m f from to)

nest-> clj macro

(nest-> & threads)

Allows to sneak in ->s inside ->>s. (->> (range 3) (map inc) (nest-> (nth 1) inc) (str "x")) => x3

num->compact clj/s

(num->compact n & {:keys [prefix suffix]})

number-or-string clj/s

(number-or-string s)

pipe clj

(pipe)

Returns a vector containing a sequence that will read from the queue, and a function that inserts items into the queue.

query-string clj/s

(query-string m)

re-quote clj/s

(re-quote s)

Returns a literal regex pattern for given string, similiar to Java's Pattern.quote.

remap clj/s

(remap m mapping)

Remap keys of m based on mapping.

remove-at clj/s

(remove-at s idx)

Returns the sequence s with the element at 0-based index idx removed.

remove-empty-val clj/s

(remove-empty-val m)

Filter empty? values from map.

remove-nil-val clj/s

(remove-nil-val m)

Filter nil values from a map m.

remove-prefix clj/s

(remove-prefix s prefix)

remove-suffix clj/s

(remove-suffix s suffix)

replace-at clj/s

(replace-at s idx i)

Returns the sequence s with the item at 0-based index idx.

replace-prefix clj/s

(replace-prefix s prefix new-prefix)

some-when clj/s deprecated

(some-when pred coll)

Similiar to some but returns matching value instead of predicates result.

str-greater? clj/s

(str-greater? this that)

Returns true if this is greater than that. Case insensitive.

str-smaller? clj/s

(str-smaller? this that)

Returns true if this is smaller than that. Case insensitive.

strip clj/s

(strip s cs)

Takes a string s and a string cs. Removes all cs characters from s.

time-bookmark clj/s

(time-bookmark)

Returns time bookmark (technically system time in nanoseconds). For use in concert with ellapsed-time to messure execution time of some code block.

update-first clj/s

(update-first s m)

(update-first s m & args)

Updates first item in sequence s by applying mapping method m to it.

update-last clj/s

(update-last s m)

(update-last s m & args)

Updates last item in sequence s by applying mapping method m to it.

uuids clj/s

(uuids)

Generates UUID without dashes.

when-> clj macro

(when-> thread cnd & threads)

Using when + -> inside -> threads Takes a single condition and multiple forms that will be executed like a normal -> if the condition is true. Contition can take the initial value as argument, it needs to be referenced as '%' (eg, (some-condition %) (-> "foobar" (upper-case) (when-> true (str "baz"))) => FOOBARbaz

when->> clj macro

(when->> cnd & threads)

Using when + ->> inside ->> threads Takes a single condition and one or more forms that will be executed like a regular ->>, if condition is true. Will pass the initial value if condition is false. Contition can take the initial value as argument, it needs to be referenced as '%' (eg, (some-condition %) (->> (range 10) (map inc) (when->> true (filter even?))) => (2 4 6 8 10)

when->>-> clj macro

(when->>-> cnd & threads)

Using when + -> inside ->> threads. Takes a single condition cnd and multiple forms that will be exectued as a regular ->>, if the condition is true (otherwise the initial value will be passed to next form). Contition can take the initial value as argument, it needs to be referenced as '%' (eg, (some-condition %) (->> (range 3) (map inc) (when->>-> (seq %) (into ["header"]))) => ("header" 1 2 3)

with-mname clj macro

(with-mname meta-name body)