uncomplicate.fluokitten.algo — uncomplicate/fluokitten 0.9.2

atom-fmap! clj

(atom-fmap! a g)

(atom-fmap! ax g ry)

(atom-fmap! ax g ry rz)

(atom-fmap! ax g ry rz rw)

(atom-fmap! ax g ry rz rw rws)

atom-id clj

(atom-id a)

atom-pure clj

(atom-pure _ v)

coll-bind clj

(coll-bind c g)

(coll-bind c g ss)

coll-fapply clj

(coll-fapply cv cg)

(coll-fapply cv cg cvs)

coll-fmap clj

(coll-fmap c g)

(coll-fmap c g ss)

coll-join clj

(coll-join c)

coll-op* clj

(coll-op* zero)

coll-pure clj

(coll-pure cv v)

(coll-pure cv v vs)

collection-fold clj

(collection-fold c)

(collection-fold c f init)

(collection-fold cx f init cy)

(collection-fold cx f init cy cz)

(collection-fold cx f init cy cz cw)

(collection-fold cx f init cy cz cw cws)

collection-foldmap clj

(collection-foldmap c g)

(collection-foldmap c g f init)

(collection-foldmap cx g f init cy)

(collection-foldmap cx g f init cy cz)

(collection-foldmap cx g f init cy cz cw)

(collection-foldmap cx g f init cy cz cw cws)

collfold-fold clj

(collfold-fold c)

(collfold-fold c f init)

collreduce-bind clj

(collreduce-bind cr g)

(collreduce-bind cr g ss)

collreduce-extract clj

(collreduce-extract c)

collreduce-fapply clj

(collreduce-fapply crv crg)

(collreduce-fapply cv cg cvs)

collreduce-fmap clj

(collreduce-fmap cr g)

(collreduce-fmap _ _ _)

collreduce-join clj

(collreduce-join c)

collreduce-op clj

(collreduce-op)

(collreduce-op x)

(collreduce-op x y)

(collreduce-op x y z)

(collreduce-op x y z w)

(collreduce-op x y z w & ws)

collreduce-pure clj

(collreduce-pure _ v)

create-mapentry clj

(create-mapentry k v)

Creates a map entry with the supplied key and value. On JVM it creates an instance of clojure.lang.MapEntry.

default-bind clj

(default-bind m g)

(default-bind m g ms)

default-foldmap clj

(default-foldmap x g)

(default-foldmap x g f init)

(default-foldmap x g f init y)

(default-foldmap x g f init y z)

(default-foldmap x g f init y z w)

(default-foldmap x g f init y z w ws)

default-unbind clj

(default-unbind wa g)

(default-unbind wa g was)

default-unbind! clj

(default-unbind! wa g)

(default-unbind! wa g was)

eduction-bind clj

(eduction-bind e g)

(eduction-bind e g ss)

eduction-fapply clj

(eduction-fapply ev eg)

(eduction-fapply ev eg evs)

eduction-fmap clj

(eduction-fmap e g)

(eduction-fmap e g ss)

eduction-foldmap clj

(eduction-foldmap c g)

(eduction-foldmap c g f init)

(eduction-foldmap cx g f init cy)

(eduction-foldmap cx g f init cy cz)

(eduction-foldmap cx g f init cy cz cw)

(eduction-foldmap cx g f init cy cz cw cws)

eduction-join clj

(eduction-join e)

eduction-op clj

(eduction-op)

(eduction-op x)

(eduction-op x y)

(eduction-op x y z)

(eduction-op x y z w)

(eduction-op x y z w & ws)

eduction-pure clj

(eduction-pure e v)

(eduction-pure e v vs)

extend-atom clj macro

(extend-atom t)

extend-collection clj macro

(extend-collection t)

extend-eduction clj macro

(extend-eduction t)

extend-function clj macro

(extend-function t)

extend-hashmap clj macro

(extend-hashmap t)

extend-ideref clj macro

(extend-ideref t)

extend-just clj macro

