haskpy.typeclasses.applicative.Applicative

Applicative

class Applicative

Bases: Apply

Applicative functor typeclass.

Minimal complete definition:

pure | (apply | apply_to)

The required Functor methods are given defaults based on the required Applicative methods, so you don’t need to implement map method.

References

__lshift__(x)

Sequence with << similarly as with <* and << in Haskell

__matmul__(x)

Application operand @ applies similarly as <*> in Haskell

f @ x translates to f.apply_to(x), x.apply(f) and apply(f, x).

Why @ operator?

  • It’s not typically used as often as some other more common operators so less risk for confusion.

  • The operator is not a commutative as isn’t apply either.

  • If we see matrix as some structure, then matrix multiplication takes both left and right operand inside this structure and gives a result also inside this structure, similarly as apply does. So it’s an operator for two operands having a similar structure.

  • The operator evaluates the contained function(s) at the contained value(s). Thus, f “at” x makes perfect sense.

__rpow__(f)

Lifting operator ** lifts similarly as <$> in Haskell

f ** x translates to x.map(f) and map(f, x).

Why ** operator?

  • It’s not typically used as often as multiplication or addition so less risk of confusion.

  • It’s not commutative operator as isn’t lifting either.

  • The two operands have very different roles. They are not at the same “level”.

  • The right operand is “higher”, that is, it’s inside a structure and the left operand is kind of “raised to the power” of the second operand, where the “power” is the functorial structure.

  • The same operand is also used for function composition because function composition is just mapping. Visually the symbol can be seen as chaining two stars similarly as function composition chains two functions.

__rshift__(x)

Sequence with >> similarly as with *> and >> in Haskell

apply(f)

m a -> m (a -> b) -> m b

Default implementation is based on apply_to.

apply_first(x)

Combine two actions, keeping only the result of the first

Apply f => f a -> f b -> f a
apply_second(x)

Combine two actions, keeping only the result of the second

Apply f => f a -> f b -> f b
apply_to(x)

f (a -> b) -> f a -> f b

Default implementation is based on apply.

flap(x)

Functor f => f (a -> b) -> a - > f b

map(f)[source]

m a -> (a -> b) -> m b

Default implementation is based on apply:

self :: m a

f :: a -> b

pure f :: m (a -> b)

apply :: m a -> m (a -> b) -> m b

pure(x)[source]

a -> m a

replace(x)

Haskell ($>) operator