Protocols

Protocol for automatic derivation of AffineTraversal optics.

Protocol for automatic Fold derivation

Protocol for automatic derivation of Getter optics

Protocol for automatic derivation of lenses.

Base protocol for optics automatic derivation.

Protocol for automatic derivation of Prism optics.

Protocol for automatic derivation of Setter

Protocol for automatic derivation of Traversal

At provides a Lens for a this structure to focus at AtFoci at a given index AtIndex.

Cons provides a Prism between this structure and a pair containing its first element and its tail. It provides a convenient way to attach or detach elements to the left side of a structure.

Each provides a Traversal that can focus into this structure to see all its foci of type EachFoci.

FilterIndex provides a Traversal for this structure with all its foci FilterIndexFoci whose index FilterIndexType satisfies a predicate.

Index provides an AffineTraversal for this structure to focus on an optional IndexFoci at a given index IndexType.

Snoc defines a Prism between this structure and its init (all elements but the last one) and last elements. It can be seen as the reverse of Cons. It provides a way to attach or detach elements on the end side of a structure.

A Functor provides a type with the ability to transform its value type into another type, while preserving its structure.

Using the encoding for HKTs in Bow, in the type Kind<F, A>, A is the value type and F represents the structure of the type. An instance of Functor for F allows to transform A into another type, while maintaining F unchanged.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Async models how a data type runs an asynchronous computation that may fail, described by the Proc signature.

Bracket models a generalized abstracted pattern of safe resource acquisition and release in the face of errors or interruptions.

Concurrent describes asynchronous operations that can be started concurrently.

ConcurrentEffect describes computations that can be cancelled and evaluated concurrently.

Traverse provides a type with the ability to traverse a structure with an effect.

Effect is a Monad that can suspend side effects into the context implementing it and supports lazy and potentially asynchronous evaluation.

MonadDefer is a Monad that provides the ability to delay the evaluation of a computation.

UsafeRun provides capabilities to run a computation unsafely, synchronous or asynchronously.

A Comonad is the dual of a Monad. It provides capabilities to compose functions that extract values from their context.

Implementations of this instance must obey the following laws:

extract(duplicate(fa)) == fa
map(fa, f) == coflatMap(fa, { a in f(extract(a)) }
coflatMap(fa, extract) == fa
extract(coflatMap(fa, f)) == f(fa)

An Alternative is an Applicative with MonoidK capabilities.

An Applicative Functor is a Functor that also provides functionality to lift pure expressions, and sequence computations and combine their results.

Instances of this typeclass must obey the following laws:

1. Identity

   ap(pure(id), v) == v
   

2. Composition

   ap(ap(ap(pure(compose), u), v), w) == compose(u, compose(v, w))
   

3. Homomorphism

   ap(pure(f), pure(x)) == pure(f(x))
   

4. Interchange

   ap(fa, pure(b)) == ap(pure({ x in x(a) }), fa)
   

An ApplicativeError is an Applicative that has capabilities to raise and handle error values.

It has an associated type E to represent the error type that the implementing instance is able to handle.

A Bimonad has the same capabilities as Monad and Comonad.

The ComonadEnv type class represents a Comonad that support a global environment that can be provided and transformed into a local environment.

The ComonadStore type class represents those Comonads that support local position information.

The ComonadTraced type class represents those comonads which support relative (monoidal) position information.

The ComonadTrans type class represents Comonad Transformers.

A Contravariant Functor is the dual of a Covariant Functor, usually referred to as just Functor. Whereas an intuition behind Covariant Functors is that they can be seen as containing or producing values, Contravariant Functors can be seen as consuming values.

Decidable is a typeclass modeling contravariant decision. Decidable is the contravariant version of Alternative.

Divide is a type class that models the divide part of divide and conquer.

Divisible extends Divide by providing an empty value.

EquatableK provides capabilities to check equality of values at the kind level.

Foldable describes types that have the ability to be folded to a summary value.

A FunctorFilter provides the same capabilities as a Functor, while filtering out elements simultaneously.

EquatableK provides capabilities to compute a hash value at the kind level.

An Invariant Functor provides a type the ability to transform its value type into another type. An instance of Functor or Contravariant are Invariant Functors as well.

A Monad provides functionality to sequence operations that are dependent from one another.

Instances of Monad must obey the following rules:

flatMap(pure(a), f) == f(a)
flatMap(fa, pure) == fa
flatMap(fa) { a in flatMap(f(a), g) } == flatMap(flatMap(fa, f), g)

Also, instances of Monad derive a default implementation for Applicative.ap as:

ap(ff, fa) == flapMap(ff, { f in map(fa, f) }

A MonadCombine has the capabilities of MonadFilter and Alternative together.

A MonadError has the same capabilities as a Monad and an ApplicativeError.

A MonadFilter is a Monad with FunctorFilter capabilities. It also provides functionality to create a value that represents an empty element in the context implementing an instance of this typeclass.

Implementing this typeclass automatically derives an implementation for FunctorFilter.mapFilter.

A MonadReader is a Monad with capabilities to read values from a shared environment.

A MonadState is a Monad that maintains a state.

A monad transformer makes a new monad out of an existing monad, such that computations of the old monad may be embedded in the new one.

A MonadWriter is a Monad with the ability to produce a stream of data in addition to the computed values.

A monoid is an algebraic structure that has the same properties as a semigroup, with an empty element.

A MonoidK is a SemigroupK that also has an empty element.

The Monoidal type class adds an identity element to Semigroupal type class by defining the function identity.

Identity returns a specific identity Kind<F, A> value for a given type F and A.

This type class complies with the following law: fa.product(identity) == identity.product(fa) == identity

In addition, the laws of Semigroupal type class also apply.

NonEmptyReducible defines a Reducible in terms of another type that has an instance of Foldable and a method that is able to split a structure of values in a first value and the rest of the values in the structure.

Reducible augments the functions provided by Foldable with reducing functions that do not need an initial value.

The Selective typeclass represents Selective Applicative Functors, described in this paper. Selective Applicative Functors enrich Applicative Functors by providing an operation that composes two effectful computations where the second depends on the first.

A semigroup is an algebraic structure that consists of a set of values and an associative operation.

SemigroupK is a Semigroup that operates on kinds with one type parameter.

The Semigroupal type class for a given type F can be seen as an abstraction over the cartesian product. It defines the function product.

The product function for a given type F, A and B combines a Kind<F, A> and a Kind<F, B> into a Kind<F, (A, B)>. This function guarantees compliance with the following laws:

Semigroupals are associative under the bijection f = (a,(b,c)) -> ((a,b),c) or f = ((a,b),c) -> (a,(b,c)). Therefore, the following laws also apply:

f((a.product(b)).product(c)) == a.product(b.product(c))

f(a.product(b.product(c))) == (a.product(b)).product(c)

A semiring is an algebraic structure that has the same properties as a commutative monoid for addition, with multiplication.

TraverseFilter represents array-like structures that can be traversed and filtered as a single combined operation. It provides the same capabilities as Traverse and FunctorFilter together.