Control.Comonad
- Package
- control
- Repository
- purerl/purescript-control
#Comonad Source
class Comonad :: (Type -> Type) -> Constraintclass (Extend w) <= Comonad w where
Comonad extends the Extend class with the extract function
which extracts a value, discarding the comonadic context.
Comonad is the dual of Monad, and extract is the dual of pure.
Laws:
- Left Identity:
extract <<= xs = xs - Right Identity:
extract (f <<= xs) = f xs
Members
extract :: forall a. w a -> a
Re-exports from Control.Extend
#Extend Source
class Extend :: (Type -> Type) -> Constraintclass (Functor w) <= Extend w where
The Extend class defines the extension operator (<<=)
which extends a local context-dependent computation to
a global computation.
Extend is the dual of Bind, and (<<=) is the dual of
(>>=).
Laws:
- Associativity:
extend f <<< extend g = extend (f <<< extend g)
Members
extend :: forall b a. (w a -> b) -> w a -> w b
Instances
#(=<=) Source
Operator alias for Control.Extend.composeCoKleisliFlipped (right-associative / precedence 1)
Re-exports from Data.Functor
#Functor Source
class Functor :: (Type -> Type) -> Constraintclass Functor f where
A Functor is a type constructor which supports a mapping operation
map.
map can be used to turn functions a -> b into functions
f a -> f b whose argument and return types use the type constructor f
to represent some computational context.
Instances must satisfy the following laws:
- Identity:
map identity = identity - Composition:
map (f <<< g) = map f <<< map g
Members
map :: forall a b. (a -> b) -> f a -> f b
Instances
#void Source
void :: forall f a. Functor f => f a -> f UnitThe void function is used to ignore the type wrapped by a
Functor, replacing it with Unit and keeping only the type
information provided by the type constructor itself.
void is often useful when using do notation to change the return type
of a monadic computation:
main = forE 1 10 \n -> void do
print n
print (n * n)