Classes

An AffineTraversal is an optic that allows to see into a structure and getting, setting or modifying an optional focus.

A (polymorphic) PAffineTraversal is useful when setting or modifying a value for a type with an optional polymorphic focus.

A PAffineTraversal can be seen as a weaker Lens and Prism and combines their weakest functions: - set meaning we can focus into an S and set a value B for a target A and obtain a modified source T. - getOrModify meaning it returns the focus of a PAffineTraversal (if present) or the original value.

Type parameters: - S: Source. - T: Modified source. - A: Focus. - B: Modified focus.

A BoundSetter is a Setter that is already bound to a concrete source.

A Getter is an optic that allows to see into a structure and getting a focus.

It can be seen as a function (S) -> A meaning that we can look into an S and get an A.

Parameters: - S: source of the Getter. - A: focus of the Getter.

A Fold is an optic that allows to focus into a structure and get multiple results.

Fold is a generalization of an instance of Foldable and it is implemented in terms of foldMap.

Type parameters: - S: Source. - A: Focus.

Simulates a Higher-Kinded Type in Swift with 1 type argument.

This class simulates Higher-Kinded Type support in Swift. Kind<F, A> is an alias for F<A>, which is not syntactically valid in Swift. Classes that want to have HKT support must extend this class. Type parameter F is reserved for a witness to prevent circular references in the inheritance relationship. By convention, witnesses are named like the class they represent, with the prefix For. As an example:

class ForOption {}
class Option<A>: Kind<ForOption, A> {}

StateT transformer represents operations that need to write and read a state through a computation or effect.

Some computations may not require the full power of this transformer: - For read-only state, see ReaderT / Kleisli. - To accumulate a value without using it on the way, see WriterT.

Witness for the StateT<F, S, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the StateT type constructor, omitting the last type argument.

ArrayK is a Higher Kinded Type wrapper over Swift arrays.

Witness for the ArrayK<A> data type. To be used in simulated Higher Kinded Types.

Constant data type. Represents a container of two types, holding a value of the left type that remains constant, regardless of the transformation applied to it.

Witness for the Const<A, T> data type. To be used in simulated Higher Kinded Types.

Partial application of the Const type constructor, omitting the last parameter.

EitherK is a sum type for kinds. Represents a type where you can hold either a Kind<F, A> or a Kind<G, A>.

Witness for the EitherK<F, G, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the EitherK type constructor, omitting the last parameter.

Sum type of types A and B. Represents a value of either one of those types, but not both at the same time. Values of type A are called left; values of type B are called right.

Witness for the Either<A, B> data type. To be used in simulated Higher Kinded Types.

Partial application of the Either type constructor, omitting the last parameter.

The identity data type represents a context of having no effect on the type it wraps. A instance of Id<A> is isomorphic to an instance of A; it is just wrapped without any additional information.

Witness for the Id<A> data type. To be used in simulated Higher Kinded Types.

Ior represents an inclusive-or of two different types. It may have a value of the left type, the right type or both at the same time.

Witness for the Ior<A, B> data type. To be used in simulated Higher Kinded Types.

Partial application of the Ior type constructor, omitting the last parameter.

A NonEmptyArray is an array of elements that guarantees to have at least one element.

Witness for the NonEmptyArray<A> data type. To be used in simulated Higher Kinded Types.

Represents optional values. Instances of this type may represent the presence of a value (some) or absence of it (none). This type is isomorphic to native Swift Optional<A> (usually written A?), with the addition of behaving as a Higher Kinded Type.

Witness for the Option<A> data type. To be used in simulated Higher Kinded Types.

Describes the result of an operation that may have thrown errors or succeeded. The type parameter corresponds to the result type of the operation.

Witness for the Try<A> data type. To be used in simulated Higher Kinded Types.

Validated is a data type to represent valid and invalid values. It is similar to Either, but with error accumulation in the invalid case.

Witness for the Validated<E, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the Validated type constructor, ommitting the last parameter.

An Iso is a loss less invertible optic that defines an isomorphism between a type S and A.

A polimorphic PIso is useful when setting or modifying a value for a constructed type; e.g. PIso<<Option<Int>, Option<String>, Int?, String?>.

• S: Source of a PIso.
• T: Modified source of a PIso.
• A: Focus of a PIso.
• B: Modified target of a PIso.

A Lens (or Functional Reference) is an optic that can focus into a structure for getting, setting or modifying the focus (target).

