type	A	Initial bound value type
type	B	Intermediate bound value type
type	C	Target bound value type
param	bind	Monadic bind function
param	project	Projection function
returns	M

method K<M, C> SelectMany <M, A, B, C> ( this K<M, A> ma, Func<A, Pure> bind, Func<A, B, C> project) Source #

where M : Functor<M>

Monad bind operation

Parameters

type	A	Initial bound value type
type	B	Intermediate bound value type
type	C	Target bound value type
param	bind	Monadic bind function
param	project	Projection function
returns	M

method K<M, C> SelectMany <M, A, B, C> ( this K<M, A> ma, Func<A, K<IO, B>> bind, Func<A, B, C> project) Source #

where M : Monad<M>

Monad bind operation

Parameters

type	A	Initial bound value type
type	B	Intermediate bound value type
type	C	Target bound value type
param	bind	Monadic bind function
param	project	Projection function
returns	M

method K<M, A> Flatten <M, A> (this K<M, K<M, A>> mma) Source #

where M : Monad<M>

Monadic join operation

Parameters

type	M	Monad trait
type	A	Bound value type
param	mma
returns	Joined monad

class MonadExtensions Source #

Monad module

Methods

method K<M, K<N, B>> BindT <M, N, A, B> (this K<M, K<N, A>> mna, Func<A, K<N, B>> f) Source #

where M : Functor<M>

where N : Monad<N>

Runs a monadic bind operation on the nested monads

If you're working with an inner monad that is concrete then you will first need to call KindT to cast the monad to a more general K version. This enables the T variant extensions (like BindT, `MapT, etc.) to work without providing excessive generic arguments all the way down the chain.

Parameters

type	M	Outer monad trait
type	N	Inner monad trait
type	A	Input bound value
type	B	Output bound value
param	mna	Nested monadic value
param	f	Bind function
returns	Mapped value

Examples

var mx = Seq<Option>(Some(1), Some(2), Some(3));

var ma = mx.KindT<Seq, Option, Option, int>() .BindT(a => Some(a + 1)) .MapT(a => a + 1); .AsT<Seq, Option, Option, int>();

method K<M, K<N, B>> BindT <M, N, A, B> (this K<M, K<N, A>> mna, Func<A, K<M, K<N, B>>> f) Source #

where M : Monad<M>

where N : Monad<N>, Traversable<N>

Runs a monadic bind operation on the nested monads

If you're working with an inner monad that is concrete then you will first need to call KindT to cast the monad to a more general K version. This enables the T variant extensions (like BindT, `MapT, etc.) to work without providing excessive generic arguments all the way down the chain.

Parameters

type	M	Outer monad trait
type	N	Inner monad trait
type	A	Input bound value
type	B	Output bound value
param	mna	Nested monadic value
param	f	Bind function
returns	Mapped value

Examples

var mx = Seq<Option>(Some(1), Some(2), Some(3));

var ma = mx.KindT<Seq, Option, Option, int>() .BindT(a => Seq(Some(a + 1))) .MapT(a => a + 1); .AsT<Seq, Option, Option, int>();

class Monad Source #

Monad module

Methods

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

where M : Monad<M>

method K<M, A> flatten <M, A> (K<M, K<M, A>> mma) Source #

where M : Monad<M>

method K<M, B> bind <M, A, B> (K<M, A> ma, Func<A, K<M, B>> f) Source #

where M : Monad<M>

method MB bind <M, MB, A, B> (K<M, A> ma, Func<A, MB> f) Source #

where MB : K<M, B>

where M : Monad<M>

interface Monad <M> Source #

where M : Monad<M>

Monad trait

Parameters

type

M

Self referring trait

Methods

method K<M, B> Bind <A, B> (K<M, A> ma, Func<A, K<M, B>> f) Source #

method K<M, A> Flatten <A> (K<M, K<M, A>> mma) Source #

method K<M, B> Map <A, B> (Func<A, B> f, K<M, A> ma) Source #

method K<M, A> LiftIO <A> (IO<A> ma) Source #

Lifts the IO monad into a monad transformer stack.

If this method isn't overloaded in the inner monad or any monad in the stack on the way to the inner monad then it will throw an exception.

This isn't ideal - however it appears to be the only way to achieve this kind of functionality in C# without resorting to magic.

Parameters

type	A	Bound value type
param	ma	IO computation to lift
returns	The outer monad with the IO monad lifted into it

method K<M, Func<K<M, A>, IO<A>>> UnliftIO <A> () Source #

Unlifts the IO monad from the monad transformer stack.

If the WithRunInIO method isn't overloaded in the inner monad or any monad in the stack on the way to the inner monad then it will throw an exception.

This isn't ideal - however it appears to be the only way to achieve this kind of functionality in C# without resorting to magic.

Parameters

type	A	Bound value type
returns	The outer monad with the IO monad lifted into it

method K<M, B> WithRunInIO <A, B> (Func<Func<K<M, A>, IO<A>>, IO> inner) Source #

Unlifts the IO monad from the monad transformer stack.

If this method isn't overloaded in the inner monad or any monad in the stack on the way to the inner monad then it will throw an exception.

This isn't ideal - however it appears to be the only way to achieve this kind of functionality in C# without resorting to magic.

Parameters

type	A	Bound value type
param	mma	IO computation to lift
returns	The outer monad with the IO monad lifted into it

class MonadIO Source #

Monad module

Methods

method K<M, A> liftIO <M, A> (IO<A> ma) Source #

where M : Monad<M>

Embeds the IO monad into the M<A> monad. NOTE: This will fail if the monad transformer stack doesn't have an IO monad as its inner-most monad.

method K<M, Func<K<M, A>, IO<A>>> unliftIO <M, A> () Source #

where M : Monad<M>

Unlifts the IO monad from the monad transformer stack.

If the WithRunInIO method isn't overloaded in the inner monad or any monad in the stack on the way to the inner monad then it will throw an exception.

This isn't ideal - however it appears to be the only way to achieve this kind of functionality in C# without resorting to magic.

Parameters

type	A	Bound value type
returns	The outer monad with the IO monad lifted into it

method K<M, B> withRunInIO <M, A, B> (Func<Func<K<M, A>, IO<A>>, IO> inner) Source #

where M : Monad<M>

Unlifts the IO monad from the monad transformer stack.

If the WithRunInIO method isn't overloaded in the inner monad or any monad in the stack on the way to the inner monad then it will throw an exception.

This isn't ideal - however it appears to be the only way to achieve this kind of functionality in C# without resorting to magic.

Parameters

type	A	Bound value type
param	mma	IO computation to lift
returns	The outer monad with the IO monad lifted into it

method K<M, IO<A>> toIO <M, A> (K<M, A> ma) Source #

where M : Monad<M>

Convert an action in M to an action in IO.

Parameters

type	M
type	A
param	ma
returns