yang.lang — tolitius/yang 0.1.28

and-> clj

(and->)

(and-> x)

(and-> x & [f & fs])

append-if-absent clj

(append-if-absent v xs)

(append-if-absent v xs delim)

bbuffer->str clj

(bbuffer->str bb)

bytes->str clj

(bytes->str bs)

(bytes->str bs enc)

camel-to-dash clj

(camel-to-dash k)

capitalize clj

(capitalize xs)

cconj clj

(cconj xs item & {:keys [size]})

circular conj adds an item into a collection, droping the last element in case a collection count is greater than a :size. (def l '(10 11 12 13 14 15 16 17)) (take 5 (iterate #(cconj % (rand-int 10) :size 10) l)) => ((10 11 12 13 14 15 16 17) (3 10 11 12 13 14 15 16 17) (9 3 10 11 12 13 14 15 16 17) (5 9 3 10 11 12 13 14 15 16) (2 5 9 3 10 11 12 13 14 15))

csv->vec clj

(csv->vec csv)

dash-keys clj

(dash-keys m)

(dash-keys from m)

dash-to-camel clj

(dash-to-camel xs)

deep-merge-with clj

(deep-merge-with f & maps)

like merge-with, but merges maps recursively, appling the given fn only when there's a non-map at a particular level. (deepmerge + {:a {:b {:c 1 :d {:x 1 :y 2}} :e 3} :f 4} {:a {:b {:c 2 :d {:z 9} :z 3} :e 100}}) -> {:a {:b {:z 3, :c 3, :d {:z 9, :x 1, :y 2}}, :e 103}, :f 4}

dissoc-in clj

(dissoc-in m [k & ks :as keys])

from https://github.com/clojure/core.incubator

dissociates an entry from a nested associative structure returning a new nested structure. keys is a sequence of keys. Any empty maps that result will not be present in the new structure.

edn-resource clj

(edn-resource path)

extract-key-ns clj

(extract-key-ns m kns)

=> (extract-key-ns {:a/one :a-one :a/two :a-two :b/one :b-one :b/two :b-two} :a)

{:a {:one :a-one :two :a-two}}

fmk clj

(fmk m f)

apply f to each key k of map m

fmv clj

(fmv m f)

apply f to each value v of map m

freq-map clj

(freq-map m by)

future->completable-future clj

(future->completable-future fut pool)

group-by-first clj

(group-by-first m)

takes a seq of 2 element tuples and groups them by the first (key) element. (group-by-first [[1 2][1 4][2 3][2 7]]) {1 (4 2), 2 (7 3)}

group-by-ns clj

(group-by-ns m)

=> (group-by-ns {:a/one :a-one :b/one :b-one :a/two :a-two :b/two :b-two})

{:a {:one :a-one, :two :a-two} :b {:one :b-one, :two :b-two}}

gunzip-edn clj

(gunzip-edn bs)

gzip-edn clj

(gzip-edn edn)

instance-method clj

(instance-method obj method-name)

(instance-method obj method-name args)

jcoll? clj

(jcoll? x)

join clj

(join xs1 xs2 on)

lower-case clj

(lower-case s)

merge-maps clj

(merge-maps & m)

none? clj

(none? v)

one-if-none clj

(one-if-none n)

parse-double clj

(parse-double d)

parse-long clj

(parse-long l)

parse-number clj

(parse-number n)

plus clj

(plus & xs)

pos-number? clj

(pos-number? n)

positive? clj

(positive? xs)

pretty clj

(pretty & args)

private-field clj

(private-field obj field)

private-method clj

(private-method obj method & args)

props->map clj

(props->map props)

java.util.Properties to map

ranged-rand clj

(ranged-rand start end)

remove-deep clj

(remove-deep key-set data)

remove-empty clj

(remove-empty m)

=> (remove-empty {:a nil :b "" :c [] :d 42}) {:d 42}

remove-key-ns clj

(remove-key-ns m)

(remove-key-ns m kns)

replace-in-keys clj

(replace-in-keys m from to)

replace-in-kw clj

(replace-in-kw kw from to)

=> (replace-in-kw :foo-bar-baz "bar" "zoo") :foo-zoo-baz

replace-line clj

(replace-line path from to)

rfmk clj

(rfmk m f)

recursively apply f to each key k of map m

rm-sort clj

(rm-sort m)

reverse map sort (by key)

seq->in-params clj

(seq->in-params xs)

show-threads clj

(show-threads)

from: https://twitter.com/chrishouser/status/1306000820580876288

slurp-resource clj

(slurp-resource path)

squuid clj

(squuid)

tasty sequential UUIDs from: https://github.com/clojure-cookbook/clojure-cookbook/blob/1b3754a7f4aab51cc9b254ea102870e7ce478aa0/01_primitive-data/1-24_uuids.asciidoc

static-method clj

(static-method clazz method params)

str->bytes clj

(str->bytes xs)

(str->bytes xs enc)

str->edn clj

(str->edn xs)

str->uuid clj

(str->uuid s)

str-val clj

(str-val v)

str= clj

(str= s v)

case insensitive

suuid? clj

(suuid? s)

sval? clj

(sval? v)

then-apply clj

(then-apply cf f)

then-compose clj

(then-compose cf f)

to-alpha-num clj

(to-alpha-num xs)

to-double clj

(to-double n)

to-long clj

(to-long n)

trim clj

(trim s)

underscore-keys clj

(underscore-keys m)

(underscore-keys from m)

upper-case clj

(upper-case s)

uuid clj

(uuid)

value clj

(value v)

value? clj

(value? v)

zero-uuid clj