A (polymorphic) PLens is useful when setting or modifying a value for a constructed type.

A PLens can be seen as a pair of functions: - get: (S) -> A meaning we can focus into S and extract an A. - set: (B, S) -> T meaning we can focus into an S and set a value B for a target A and obtain a modified source.

The type arguments are: - S is the source of a PLens. - T is the modified source of a PLens. - A is the focus of a PLens. - B is the modified focus of a PLens.

A Prism is a loss less invertible optic that can look into a structure and optionally find its focus. It is mostly used for finding a focus that is only present under certain conditions, like in a sum type.

A (polymorphic) PPrism is useful when setting or modifying a value for a polymorphic sum type.

A PPrism gathres the two concepts of pattern matching and constructor and thus can be seen as a pair of functions: - getOrModify meaning it returns the focus of a PPRism or the original value. - reverseGet meaining we can construct the source type of a PPrism from a focus.

Type parameters: - S: Source. - T: Modified source. - A: Focus. - B: Modified focus.

A Setter is an optic that allows to see into a structure and set or modify its focus.

A (polymorphic) PSetter is useful when setting or modifying a value for a constructed type.

A PSetter is a generalization of a Functor.

Parameters: - S: Source of the PSetter. - T: Modified source of the PSetter. - A: Focus of the PSetter. - B: Modified focus of the PSetter.

A Traversal is an optic that allows to see into a structure with 0 to N foci.

Traversal is a generalization of Traverse and can be seen as a representation of modifyF. All methods are written in terms of modifyF.

Type parameters: - S: Source. - T: Modified source. - A: Focus. - B: Modified focus.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Witness for the Coproduct10 data type. To be used in simulated Higher Kinded Types.

Represents a sum type of 10 different types.

Witness for the Coproduct2 data type. To be used in simulated Higher Kinded Types.

Represents a sum type of 2 different types.

Witness for the Coproduct3 data type. To be used in simulated Higher Kinded Types.

Represents a sum type of 3 different types.

Witness for the Coproduct4 data type. To be used in simulated Higher Kinded Types.

Represents a sum type of 4 different types.

Witness for the Coproduct5 data type. To be used in simulated Higher Kinded Types.

Represents a sum type of 5 different types.

Witness for the Coproduct6 data type. To be used in simulated Higher Kinded Types.

Represents a sum type of 6 different types.

Witness for the Coproduct7 data type. To be used in simulated Higher Kinded Types.

Represents a sum type of 7 different types.

Witness for the Coproduct8 data type. To be used in simulated Higher Kinded Types.

Represents a sum type of 8 different types.

Witness for the Coproduct9 data type. To be used in simulated Higher Kinded Types.

Represents a sum type of 9 different types.

Undocumented

Undocumented

Undocumented

Witness for the Cofree data type. To be used in simulated Higher Kinded Types.

Partial application of the Cofree type constructor, omitting the last parameter.

Cofree is a type that, given any Functor, is able to provide a Comonad instance, that can be interpreted into a more restrictive one.

Witness for the Free<F, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the Free type constructor, omitting the last parameter.

Free is a type that, given any Functor, is able to provide a Monad instance, that can be interpreted into a more restrictive one.

A transformation between two kinds.

As Function1<A, B> represents a transformation from A to B, FunctionK<F, G> represents a transformation from Kind<F, A> to Kind<G, A>. Subclasses of FunctionK need to implement invoke.

Witness for the Program<F, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the Program type constructor, omitting the last parameter.

Program is a type that, given any type constructor, is able to provide a Monad instance, that can be interpreted into a more restrictive one.

As opposed to Free, Program does not require F to be a functor, which means that evaluation of map calls are deferred and left for the later interpretation in another monad.

An atomically modifiable reference to a value

Kleisli represents a function with the signature (D) -> Kind<F, A>.

Partial application of the Kleisli type constructor, omitting the last parameter.

Witness for the Kleisli<F, D, A> data type. To be used in simulated Higher Kinded Types.

Witness for the IO<E, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the IO type constructor, omitting the last parameters.

An IO is a data type that encapsulates and suspends side effects producing values of type A or errors of type E.

Ref is an asynchronous, concurrent mutable reference in the context of F holding a value of type A. Provides safe concurrent access and modification of its content. Refis a purely functional wrapper over an Atomic<A> in context F that is always initialized to a value.

Witness for the Resource<F, A> type. To be used in simulated Higher Data Types.

