Welcome to the documentation for @effect/typeclass, a collection of re-usable typeclasses for the Effect ecosystem.
The functional abstractions in @effect/typeclass can be broadly divided into two categories.
Abstractions For Concrete Types - These abstractions define properties of concrete types, such as number and string, as well as ways of combining those values.
Abstractions For Parameterized Types - These abstractions define properties of parameterized types such as ReadonlyArray and Option and ways of combining them.
Concrete Types
Members and derived functions
Note: members are in bold.
Bounded
A type class used to name the lower limit and the upper limit of a type.
Extends:
Order
Name
Given
To
maxBound
A
effect-bot
ma+effect@matechs.com
minBound
A
reverse
Bounded<A>
Bounded<A>
clamp
A
A
Monoid
A Monoid is a Semigroup with an identity. A Monoid is a specialization of a
Semigroup, so its operation must be associative. Additionally,
x |> combine(empty) == empty |> combine(x) == x. For example, if we have Monoid<String>,
with combine as string concatenation, then empty = "".
Extends:
Semigroup
Name
Given
To
empty
A
combineAll
Iterable<A>
A
reverse
Monoid<A>
Monoid<A>
tuple
[Monoid<A>, Monoid<B>, ...]
Monoid<[A, B, ...]>
struct
{ a: Monoid<A>, b: Monoid<B>, ... }
Monoid<{ a: A, b: B, ... }>
min
Bounded<A>
Monoid<A>
max
Bounded<A>
Monoid<A>
Semigroup
A Semigroup is any set A with an associative operation (combine):
x |> combine(y) |> combine(z) == x |> combine(y |> combine(z))
A type class of types which give rise to two independent, covariant
functors.
Name
Given
To
bimap
F<E1, A>, E1 => E2, A => B
F<E2, B>
mapLeft
F<E1, A>, E1 => E2
F<E2, A>
map
F<A>, A => B
F<B>
Chainable
Extends:
FlatMap
Covariant
Name
Given
To
tap
F<A>, A => F<B>
F<A>
andThenDiscard
F<A>, F<B>
F<A>
bind
F<A>, name: string, A => F<B>
F<A & { [name]: B }>
Contravariant
Contravariant functors.
Extends:
Invariant
Name
Given
To
contramap
F<A>, B => A
F<B>
contramapComposition
F<G<A>>, A => B
F<G<B>>
imap
contramap
imap
Coproduct
Coproduct is a universal monoid which operates on kinds.
This type class is useful when its type parameter F<_> has a
structure that can be combined for any particular type, and which
also has a "zero" representation. Thus, Coproduct is like a Monoid
for kinds (i.e. parametrized types).
A Coproduct<F> can produce a Monoid<F<A>> for any type A.
Here's how to distinguish Monoid and Coproduct:
Monoid<A> allows A values to be combined, and also means there
is an "empty" A value that functions as an identity.
Coproduct<F> allows two F<A> values to be combined, for any A. It
also means that for any A, there is an "zero" F<A> value. The
combination operation and zero value just depend on the
structure of F, but not on the structure of A.
Extends:
SemiCoproduct
Name
Given
To
zero
F<A>
coproductAll
Iterable<F<A>>
F<A>
getMonoid
Monoid<F<A>>
Covariant
Covariant functors.
Extends:
Invariant
Name
Given
To
map
F<A>, A => B
F<B>
mapComposition
F<G<A>>, A => B
F<G<B>>
imap
map
imap
flap
A, F<A => B>
F<B>
as
F<A>, B
F<B>
asUnit
F<A>
F<void>
Filterable
Filterable<F> allows you to map and filter out elements simultaneously.
Name
Given
To
partitionMap
F<A>, A => Either<B, C>
[F<B>, F<C>]
filterMap
F<A>, A => Option<B>
F<B>
compact
F<Option<A>>
F<A>
separate
F<Either<A, B>>
[F<A>, F<B>]
filter
F<A>, A => boolean
F<A>
partition
F<A>, A => boolean
[F<A>, F<A>]
partitionMapComposition
F<G<A>>, A => Either<B, C>
[F<G<B>>, F<G<C>>]
filterMapComposition
F<G<A>>, A => Option<B>
F<G<B>>
FlatMap
Name
Given
To
flatMap
F<A>, A => F<B>
F<B>
flatten
F<F<A>>
F<A>
andThen
F<A>, F<B>
F<B>
composeKleisliArrow
A => F<B>, B => F<C>
A => F<C>
Foldable
Data structures that can be folded to a summary value.
In the case of a collection (such as ReadonlyArray), these
methods will fold together (combine) the values contained in the
collection to produce a single result. Most collection types have
reduce methods, which will usually be used by the associated
Foldable<F> instance.
Name
Given
To
reduce
F<A>, B, (B, A) => B
B
reduceComposition
F<G<A>>, B, (B, A) => B
B
reduceRight
F<A>, B, (B, A) => B
B
foldMap
F<A>, Monoid<M>, A => M
M
toReadonlyArray
F<A>
ReadonlyArray<A>
toReadonlyArrayWith
F<A>, A => B
ReadonlyArray<B>
reduceKind
Monad<G>, F<A>, B, (B, A) => G<B>
G<B>
reduceRightKind
Monad<G>, F<A>, B, (B, A) => G<B>
G<B>
foldMapKind
Coproduct<G>, F<A>, (A) => G<B>
G<B>
Invariant
Invariant functors.
Name
Given
To
imap
F<A>, A => B, B => A
F<B>
imapComposition
F<G<A>>, A => B, B => A
F<G<B>>
bindTo
F<A>, name: string
F<{ [name]: A }>
tupled
F<A>
F<[A]>
Monad
Allows composition of dependent effectful functions.
Extends:
FlatMap
Pointed
Of
Name
Given
To
of
A
F<A>
ofComposition
A
F<G<A>>
unit
F<void>
Do
F<{}>
Pointed
Extends:
Covariant
Of
Product
Extends:
SemiProduct
Of
Name
Given
To
productAll
Iterable<F<A>>
F<ReadonlyArray<A>>
tuple
[F<A>, F<B>, ...]
F<[A, B, ...]>
struct
{ a: F<A>, b: F<B>, ... }
F<{ a: A, b: B, ... }>
SemiAlternative
Extends:
SemiCoproduct
Covariant
SemiApplicative
Extends:
SemiProduct
Covariant
Name
Given
To
liftSemigroup
Semigroup<A>
Semigroup<F<A>>
ap
F<A => B>, F<A>
F<B>
andThenDiscard
F<A>, F<B>
F<A>
andThen
F<A>, F<B>
F<B>
lift2
(A, B) => C
(F<A>, F<B>) => F<C>
lift3
(A, B, C) => D
(F<A>, F<B>, F<C>) => F<D>
SemiCoproduct
SemiCoproduct is a universal semigroup which operates on kinds.
This type class is useful when its type parameter F<_> has a
structure that can be combined for any particular type. Thus,
SemiCoproduct is like a Semigroup for kinds (i.e. parametrized
types).
A SemiCoproduct<F> can produce a Semigroup<F<A>> for any type A.
Here's how to distinguish Semigroup and SemiCoproduct:
Semigroup<A> allows two A values to be combined.
SemiCoproduct<F> allows two F<A> values to be combined, for any A.
The combination operation just depends on the structure of F,
but not the structure of A.
Extends:
Invariant
Name
Given
To
coproduct
F<A>, F<B>
F<A | B>
coproductMany
Iterable<F<A>>
F<A>
getSemigroup
Semigroup<F<A>>
coproductEither
F<A>, F<B>
F<Either<A, B>>
SemiProduct
Extends:
Invariant
Name
Given
To
product
F<A>, F<B>
F<[A, B]>
productMany
F<A>, Iterable<F<A>>
F<[A, ...ReadonlyArray<A>]>
productComposition
F<G<A>>, F<G<B>>
F<G<[A, B]>>
productManyComposition
F<G<A>>, Iterable<F<G<A>>>
F<G<[A, ...ReadonlyArray<A>]>>
nonEmptyTuple
[F<A>, F<B>, ...]
F<[A, B, ...]>
nonEmptyStruct
{ a: F<A>, b: F<B>, ... }
F<{ a: A, b: B, ... }>
andThenBind
F<A>, name: string, F<B>
F<A & { [name]: B }>
productFlatten
F<A>, F<B>
F<[...A, B]>
Traversable
Traversal over a structure with an effect.
Name
Given
To
traverse
Applicative<F>, T<A>, A => F<B>
F<T<B>>
traverseComposition
Applicative<F>, T<G<A>>, A => F<B>
F<T<G<B>>>
sequence
Applicative<F>, T<F<A>>
F<T<A>>
traverseTap
Applicative<F>, T<A>, A => F<B>
F<T<A>>
TraversableFilterable
TraversableFilterable, also known as Witherable, represents list-like structures
that can essentially have a traverse and a filter applied as a single
combined operation (traverseFilter).