ribelo.extropy — com.github.ribelo/extropy 0.0.15

-array-list clj/s

(-array-list)

(-array-list xs)

-compose-preds clj/s macro

(-compose-preds f nc nf)

-crypto cljs

>js-props cljs

(>js-props m)

add-ns clj/s

(add-ns ns m)

as-?double clj/s

(as-?double x)

as-?long clj/s

(as-?long x)

assoc-some clj/s

(assoc-some m k v)

(assoc-some m k v & kvs)

assoc-some! clj/s

(assoc-some! m k v)

(assoc-some! m k v & kvs)

CacheEntry cljs

clj? clj/s

cljs? clj/s

comp clj/s

(comp)

(comp f)

(comp f g)

(comp f g h)

(comp f1 f2 f3 f4)

(comp f1 f2 f3 f4 f5)

(comp f1 f2 f3 f4 f5 f6)

(comp f1 f2 f3 f4 f5 f6 f7)

(comp f1 f2 f3 f4 f5 f6 f7 f8)

(comp f1 f2 f3 f4 f5 f6 f7 f8 & fs)

conj-some clj/s

(conj-some xs x)

(conj-some xs x & more)

conj-some! clj/s

(conj-some! xs x)

(conj-some! xs x & more)

conjs clj/s

conjs! clj/s

conjv clj/s

conjv! clj/s

deque clj/s

(deque)

(deque xs)

dissoc-in clj/s

(dissoc-in m ks)

do-task clj/s

(do-task t)

do-true clj/s macro

(do-true & body)

ensure-iter clj/s

(ensure-iter x)

ensure-persisten! clj/s

(ensure-persisten! xs)

ensure-transient clj/s

(ensure-transient xs)

every-pred clj/s

(every-pred [& preds])

every? clj/s

(every? pred xs)

filter clj/s

(filter pred xs)

(filter pred xs & colls)

filter-keys clj/s

(filter-keys pred m)

filter-vals clj/s

(filter-vals pred m)

first-key clj/s

(first-key xs)

first-val clj/s

(first-val xs)

format clj/s

(format fmt & args)

format-query-string clj/s

(format-query-string m)

format-url clj/s

(format-url url)

(format-url url & args)

group-by clj/s

(group-by f xs)

IExtropyCollection clj/s protocol

add clj/s

(add _ x)

(add _ i x)

add-first clj/s

(add-first _ x)

add-last clj/s

(add-last _ x)

clear clj/s

(clear _)

contains clj/s

(contains _ x)

put clj/s

(put k v)

put-in clj/s

(put-in ks v)

if-clj clj/s macro

(if-clj then & [else])

if-cljs clj/s macro

(if-cljs then & [else])

intersect? clj/s

(intersect? xs ys)

into-all clj/s

(into-all to from)

(into-all to from & more)

iter clj/s

(iter xs)

iter? clj/s

(iter? x)

keep clj/s

(keep pred xs)

key->prop cljs

(key->prop k)

kw-identical? clj/s

(kw-identical? x y)

loop-it clj/s macro

(loop-it bindings body & finish)

map clj/s

(map f xs)

(map f xs1 xs2)

(map f xs1 xs2 xs3)

(map f xs1 xs2 xs3 xs4)

(map f xs1 xs2 xs3 xs4 & colls)

memoize clj/s

(memoize f)

(memoize ttl-ms f)

ms clj/s

(ms n)

(ms n k)

multi-iter clj/s

(multi-iter colls)

(multi-iter xf colls)

nano-id cljs

(nano-id)

(nano-id size)

native-map clj/s

(native-map)

(native-map xs)

native-set clj/s

(native-set)

(native-set xs)

now-dt clj/s

(now-dt)

now-nano clj/s≠

clj

(now-nano)

cljs

now-udt clj/s

(now-udt)

oget cljs

(oget k)

(oget o k)

(oget o k not-found)

oget-in cljs

(oget-in ks)

(oget-in o ks)

(oget-in o ks not-found)

oset cljs

(oset o k v)

oset-in cljs

(oset-in o ks v)

path clj/s

(path & parts)

prn-task clj/s

(prn-task t)

prop->key cljs

(prop->key k)

qb clj/s macro

(qb nlaps form)

(qb nlaps form & more)

qname clj/s

(qname k)

random-bytes cljs

(random-bytes size)

rcompare clj/s

(rcompare x y)

reduce clj/s

(reduce f xs)

(reduce f init xs)

reduce-kv clj/s

(reduce-kv f m)

(reduce-kv f init m)

reduce-kvs clj/s

(reduce-kvs rf init kvs)

remove clj/s

(remove pred xs)

remove-ns clj/s

(remove-ns m)

rename-keys clj/s

(rename-keys m kmap)

round clj/s

(round x)

(round x nplaces)

round2 clj/s

(round2 x)

run! clj/s

(run! f xs)

sb-append clj/s

(sb-append sb s)

(sb-append sb s & more)

select-keys clj/s

(select-keys m xs)

sentinel clj/s

some clj/s

(some pred xs)

some-pred clj/s

(some-pred [& preds])

some= clj/s

(some= x xs)

sort clj/s

(sort xs)

(sort comp xs)

sort-by clj/s

(sort-by kfn xs)

(sort-by kfn comp xs)

str-builder clj/s

str-contains? clj/s

(str-contains? s x)

str-ends-with? clj/s

(str-ends-with? s x)

str-join clj/s

(str-join sep xs)

str-join-once clj/s

(str-join-once sep xs)

str-repeat clj/s

(str-repeat n s)

str-starts-with? clj/s

(str-starts-with? s x)

tap-task clj/s

(tap-task t)

time-ms clj/s macro

(time-ms & body)

time-ns clj/s macro

(time-ns & body)

transient? clj/s

(transient? xs)

url-decode clj/s

(url-decode s)

url-encode clj/s

(url-encode s)