(extend-just t just-pure)

extend-keyword clj macro

(extend-keyword t)

extend-lazyseq clj macro

(extend-lazyseq t)

extend-list clj macro

(extend-list t)

extend-mapentry clj macro

(extend-mapentry t)

extend-ref clj macro

(extend-ref t)

extend-seq clj macro

(extend-seq t)

extend-set clj macro

(extend-set t)

extend-vector clj macro

(extend-vector t)

extend-volatile clj macro

(extend-volatile t)

function-bind clj

(function-bind f g)

(function-bind f g hs)

function-extract clj

(function-extract f)

function-fapply clj

(function-fapply f g)

(function-fapply f g hs)

function-fmap clj

(function-fmap f g)

(function-fmap f g hs)

function-fold clj

(function-fold fx)

(function-fold fx f init)

(function-fold fx f init fy)

(function-fold fx f init fy fz)

(function-fold fx f init fy fz fw)

(function-fold fx f init fy fz fw fws)

function-join clj

(function-join f)

function-op clj

(function-op)

(function-op x)

(function-op x y & zs)

function-pure clj

(function-pure f x)

hashmap-bind clj

(hashmap-bind m g)

(hashmap-bind m g ms)

hashmap-fapply clj

(hashmap-fapply mv mg)

(hashmap-fapply mv mg mvs)

hashmap-fmap clj

(hashmap-fmap m g)

(hashmap-fmap m g ms)

hashmap-fold clj

(hashmap-fold m)

(hashmap-fold m f init)

(hashmap-fold mx f init my)

(hashmap-fold mx f init my mz)

(hashmap-fold mx f init my mz mw)

(hashmap-fold mx f init my mz mw mws)

hashmap-join clj

(hashmap-join m)

hashmap-pure clj

(hashmap-pure m v)

(hashmap-pure m v vs)

just-bind clj

(just-bind jv g)

(just-bind jv g jvs)

just-fapply clj

(just-fapply jv jg)

(just-fapply jv jg jvs)

just-fmap clj

(just-fmap jv g)

(just-fmap jv g jvs)

just-fold clj

(just-fold x)

(just-fold x f init)

(just-fold x f init y)

(just-fold x f init y z)

(just-fold x f init y z w)

(just-fold x f init y z w ws)

just-foldmap clj

(just-foldmap x g)

(just-foldmap x g f init)

(just-foldmap x g f init y)

(just-foldmap x g f init y z)

(just-foldmap x g f init y z w)

(just-foldmap x g f init y z w ws)

just-join clj

(just-join jjv)

just-op clj

(just-op)

(just-op x)

(just-op x y & zs)

keyword-fapply clj

(keyword-fapply kv kg)

(keyword-fapply kv kg kvs)

keyword-fmap clj

(keyword-fmap k g)

(keyword-fmap k g ks)

keyword-id clj

keyword-op clj

(keyword-op)

(keyword-op x)

(keyword-op x y)

(keyword-op x y z)

(keyword-op x y z w)

(keyword-op x y z w ws)

keyword-pure clj

(keyword-pure k v)

(keyword-pure k v vs)

list-bind clj

(list-bind c g)

(list-bind c g ss)

list-fapply clj

(list-fapply cv cg)

(list-fapply cv cg cvs)

list-fmap clj

(list-fmap l g)

(list-fmap l g ss)

list-join clj

(list-join c)

list-op clj

(list-op)

(list-op x)

(list-op x y)

(list-op x y z)

(list-op x y z w)

(list-op x y z w & ws)

mapentry-fapply clj

(mapentry-fapply [ke ve :as e] [kg vg])

(mapentry-fapply [ke ve :as e] [kg vg] es)

mapentry-fmap clj

(mapentry-fmap [ke ve] g)

(mapentry-fmap [ke ve] g es)

mapentry-fold clj

(mapentry-fold e)

(mapentry-fold e f init)

(mapentry-fold e f init e1)

(mapentry-fold e f init e1 e2)

