yoneda

basic

class yoneda.basic.Maybe(data)

Bases: Monad, Generic[A]

__repr__()

String representation of monad.

Return type:

str

classmethod just(value)

Just constructor for Maybe class.

Parameters:

value (object) – Non-null value.

Returns:

Maybe monad of value.

Return type:

Maybe

classmethod nothing()

Nothing constructor for Maybe class.

Returns:

Nothing monad.

Return type:

Maybe

property state: str

State of monad. Either just or nothing.

class yoneda.basic.Try(data)

Bases: Monad, Generic[A]

__repr__()

String representation of monad.

Return type:

str

app(monad_func)

Applicative: M(A -> B) -> MB

Given a Monad of a function A to B, return a Monad of B (MB).

Parameters:

monad_func (Monad) – Monad of function (A -> B).

Returns:

Try Monad of B.

Return type:

Try[B]

bind(func)

Bind: (A -> MB) -> MB

Given a function A to MB, return a Monad of B (MB).

Parameters:

func (function) – Function (A -> MB).

Returns:

Try Monad of B.

Return type:

Try[B]

classmethod failure(error)

Success constructor for Try class.

Parameters:

error (Exception) – Error.

Returns:

Try monad of error.

Return type:

Maybe

fmap(func)

Functor map: (A -> B) -> MB

Given a function A to B, return a Monad of B (MB). Example: m.fmap(lambda x: x + 2)

Parameters:

func (function) – Function (A -> B).

Returns:

Try Monad of B.

Return type:

Try[B]

property state: str

State of monad. Either success or failure.

classmethod success(value)

Success constructor for Try class.

Parameters:

value (object) – Non-error value.

Returns:

Try monad of value.

Return type:

Maybe

monad

class yoneda.monad.C

Monad is a library containing the Monad class and a library of monadic functions it calls.

Haskell equivalence table:

Python		Haskell		Haskell Type Signature
prefix	infix	prefix	infix	implication	signature
app	│iapp│		<*>	Applicative f =>	f (a -> b) -> fa -> fb
bind	│ibind│		>>=	Monad m =>	m a -> (a -> m b) -> m b
fail	│ifail│	fail		Monad m =>	String -> m a
fmap	│ifmap│	fmap	<$>	Functor f =>	(a -> b) -> fa -> fb
right	│iright│		>>	Monad m =>	m a -> m b -> m b
unwrap				Monad m =>	m a -> a
wrap	│iwrap│	pure		Applicative f =>	a -> f a
wrap	│iwrap│	return		Monad m =>	a -> m a
curry	│icurry│
dot	│idot│	.	.		(b -> c) -> (a -> b) -> (a -> c)
partial_dot		.	.		(b -> c) -> (a -> b) -> (a -> c)

alias of TypeVar(‘C’)

class yoneda.monad.Monad(data)

Bases: Generic[A]

Monad is a generic base class for monads. It implements all the monad functions as methods which take itself as the first argument.

Haskell equivalence table:

Python		Haskell		Haskell Type Signature
prefix	infix	prefix	infix	implication	signature
app	^		<*>	Applicative f =>	f (a -> b) -> fa -> fb
bind	>>		>>=	Monad m =>	m a -> (a -> m b) -> m b
fail		fail		Monad m =>	String -> m a
fmap	&	fmap	<$>	Functor f =>	(a -> b) -> fa -> fb
right			>>	Monad m =>	m a -> m b -> m b
unwrap				Monad m =>	m a -> a
wrap		pure		Applicative f =>	a -> f a
wrap		return		Monad m =>	a -> m a

__and__(func)

Functor map: (A -> B) -> MB

Given a function A to B, return a Monad of B (MB). Example: m & (lambda x: x + 2)

Parameters:

func (function) – Function (A -> B).

Returns:

Monad of B.

Return type:

Monad[B]

__init__(data)

Constructs monad instance.

Parameters:

data (object) – Data to be wrapped with Monad.

__repr__()

String representation of Monad instance.

Return type:

str

__rshift__(func)

Bind: (A -> MB) -> MB

Given a function A to MB, return a Monad of B (MB). Example: m >> Monad

Parameters:

func (function) – Function (A -> MB).

Returns:

Monad of B.

Return type:

Monad[B]

__weakref__

list of weak references to the object

__xor__(monad_func)

Applicative: MA -> M(A -> B) -> MB

Given a Monad of A (MA) and a Monad of a function A to B, return a Monad of B (MB). Example: m ^ Monad.wrap(lambda x: x + 2)

Parameters:

• monad (Monad) – Monad of A.

• func (Monad) – Monad of function (A -> B).

Raises:

EnforceError – If monad is not Monad subclass or instance.

Returns:

Monad of B.

Return type:

Monad[B]

app(monad_func)

Applicative: M(A -> B) -> MB

Given a Monad of a function A to B, return a Monad of B (MB).

Parameters:

monad_func (Monad) – Monad of function (A -> B).

Returns:

Monad of B.

Return type:

Monad[B]

bind(func)

Bind: (A -> MB) -> MB

Given a function A to MB, return a Monad of B (MB).

Parameters:

func (function) – Function (A -> MB).

Returns:

Monad of B.

Return type:

Monad[B]

fail(error)

Fail: E -> ME

Return a Monad of given Exception.

Parameters:

error (Exception) – Error.

Returns:

Error Monad.

Return type:

Monad

fmap(func)

Functor map: (A -> B) -> MB

Given a function A to B, return a Monad of B (MB). Example: m.fmap(lambda x: x + 2)