Partial application of the Resource type constructor, omitting the last parameter.

Resource models resource allocation and releasing. It is specially useful when multiple resources that depend on each other need to be acquired and later released in reverse order. Whn a resource is created, one can make use of the use method to run a computation with the resource. The finalizers are guaranteed to run afterwards in reverse order of acquisition.

A stateful, effectful and recurring schedule of actions.

A schedule consumes values of type A and based on its internal state of type State, decides to continue or stop. Every decision has a delay and an output of type B.

Witness for the MaybeK<A> data type. To be used in simulated Higher Kinded Types.

MaybeK is a Higher Kinded Type wrapper over RxSwift’s Maybe data type.

Witness for the ObservableK<A> data type. To be used in simulated Higher Kinded Types.

ObservableK is a Higher Kinded Type wrapper over RxSwift’s Observable data type.

Witness for the SingleK<A> data type. To be used in simulated Higher Kinded Types.

SingleK is a Higher Kinded Type wrapper over RxSwift’s SingleK data type.

Witness for the Cokleisli<F, A, B> data type. To be used in simulated Higher Kinded Types.

Partial application of the Cokleisli type constructor, omitting the last parameter.

Cokleisli represents a function with the signature (Kind<F, A>) -> B.

CokleisliK represents a function with the signature (Kind<F, A>) -> B that is polymorphic on A, where F and B are fixed. Subclasses of CokleisliK need to implement invoke.

Witness for the Function0<A> data type. To be used in simulated Higher Kinded Types.

This data type acts as a wrapper over functions that receive no input and produce a value; namely, constant functions. This wrapper gives these functions capabilities to be used as a Higher Kinded Type and conform to typeclasses that have this requirement.

Witness for the Function1<I, O> data type. To be used in simulated Higher Kinded Types`.

Partial application of the Function1 type constructor, omitting the last parameter.

This data type acts as a wrapper over functions. It receives two type parameters representing the input and output type of the function. The wrapper adds capabilities to use a function as a Higher Kinded Type and conform to typeclasses that have this requirement.

Witness for the LazyFunction1<I, O> data type. To be used in simulated Higher Kinded Types`.

Partial application of the LazyFunction1 type constructor, omitting the last parameter.

This data type acts as a wrapper over functions, like Function1. As opposed to Function1, function composition is stack-safe. This means that no matter how many LazyFunction1s you compose, calling their composition won’t cause a stack overflow.

Witness for the CoT<W, M, A> data type. To be used in simulated Higher Kinded Types

Partial application of the CoT type constructor, omitting the last parameter.

CoT gives you the best pairing monad transformer for any Comonad W In other words, an explorer for the state space given by W. It can also provide: - A MonadReader from a ComonadEnv - A MonadWriter from a ComonadTraced - A MonadState from a ComonadStore

Coreader is a special case of CoreaderT / Cokleisli where F is Id, so it is equivalent to functions (A) -> B.

Witness for the Coyoneda data type. To be used in simulated Higher Kinded Types.

Partial application of the Coyoneda type constructor, omitting the last parameter.

This type implements the dual version of the Yoneda lemma, stating that F is naturally isomorphic to Coyoneda.

Coyoneda can be viewed as the arguments that we need for the map function.

Witness for the Day<F, G, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the Day type constructor, omitting the last parameter.

Day convolution of two Functors. It can be seen as the suspended version of a Pairing between Functors F and G, applied to specific values.

Witness for the DictionaryK<K, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the DictionaryK type constructor, omitting the last parameter.

DictionaryK is a Higher Kinded Type wrapper over Swift dictionaries.

Witness for the Endo<A> data type. To be used in simulated Higher Kinded Types.

Endo represents an Endomorphism; i.e., a function where the input and output type is the same.

Witness for the Eval<A> data type. To be used in simulated Higher Kinded Types.

Eval is a data type that describes a potentially lazy computation that produces a value.

Eval has three different evaluation strategies: - Now: the computation is evaluated immediately. - Later: the computation is evaluated when it is needed (typically by calling Eval.value()), just once. This value is cached, so subsequent invocations do not trigger additional computations of the value. - Always: the computation is evaluated every time it is needed (typically by calling Eval.value()).

Now is an eager evaluation strategy, whereas Later and Always are lazy.

Encodes the notion of existential type. Exists<F> is a wrapper around a Kind<F, X> value, where X is some type that is not exposed on Exists signature.

