method K<AF, Func<B,Func<C, Func<D, Func<E, Func<F, G>>>>>> apply <AF, A, B, C, D, E, F, G> (K<AF, Func<A, B, C, D, E, F, G>> mf, K<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, Func<E, Func<F, Func<G, H>>>>>>> apply <AF, A, B, C, D, E, F, G, H> (K<AF, Func<A, B, C, D, E, F, G, H>> mf, K<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, Func<E, Func<F, Func<G, Func<H, I>>>>>>>> apply <AF, A, B, C, D, E, F, G, H, I> (K<AF, Func<A, B, C, D, E, F, G, H, I>> mf, K<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, Func<E, Func<F, Func<G, Func<H, Func<I, J>>>>>>>>> apply <AF, A, B, C, D, E, F, G, H, I, J> (K<AF, Func<A, B, C, D, E, F, G, H, I, J>> mf, K<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, Func<E, Func<F, Func<G, Func<H, Func<I, Func<J, K>>>>>>>>>> apply <AF, A, B, C, D, E, F, G, H, I, J, K> (K<AF, Func<A, B, C, D, E, F, G, H, I, J, K>> mf, K<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, R> ( (K<AF, A>, K<AF, B>) items, Func<A, B, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, R> ( (K<AF, A>, K<AF, B>, K<AF, C>) items, Func<A, B, C, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, R> ( (K<AF, A>, K<AF, B>, K<AF, C>, K<AF, D>) items, Func<A, B, C, D, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, R> ( (K<AF, A>, K<AF, B>, K<AF, C>, K<AF, D>, K<AF, E>) items, Func<A, B, C, D, E, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, F, R> ( (K<AF, A>, K<AF, B>, K<AF, C>, K<AF, D>, K<AF, E>, K<AF, F>) items, Func<A, B, C, D, E, F, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, F, G, R> ( (K<AF, A>, K<AF, B>, K<AF, C>, K<AF, D>, K<AF, E>, K<AF, F>, K<AF, G>) items, Func<A, B, C, D, E, F, G, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, F, G, H, R> ( (K<AF, A>, K<AF, B>, K<AF, C>, K<AF, D>, K<AF, E>, K<AF, F>, K<AF, G>, K<AF, H>) items, Func<A, B, C, D, E, F, G, H, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, F, G, H, I, R> ( (K<AF, A>, K<AF, B>, K<AF, C>, K<AF, D>, K<AF, E>, K<AF, F>, K<AF, G>, K<AF, H>, K<AF, I>) items, Func<A, B, C, D, E, F, G, H, I, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, F, G, H, I, J, R> ( (K<AF, A>, K<AF, B>, K<AF, C>, K<AF, D>, K<AF, E>, K<AF, F>, K<AF, G>, K<AF, H>, K<AF, I>, K<AF, J>) items, Func<A, B, C, D, E, F, G, H, I, J, R> f) Source #

where AF : Applicative<AF>

class Applicative Source #

Methods

method K<M, R> applyM <M, A, B, R> ((K<M, A>, K<M, B>) items, Func<A, B, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, R> ((K<M, A>, K<M, B>, K<M, C>) items, Func<A, B, C, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, R> ((K<M, A>, K<M, B>, K<M, C>, K<M, D>) items, Func<A, B, C, D, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, R> ((K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>) items, Func<A, B, C, D, E, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, F, R> ((K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>, K<M, F>) items, Func<A, B, C, D, E, F, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, F, G, R> ((K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>, K<M, F>, K<M, G>) items, Func<A, B, C, D, E, F, G, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, F, G, H, R> ((K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>, K<M, F>, K<M, G>, K<M, H>) items, Func<A, B, C, D, E, F, G, H, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, F, G, H, I, R> ((K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>, K<M, F>, K<M, G>, K<M, H>, K<M, I>) items, Func<A, B, C, D, E, F, G, H, I, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, F, G, H, I, J, R> ((K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>, K<M, F>, K<M, G>, K<M, H>, K<M, I>, K<M, J>) items, Func<A, B, C, D, E, F, G, H, I, J, K<M, R>> f) Source #

where M : Monad<M>

class Applicative Source #

Methods

method K<F, A> add <NumA, F, A> (K<F, A> fa, K<F, A> fb) Source #

where F : Applicative<F>

where NumA : Num<A>

Sum the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> add <F, A> (K<F, A> fa, K<F, A> fb) Source #

where F : Applicative<F>

where A : IAdditionOperators<A, A, A>

Sum the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> subtract <NumA, F, A> (K<F, A> fa, K<F, A> fb) Source #

where F : Applicative<F>

where NumA : Arithmetic<A>

Subtract the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> subtract <F, A> (K<F, A> fa, K<F, A> fb) Source #

where F : Applicative<F>

where A : ISubtractionOperators<A, A, A>

Subtract the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> multiply <NumA, F, A> (K<F, A> fa, K<F, A> fb) Source #

where F : Applicative<F>

where NumA : Arithmetic<A>

Multiply the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> multiply <F, A> (K<F, A> fa, K<F, A> fb) Source #

where F : Applicative<F>

where A : IMultiplyOperators<A, A, A>

Multiply the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> divide <NumA, F, A> (K<F, A> fa, K<F, A> fb) Source #

where F : Applicative<F>

where NumA : Num<A>

Multiply the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> divide <F, A> (K<F, A> fa, K<F, A> fb) Source #

where F : Applicative<F>

where A : IDivisionOperators<A, A, A>

Multiply the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

class Applicative Source #

Methods

method K<F, A> pure <F, A> (A value) Source #

where F : Applicative<F>

method K<F, Unit> when <F> (bool flag, K<F, Unit> fx) Source #

where F : Applicative<F>

method K<F, Unit> unless <F> (bool flag, K<F, Unit> fx) Source #

where F : Applicative<F>

method K<F, A> between <F, A, OPEN, CLOSE> ( K<F, OPEN> open, K<F, CLOSE> close, K<F, A> p) Source #

where F : Applicative<F>

between(open, close, p) parses open, followed by pandclose`.

Parameters

type	A	Return value type
type	OPEN	OPEN value type
type	CLOSE	CLOSE value type
param	open	Open computation
param	close	Close computation
param	p	Between computation
returns	The value returned by `p`

method K<F, Seq<A>> replicate <F, A> (int count, K<F, A> fa) Source #

where F : Applicative<F>

Construct a sequence of count repetitions of fa

Parameters

type	A	Value type
param	count	Number of repetitions
param	fa	Applicative computation to run
returns	Applicative structure of `count` items

class Applicative Source #

Methods

method K<F, B> lift <F, A, B> (Func<A, B> f, K<F, A> fa) Source #

where F : Applicative<F>

method K<F, C> lift <F, A, B, C> (Func<A, B, C> f, K<F, A> fa, K<F, B> fb) Source #

where F : Applicative<F>

method K<F, C> lift <F, A, B, C> (Func<A, Func<B, C>> f, K<F, A> fa, K<F, B> fb) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, B, C, D> f, K<F, A> fa, K<F, B> fb, K<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, Func<B, Func<C, D>>> f, K<F, A> fa, K<F, B> fb, K<F, C> fc) Source #

where F : Applicative<F>

class Applicative Source #

Methods

method K<F, B> action <F, A ,B> (K<F, A> ma, Memo<F, B> mb) Source #

where F : Applicative<F>

method K<F, B> action <F, A ,B> (Memo<F, A> ma, Memo<F, B> mb) Source #

where F : Applicative<F>

method K<F, B> action <F, A ,B> (Memo<F, A> ma, K<F, B> mb) Source #

where F : Applicative<F>

class Applicative Source #

Methods

method K<AF, B> apply <AF, A, B> (K<AF, Func<A, B>> mf, Memo<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B, C>> apply <AF, A, B, C> (K<AF, Func<A, B, C>> mf, Memo<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, D>>> apply <AF, A, B, C, D> (K<AF, Func<A, B, C, D>> mf, Memo<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, E>>>> apply <AF, A, B, C, D, E> (K<AF, Func<A, B, C, D, E>> mf, Memo<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, Func<E, F>>>>> apply <AF, A, B, C, D, E, F> (K<AF, Func<A, B, C, D, E, F>> mf, Memo<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, Func<E, Func<F, G>>>>>> apply <AF, A, B, C, D, E, F, G> (K<AF, Func<A, B, C, D, E, F, G>> mf, Memo<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, Func<E, Func<F, Func<G, H>>>>>>> apply <AF, A, B, C, D, E, F, G, H> (K<AF, Func<A, B, C, D, E, F, G, H>> mf, Memo<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, Func<E, Func<F, Func<G, Func<H, I>>>>>>>> apply <AF, A, B, C, D, E, F, G, H, I> (K<AF, Func<A, B, C, D, E, F, G, H, I>> mf, Memo<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, Func<E, Func<F, Func<G, Func<H, Func<I, J>>>>>>>>> apply <AF, A, B, C, D, E, F, G, H, I, J> (K<AF, Func<A, B, C, D, E, F, G, H, I, J>> mf, Memo<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, Func<B,Func<C, Func<D, Func<E, Func<F, Func<G, Func<H, Func<I, Func<J, K>>>>>>>>>> apply <AF, A, B, C, D, E, F, G, H, I, J, K> (K<AF, Func<A, B, C, D, E, F, G, H, I, J, K>> mf, Memo<AF, A> ma) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, R> ( (Memo<AF, A>, Memo<AF, B>) items, Func<A, B, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, R> ( (Memo<AF, A>, Memo<AF, B>, Memo<AF, C>) items, Func<A, B, C, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, R> ( (Memo<AF, A>, Memo<AF, B>, Memo<AF, C>, Memo<AF, D>) items, Func<A, B, C, D, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, R> ( (Memo<AF, A>, Memo<AF, B>, Memo<AF, C>, Memo<AF, D>, Memo<AF, E>) items, Func<A, B, C, D, E, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, F, R> ( (Memo<AF, A>, Memo<AF, B>, Memo<AF, C>, Memo<AF, D>, Memo<AF, E>, Memo<AF, F>) items, Func<A, B, C, D, E, F, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, F, G, R> ( (Memo<AF, A>, Memo<AF, B>, Memo<AF, C>, Memo<AF, D>, Memo<AF, E>, Memo<AF, F>, Memo<AF, G>) items, Func<A, B, C, D, E, F, G, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, F, G, H, R> ( (Memo<AF, A>, Memo<AF, B>, Memo<AF, C>, Memo<AF, D>, Memo<AF, E>, Memo<AF, F>, Memo<AF, G>, Memo<AF, H>) items, Func<A, B, C, D, E, F, G, H, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, F, G, H, I, R> ( (Memo<AF, A>, Memo<AF, B>, Memo<AF, C>, Memo<AF, D>, Memo<AF, E>, Memo<AF, F>, Memo<AF, G>, Memo<AF, H>, Memo<AF, I>) items, Func<A, B, C, D, E, F, G, H, I, R> f) Source #

where AF : Applicative<AF>

method K<AF, R> apply <AF, A, B, C, D, E, F, G, H, I, J, R> ( (Memo<AF, A>, Memo<AF, B>, Memo<AF, C>, Memo<AF, D>, Memo<AF, E>, Memo<AF, F>, Memo<AF, G>, Memo<AF, H>, Memo<AF, I>, Memo<AF, J>) items, Func<A, B, C, D, E, F, G, H, I, J, R> f) Source #

where AF : Applicative<AF>

class Applicative Source #

Methods

method K<M, R> applyM <M, A, B, R> ((Memo<M, A>, Memo<M, B>) items, Func<A, B, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, R> ((Memo<M, A>, Memo<M, B>, Memo<M, C>) items, Func<A, B, C, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, R> ((Memo<M, A>, Memo<M, B>, Memo<M, C>, Memo<M, D>) items, Func<A, B, C, D, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, R> ( (Memo<M, A>, Memo<M, B>, Memo<M, C>, Memo<M, D>, Memo<M, E>) items, Func<A, B, C, D, E, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, F, R> ( (Memo<M, A>, Memo<M, B>, Memo<M, C>, Memo<M, D>, Memo<M, E>, Memo<M, F>) items, Func<A, B, C, D, E, F, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, F, G, R> ( (Memo<M, A>, Memo<M, B>, Memo<M, C>, Memo<M, D>, Memo<M, E>, Memo<M, F>, Memo<M, G>) items, Func<A, B, C, D, E, F, G, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, F, G, H, R> ( (Memo<M, A>, Memo<M, B>, Memo<M, C>, Memo<M, D>, Memo<M, E>, Memo<M, F>, Memo<M, G>, Memo<M, H>) items, Func<A, B, C, D, E, F, G, H, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, F, G, H, I, R> ( (Memo<M, A>, Memo<M, B>, Memo<M, C>, Memo<M, D>, Memo<M, E>, Memo<M, F>, Memo<M, G>, Memo<M, H>, Memo<M, I>) items, Func<A, B, C, D, E, F, G, H, I, K<M, R>> f) Source #

where M : Monad<M>

method K<M, R> applyM <M, A, B, C, D, E, F, G, H, I, J, R> ( (Memo<M, A>, Memo<M, B>, Memo<M, C>, Memo<M, D>, Memo<M, E>, Memo<M, F>, Memo<M, G>, Memo<M, H>, Memo<M, I>, Memo<M, J>) items, Func<A, B, C, D, E, F, G, H, I, J, K<M, R>> f) Source #

where M : Monad<M>

class Applicative Source #

Methods

method K<F, A> add <NumA, F, A> (Memo<F, A> fa, Memo<F, A> fb) Source #

where F : Applicative<F>

where NumA : Num<A>

Sum the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> add <F, A> (Memo<F, A> fa, Memo<F, A> fb) Source #

where F : Applicative<F>

where A : IAdditionOperators<A, A, A>

Sum the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> subtract <NumA, F, A> (Memo<F, A> fa, Memo<F, A> fb) Source #

where F : Applicative<F>

where NumA : Arithmetic<A>

Subtract the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> subtract <F, A> (Memo<F, A> fa, Memo<F, A> fb) Source #

where F : Applicative<F>

where A : ISubtractionOperators<A, A, A>

Subtract the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> multiply <NumA, F, A> (Memo<F, A> fa, Memo<F, A> fb) Source #

where F : Applicative<F>

where NumA : Arithmetic<A>

Multiply the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> multiply <F, A> (Memo<F, A> fa, Memo<F, A> fb) Source #

where F : Applicative<F>

where A : IMultiplyOperators<A, A, A>

Multiply the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> divide <NumA, F, A> (Memo<F, A> fa, Memo<F, A> fb) Source #

where F : Applicative<F>

where NumA : Num<A>

Multiply the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

method K<F, A> divide <F, A> (Memo<F, A> fa, Memo<F, A> fb) Source #

where F : Applicative<F>

where A : IDivisionOperators<A, A, A>

Multiply the bound values of the applicative structures provided

Parameters

type	NumA	Num of A
type	A	Bound value type
param	fx	Left hand side of the operation
param	fy	Right hand side of the operation
returns	An applicative structure with the arithmetic operation applied to the bound values.

class Applicative Source #

Methods

method K<F, B> lift <F, A, B> (Func<A, B> f, Memo<F, A> fa) Source #

where F : Applicative<F>

method K<F, C> lift <F, A, B, C> (Func<A, B, C> f, Memo<F, A> fa, Memo<F, B> fb) Source #

where F : Applicative<F>

method K<F, C> lift <F, A, B, C> (Func<A, B, C> f, K<F, A> fa, Memo<F, B> fb) Source #

where F : Applicative<F>

method K<F, C> lift <F, A, B, C> (Func<A, Func<B, C>> f, Memo<F, A> fa, Memo<F, B> fb) Source #

where F : Applicative<F>

method K<F, C> lift <F, A, B, C> (Func<A, Func<B, C>> f, K<F, A> fa, Memo<F, B> fb) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, B, C, D> f, Memo<F, A> fa, Memo<F, B> fb, Memo<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, B, C, D> f, K<F, A> fa, Memo<F, B> fb, Memo<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, B, C, D> f, Memo<F, A> fa, K<F, B> fb, Memo<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, B, C, D> f, Memo<F, A> fa, Memo<F, B> fb, K<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, B, C, D> f, K<F, A> fa, K<F, B> fb, Memo<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, B, C, D> f, Memo<F, A> fa, K<F, B> fb, K<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, Func<B, Func<C, D>>> f, Memo<F, A> fa, Memo<F, B> fb, Memo<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, Func<B, Func<C, D>>> f, K<F, A> fa, Memo<F, B> fb, Memo<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, Func<B, Func<C, D>>> f, Memo<F, A> fa, K<F, B> fb, Memo<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, Func<B, Func<C, D>>> f, Memo<F, A> fa, Memo<F, B> fb, K<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, Func<B, Func<C, D>>> f, K<F, A> fa, K<F, B> fb, Memo<F, C> fc) Source #

where F : Applicative<F>

method K<F, D> lift <F, A, B, C, D> (Func<A, Func<B, Func<C, D>>> f, Memo<F, A> fa, K<F, B> fb, K<F, C> fc) Source #

where F : Applicative<F>

class Applicative Source #

Methods

method K<F, (A First, B Second)> zip <F, A, B> ((K<F, A> First, K<F, B> Second) tuple) Source #

where F : Applicative<F>

Zips applicatives into a tuple

Parameters

type	F	Applicative trait type
type	A	First applicative's bound value type
type	B	Second applicative's bound value type
param	tuple	Tuple of applicatives to run
returns	Zipped applicative

method K<F, (A First, B Second, C Third)> zip <F, A, B, C> ((K<F, A> First, K<F, B> Second, K<F, C> Third) tuple) Source #

where F : Applicative<F>

Zips applicatives into a tuple

Parameters

type	F	Applicative trait type
type	A	First applicative's bound value type
type	B	Second applicative's bound value type
type	C	Third applicative's bound value type
param	tuple	Tuple of applicatives to run
returns	Zipped applicative

method K<F, (A First, B Second, C Third, D Fourth)> zip <F, A, B, C, D> ((K<F, A> First, K<F, B> Second, K<F, C> Third, K<F, D> Fourth) tuple) Source #

where F : Applicative<F>

Zips applicatives into a tuple

Parameters

type	F	Applicative trait type
type	A	First applicative's bound value type
type	B	Second applicative's bound value type
type	C	Third applicative's bound value type
type	D	Fourth applicative's bound value type
param	tuple	Tuple of applicatives to run
returns	Zipped applicative

method K<F, (A First, B Second, C Third, D Fourth, E Fifth)> zip <F, A, B, C, D, E> ((K<F, A> First, K<F, B> Second, K<F, C> Third, K<F, D> Fourth, K<F, E> Fifth) tuple) Source #

where F : Applicative<F>

Zips applicatives into a tuple

Parameters

type	F	Applicative trait type
type	A	First applicative's bound value type
type	B	Second applicative's bound value type
type	C	Third applicative's bound value type
type	D	Fourth applicative's bound value type
param	tuple	Tuple of applicatives to run
returns	Zipped applicative

method K<F, (A First, B Second)> zip <F, A, B> (K<F, A> First, K<F, B> Second) Source #

where F : Applicative<F>

Zips applicatives into a tuple

Parameters

type	B	Second applicative's bound value type
type	F	Applicative trait type
type	A	First applicative's bound value type
param	Second	Second applicative
param	First	First applicative
returns	Zipped applicative

method K<F, (A First, B Second, C Third)> zip <F, A, B, C> (K<F, A> First, K<F, B> Second, K<F, C> Third) Source #

where F : Applicative<F>

Zips applicatives into a tuple

Parameters

type	B	Second applicative's bound value type
type	C	Third applicative's bound value type
type	F	Applicative trait type
type	A	First applicative's bound value type
param	Second	Second applicative
param	Third	Third applicative
param	First	First applicative
returns	Zipped applicative

method K<F, (A First, B Second, C Third, D Fourth)> zip <F, A, B, C, D> (K<F, A> First, K<F, B> Second, K<F, C> Third, K<F, D> Fourth) Source #

where F : Applicative<F>

Zips applicatives into a tuple

Parameters

type	B	Second applicative's bound value type
type	C	Third applicative's bound value type
type	D	Fourth applicative's bound value type
type	F	Applicative trait type
type	A	First applicative's bound value type
param	Second	Second applicative
param	Third	Third applicative
param	Fourth	Fourth applicative
param	First	First applicative
returns	Zipped applicative

method K<F, (A First, B Second, C Third, D Fourth, E Fifth)> zip <F, A, B, C, D, E> (K<F, A> First, K<F, B> Second, K<F, C> Third, K<F, D> Fourth, K<F, E> Fifth) Source #

where F : Applicative<F>

Zips applicatives into a tuple

Parameters

type	B	Second applicative's bound value type
type	C	Third applicative's bound value type
type	D	Fourth applicative's bound value type
type	F	Applicative trait type
type	A	First applicative's bound value type
param	Second	Second applicative
param	Third	Third applicative
param	Fourth	Fourth applicative
param	Fifth	Fifth applicative
param	First	First applicative
returns	Zipped applicative