(mapentry-fold e f init e1 e2 e3)

(mapentry-fold e f init e1 e2 e3 es)

mapentry-foldmap clj

(mapentry-foldmap e g)

(mapentry-foldmap e g f init)

(mapentry-foldmap e g f init e1)

(mapentry-foldmap e g f init e1 e2)

(mapentry-foldmap e g f init e1 e2 e3)

(mapentry-foldmap e g f init e1 e2 e3 es)

mapentry-id clj

(mapentry-id [kx vx])

mapentry-join clj

(mapentry-join [k x :as e])

mapentry-op clj

(mapentry-op e)

mapentry-pure clj

(mapentry-pure e v)

object-fmap clj

(object-fmap o f)

(object-fmap o f os)

object-fold clj

(object-fold x)

(object-fold x f init)

(object-fold x f init y)

(object-fold x f init y z)

(object-fold x f init y z w)

(object-fold x f init y z w ws)

object-foldmap clj

(object-foldmap x g)

(object-foldmap x g f init)

(object-foldmap x g f init y)

(object-foldmap x g f init y z)

(object-foldmap x g f init y z w)

(object-foldmap x g f init y z w ws)

object-pure clj

(object-pure o x)

reducible-bind clj

(reducible-bind c g)

(reducible-bind c g ss)

reducible-fapply clj

(reducible-fapply cv cg)

(reducible-fapply cv cg cvs)

reducible-fmap clj

(reducible-fmap c g)

(reducible-fmap c g cs)

reducible-join clj

(reducible-join c)

reducible-op clj

(reducible-op)

(reducible-op x)

(reducible-op x y)

(reducible-op x y z)

(reducible-op x y z w)

(reducible-op x y z w & ws)

ref-fmap! clj

(ref-fmap! rx g)

(ref-fmap! rx g ry)

(ref-fmap! rx g ry rz)

(ref-fmap! rx g ry rz rw)

(ref-fmap! rx g ry rz rw rws)

ref-id clj

(ref-id r)

ref-pure clj

(ref-pure _ v)

reference-bind clj

(reference-bind mv g)

(reference-bind mv g mvs)

reference-bind! clj

(reference-bind! mv g)

(reference-bind! mv g mvs)

reference-fapply clj

(reference-fapply rv rg)

(reference-fapply rv rg rvs)

reference-fapply! clj

(reference-fapply! rv rg)

(reference-fapply! rv rg rvs)

reference-fmap clj

(reference-fmap r g)

(reference-fmap r g rs)

reference-fold clj

(reference-fold r)

(reference-fold r f init)

(reference-fold rx f init ry)

(reference-fold rx f init ry rz)

(reference-fold rx f init ry rz rw)

(reference-fold rx f init ry rz rw rws)

reference-foldmap clj

(reference-foldmap rx g)

(reference-foldmap rx g f init)

(reference-foldmap rx g f init ry)

(reference-foldmap rx g f init ry rz)

(reference-foldmap rx g f init ry rz rw)

(reference-foldmap rx g f init ry rz rw rws)

reference-join clj

(reference-join r)

reference-join! clj

(reference-join! r)

reference-op clj

(reference-op r)

seq-bind clj

(seq-bind c g)

(seq-bind c g ss)

seq-fapply clj

(seq-fapply cv cg)

(seq-fapply cv cg cvs)

seq-fmap clj

(seq-fmap s g)

(seq-fmap s g ss)

seq-join clj

(seq-join s)

seq-op* clj

(seq-op* zero)

seq-pure clj

(seq-pure cv v)

(seq-pure cv v vs)

seq-unbind clj

(seq-unbind s g)

(seq-unbind s g ss)

volatile-fmap! clj

(volatile-fmap! v g)

(volatile-fmap! vx g ry)

(volatile-fmap! vx g ry rz)

(volatile-fmap! vx g ry rz rw)

(volatile-fmap! vx g ry rz rw rws)

volatile-id clj

(volatile-id a)

volatile-pure clj

(volatile-pure _ v)