Index of values


(%) [Fn]
(<*>) [Applicative.S3]
(<*>) [Applicative.S2]
(<*>) [Applicative.S]
(<~>) [Applicative.S3]
(<~>) [Applicative.S2]
(<~>) [Applicative.S]
(>>=) [Monad.S3]
(>>=) [Monad.S2]
(>>=) [Monad.S]
(>\|=) [Functor.S3]
(>\|=) [Functor.S2]
(>\|=) [Functor.S]
_Both [These]
_Cons [Clarity_list]
_Left [These]
_Left [Either]
_Nil [Clarity_list]
_None [Option]
_Right [These]
_Right [Either]
_Some [Option]
A
absurd [Void]	Since Void.t values don't exist, it's logically possible to create value of any type
align [Align.S3]
align [Align.S2]
align [Align.S]
align_with [Align.Basic3]
align_with [Align.Basic2]
align_with [Align.Basic]
all [Foldable.S]
any [Foldable.S]
ap [Applicative.Basic3]
ap [Applicative.Basic2]
ap [Applicative.Basic]
ap' [Applicative.S3]
ap' [Applicative.S2]
ap' [Applicative.S]
append [Vector]	Concatenates two vectors.
append [Semigroup.S]
append [Monoid.S]
append [Clarity_list]
ask [Reader]
B
bimap [These]
bimap [Either]
bind [Monad.Basic3]
bind [Monad.Basic2]
bind [Monad.Basic]
C
censor [Writer.Make]
clear [Vector.Builder]	Clear builder.
compose [Fn]
cons [Vector]	Prepend one element to vector.
const [Fn]
copy [Vector.Builder]	Create copy of this builder.
curry [Fn]
D
defer [Fn]
dimap [Reader]
discard_left [Applicative.S3]
discard_left [Applicative.S2]
discard_left [Applicative.S]
discard_right [Applicative.S3]
discard_right [Applicative.S2]
discard_right [Applicative.S]
drop [Vector]	`drop v i` returns the suffix of `v` starting at `i`.
E
empty [Vector.Builder]	Creates new empty builder.
empty [Vector]	Empty vector.
F
fail [Validation.Make]
falign [Align.S3]
falign [Align.S2]
falign [Align.S]
filter [Clarity_list]
find [Foldable.S]
flip [Fn]
fold [Validation.Make]
fold [These]
fold [Option]
fold [Either]
fold_map [Foldable.S]
foldl [Foldable.Basic]
foldl_m [Foldable.M3]
foldl_m [Foldable.M2]
foldl_m [Foldable.M]
foldr [Foldable.Basic]
foldr' [Foldable.S]
foldr_m [Foldable.M3]
foldr_m [Foldable.M2]
foldr_m [Foldable.M]
forever [Applicative.S3]
forever [Applicative.S2]
forever [Applicative.S]
G
get [Vector]	`get v i` returns the element of a `v` at position `i`.
get [State]
gets [State]
I
id [Fn]
init [Vector]	`init l f` creates vector of length `l` where value at position `i` is initialized with `f i`.
intersperse [Clarity_list]
iter [Vector]	`iter f v` iterates over `v` applying `f` to each element.
iter [Clarity_list]
J
join [Monad.S3]
join [Monad.S2]
join [Monad.S]
L
length [Vector]	The length of a vector.
length [Clarity_list]
listen [Writer.Make]
local [Reader]
M
map [Functor.Basic3]
map [Functor.Basic2]
map [Functor.Basic]
map_errors [Validation.Make]
mapi [Clarity_list]
maybe_both [These]
maybe_errors [Validation.Make]
maybe_left [These]
maybe_left [Either]
maybe_result [Validation.Make]
maybe_right [These]
maybe_right [Either]
mcompose [Monad.S3]
mcompose [Monad.S2]
mcompose [Monad.S]
modify [State]
O
of_either [Validation.Make]
of_list [Vector]	Converts list to vector
P
pad_zip [Align.S3]
pad_zip [Align.S2]
pad_zip [Align.S]
pad_zip_with [Align.S3]
pad_zip_with [Align.S2]
pad_zip_with [Align.S]
pure [Applicative.Basic3]
pure [Applicative.Basic2]
pure [Applicative.Basic]
put [Vector.Builder]	Put element to builder.
put [State]
R
reader [Reader]
repeat [Applicative.S3]
repeat [Applicative.S2]
repeat [Applicative.S]
repeat_ [Applicative.S3]
repeat_ [Applicative.S2]
repeat_ [Applicative.S]
replace [Functor.S3]
replace [Functor.S2]
replace [Functor.S]
result [Vector.Builder]	Get vector of current elements in builder.
rev [Clarity_list]
rev_append [Clarity_list]
rev_map [Clarity_list]
rev_mapi [Clarity_list]
run [Writer.Make]
run [State]
run [Reader]
S
sequence [Traversable.S3]
sequence [Traversable.S2]
sequence [Traversable.S]
sequence_ [Traversable.S3]
sequence_ [Traversable.S2]
sequence_ [Traversable.S]
snoc [Vector]	Apppend one element to vector.
sort [Clarity_list]	Stable sort with supplied comparision function, default is Pervasives.compare
split_at [Vector]	`split_at v i` returns pair of a vectors where first element is the prefix of `v` of length `i` and second is the suffix of `v` starting at `i`.
state [State]
swap [These]
swap [Either]
T
take [Vector]	`take v i` returns the prefix of `v` of length `i`.
tell [Writer.Make]
to_either [Validation.Make]
to_list [Vector]	Converts vector to list
traverse [Traversable.Basic3]
traverse [Traversable.Basic2]
traverse [Traversable.Basic]
traverse_ [Traversable.Basic3]
traverse_ [Traversable.Basic2]
traverse_ [Traversable.Basic]
U
uncurry [Fn]
update [Vector]	`update v i x` returns new vector initialized with values of `v` where value at index `i` is replaced with `x`.
V
void [Functor.S3]
void [Functor.S2]
void [Functor.S]
W
writer [Writer.Make]
Z
zero [Monoid.S]