Data.Profunctor.Choice
- Package
- profunctor
- Repository
- purescript/purescript-profunctor
#Choice Source
class Choice :: (Type -> Type -> Type) -> Constraint
class (Profunctor p) <= Choice p where
The Choice
class extends Profunctor
with combinators for working with
sum types.
left
and right
lift values in a Profunctor
to act on the Left
and
Right
components of a sum, respectively.
Looking at Choice
through the intuition of inputs and outputs
yields the following type signature:
left :: forall input output a. p input output -> p (Either input a) (Either output a)
right :: forall input output a. p input output -> p (Either a input) (Either a output)
If we specialize the profunctor p
to the function
arrow, we get the following type
signatures:
left :: forall input output a. (input -> output) -> (Either input a) -> (Either output a)
right :: forall input output a. (input -> output) -> (Either a input) -> (Either a output)
When the profunctor
is Function
application, left
allows you to map a function over the
left side of an Either
, and right
maps it over the right side (same as map
would do).
Members
left :: forall a b c. p a b -> p (Either a c) (Either b c)
right :: forall a b c. p b c -> p (Either a b) (Either a c)
Instances
#splitChoice Source
splitChoice :: forall p a b c d. Category p => Choice p => p a b -> p c d -> p (Either a c) (Either b d)
Compose a value acting on a sum from two values, each acting on one of the components of the sum.
Specializing (+++)
to function application would look like this:
(+++) :: forall a b c d. (a -> b) -> (c -> d) -> (Either a c) -> (Either b d)
We take two functions, f
and g
, and we transform them into a single function which
takes an Either
and maps f
over the left side and g
over the right side. Just like
bi-map
would do for the bi-functor
instance of Either
.
#(+++) Source
Operator alias for Data.Profunctor.Choice.splitChoice (right-associative / precedence 2)
#fanin Source
fanin :: forall p a b c. Category p => Choice p => p a c -> p b c -> p (Either a b) c
Compose a value which eliminates a sum from two values, each eliminating one side of the sum.
This combinator is useful when assembling values from smaller components, because it provides a way to support two different types of input.
Specializing (|||)
to function application would look like this:
(|||) :: forall a b c d. (a -> c) -> (b -> c) -> Either a b -> c
We take two functions, f
and g
, which both return the same type c
and we transform them into a
single function which takes an Either
value with the parameter type of f
on the left side and
the parameter type of g
on the right side. The function then runs either f
or g
, depending on
whether the Either
value is a Left
or a Right
.
This allows us to bundle two different computations which both have the same result type into one
function which will run the approriate computation based on the parameter supplied in the Either
value.