Parameters:

func (function) – Function (A -> B).

Returns:

Monad of B.

Return type:

Monad[B]

right(monad)

Right: MB -> MB

Return given monad (self is left, given monad is right).

Parameters:

monad (Monad) – Right monad.

Returns:

Right Monad.

Return type:

Monad

unwrap()

Unwrap: () -> A

Return self._data.

Returns:

Monad data.

Return type:

A

classmethod wrap(data)

Wrap: A -> MA

Create a new Monad with given data.

Parameters:

data (Any) – Data to be wrapped as Monad.

Returns:

Monad of data.

Return type:

Monad[A]

yoneda.monad.app(monad_func, monad)

Applicative: M(A -> B) -> MA -> MB

Given a Monad of A (MA) and a Monad of a function A to B, return a Monad of B (MB).

Parameters:

• monad_func (Monad) – Monad of function (A -> B).

• monad (Monad) – Monad of A.

Raises:

• EnforceError – If monad_func is not instance of Monad.

• EnforceError – If monad is not Monad subclass or instance.

Returns:

Monad of B.

Return type:

Monad[B]

yoneda.monad.bind(func, monad)

Bind: (A -> MB) -> MA -> MB

Given a Monad of A (MA) and a function A to MB, return a Monad of B (MB).

Parameters:

• func (function) – Function (A -> MB).

• monad (Monad) – Monad of A.

Raises:

EnforceError – If monad is not Monad subclass or instance.

Returns:

Monad of B.

Return type:

Monad[B]

yoneda.monad.catch(monad, func)

Catch: MA -> (A -> B) -> (MB | ME)

Catches exception and returns it rather then raising an error.

Parameters:

• monad (Monad) – Monad.

• func (function) – Function to attempt.

Raises:

EnforceError – If monad is not Monad subclass or instance.

Returns:

Partial function with catch logic.

Return type:

object

yoneda.monad.curry(func, *args, **kwargs)

Infix notation for functools.partial.

Parameters:

• func (function) – Function to be curried.

• args (optional) – Arguments.

• kwargs (optional) – Keyword arguments.

Returns:

Curried function.

Return type:

function

yoneda.monad.dot(func_b, func_a)

Dot: (b -> c) -> (a -> b) -> (a -> c)

fb |idot| fa == fb(fa)

Composes two functions.

Example

` fa = lambda x: x + 'a' fb = lambda x: x + 'b' dot(fb, fa)('x') == 'xab' (fb | idot | fa)('x') == 'xab' `

Parameters:

• func_b (function) – Outer function.

• func_a (function) – Inner function.

Returns:

Function composition.

Return type:

partial

yoneda.monad.enforce_monad(item)

Enforces item being a Monad subclass or instance.

Parameters:

item (object) – Item to be tested.

Raises:

EnforceError – If item is not Monad subclass or instance.

Return type:

None

yoneda.monad.fail(monad, error)

Fail: M -> E -> ME

Given a Monad and Exception, return a Monad of that Exception.

Parameters:

• monad (Monad) – Monad to wrap error with.

• error (Exception) – Error.

Raises:

• EnforceError – If monad is not Monad subclass or instance.

• EnforceError – If error is not an instance of Exception.

Returns:

Error Monad.

Return type:

Monad

yoneda.monad.fmap(func, monad)

Functor map: (A -> B) -> MA -> MB

Given a Monad of A (MA) and a function A to B, return a Monad of B (MB).

Parameters:

• func (function) – Function (A -> B).

• monad (Monad) – Monad of A.

Raises:

EnforceError – If monad is not Monad subclass or instance.

Returns:

Monad of B.

Return type:

Monad[B]

yoneda.monad.partial_dot(func)

Partial Dot: (b -> c) -> (a -> b)

Partial version of dot function.

Example

` app = ym.app u = Monad(lambda x: x + 1) v = Monad(lambda x: x + 2) w = Monad(3) Monad(partial_dot) | iapp | u | iapp | v | iapp | w `

Parameters:

func (function) – Outer composition function.

Returns:

Function composition.

Return type:

partial

yoneda.monad.right(monad_a, monad_b)

Right: MA -> MB -> MB

Given two Monads, a and b, return the right Monad b.

Parameters:

• monad_a (Monad) – Left monad.

• monad_b (Monad) – Right monad.

Raises:

EnforceError – If monad is not Monad subclass or instance.

Returns:

Right Monad.

Return type:

Monad

yoneda.monad.succeed(monad, value)

Succed: M -> A -> MA

Given a Monad and a value, return a Monad of that value.

Parameters:

• monad (Monad) – Monad to wrap value with.

• value (object) – Value.

Raises:

• EnforceError – If monad is not Monad subclass or instance.

• EnforceError – If value is an instance of Exception.

Returns:

Monad of value.

Return type:

Monad

yoneda.monad.unwrap(monad)

Unwrap: MA -> A

Return the data of a given Monad instance.

Parameters:

monad (Monad) – Monad instance.

Raises:

EnforceError – If monad is not Monad subclass or instance.

Returns:

Monad data.

Return type:

A

yoneda.monad.wrap(monad, data)

Wrap: M -> A -> MA

Given a Monad class or instance, create a new Monad with given data.

Parameters:

• monad (Monad) – Monad class or instance.

• data (Any) – Data to be wrapped as Monad.

Raises:

EnforceError – If monad is not Monad subclass or instance.

Returns:

Monad of data.

Return type:

Monad[A]