You provide a value of type Kind<F, X> when constructing an Exists<F>instance but the specific type X that you provide is hidden inside Exists. The only way to interact with the content of Exists<F> is with a function of type Kind<F, X> -> R that is polymorphic on X (represented by the CokleisliK<F, R class). You pass a CokleisliK<F, R> to an Exists<F> and the function is called with the specific type that is hidden inside the Exists. This is done with the run method.

Witness for the Moore<E, V> data type. To be used in simulated Higher Kinded Types.

Partial application of the Moore type constructor, omitting the last parameter.

Moore represents Moore machines that hold values of type V and handle inputs of type E.

Witness for the PairK<F, G, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the PairK type constructor, omitting the last parameter.

PairK is a product type for kinds. Represents a type where you hold both a Kind<F, A> and a Kind<G, A>.

Witness for the Pairing<F, G> data type. To be used in simulated Higher Kinded Types.

Partial application of the Pairing type constructor, omitting the last parameter.

The Pairing type represents a relationship between Functors F and G, where the sums in one can annihilate the products in the other.

The internals of this type embed a function of the following shape: forall a b c. f a -> g b -> (a -> b -> c) -> c Or equivalently: forall a b. f (a -> b) -> g a -> b

Swift lacks universal quantifiers, so these types are replaced by Any.

Witness for the SetK<A> data type. To be used in simulated Higher Kinded Types.

An unordered collection of unique elements, wrapped to act as a Higher Kinded Type.

Witness for the Sum<F, G, V> data type. To be used in simulated Higher Kinded Types.

Partial application of the Sum type constructor, omitting the last parameter.

The Sum type models a Comonad that contains two different Comonadic values, where only one of them can be selected at a given moment.

Witness for the Trampoline<A> data type. To be used in simulated Higher Kinded Types.

The Trampoline type helps us overcome stack safety issues of recursive calls by transforming them into loops.

Witness for the Tree<A> data type. To be used in simulated Higher Kinded Types.

Tree represents a non-empty tree that allows node to have an arbitrary number of children.

The Foldable instance walks through the tree in depth-first order.

Witness for the Yoneda data type. To be used in simulated Higher Kinded Types.

Partial application of the Yoneda type constructor, omitting the last parameter.

This type implements the covariant form of the Yoneda lemma, stating that F is naturally isomorphic to Yoneda.

Yoneda can be viewed as the partial application of the map function, where the first argument is fixed:

map :: (F<A>, (A) -> B) -> F<B> Yoneda :: ((A) -> B) -> F<B>

Witness for the Zipper<A> data type. To be used in simulated Higher Kinded Types.

A Zipper is an array of elements focused on a specific element, which lets us move the focus around the array, and retrieve the elements to the left and right of the focus.

Undocumented

Undocumented

Wrapper class to represent a constant present first option.

Wrapper class to represent a constant present last option.

Witness for the EitherT<F, A, B> data type. To be used in simulated Higher Kinded Types.

Partial application of the EitherT type constructor, omitting the last parameter.

The EitherT transformer represents the nesting of an Either value inside any other effect. It is equivalent to Kind<F, Either<A, B>>.

Witness for the EnvT<E, W, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the EnvT type constructor, omitting the last parameter.

The environment Comonad Transformer. This Comonad Transformer extends the context of a value in the base Comonad with a global environment.

Witness for the OptionT<F, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the OptionT type constructor, omitting the last parameter.

The OptionT transformer represents the nesting of an Option value inside any other effect. It is equivalent to Kind<F, Option<A>>.

Witness for the StoreT<S, W, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the StoreT type constructor, omitting the last parameter.

The Store Comonad Transformer. This Comonad Transformer extends the context of a value in the base Comonad so that it depends on a position of the type of the state.

Witness for the TracedT<M, W, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the TracedT type constructor, omitting the last parameter.

The cowriter Comonad Transformer. This Comonad Transformer extends the context of a value in the base Comonad so that the value depends on a monoidal position.

Witness for the WriterT<F, W, A> data type. To be used in simulated Higher Kinded Types.

Partial application of the WriterT type constructor, omitting the last parameter.

WriterT transformer represents operations that accumulate values through a computation or effect, without reading them.

A binding expression is one of the instructions of the form x <- fx in a monad comprehension.

In a binding expression of the form x <- fx, x is the variable to be bound and fx is the monadic effect that we want to bind to the variable.

A bound variable is a variable to be used in a monad comprehesion to bind the produced values by a monadic effect.