Safe Haskell | Safe-Inferred |
---|

- class Arrow arr => ArrowF f arr | arr -> f where
- mapF :: ArrowF f arr => (f b -> f c) -> (a `arr` b) -> a `arr` c
- arrMF :: (ArrowF f arr, ArrowKleisli m arr) => (a -> m (f c)) -> a `arr` c
- unite :: ArrowPlus arr => (b, b) `arr` b
- const :: Arrow arr => b -> a `arr` b
- concatA :: ArrowPlus arr => [a `arr` b] -> a `arr` b
- plus :: (Alternative f, ArrowF f arr) => (a `arr` b) -> (a `arr` b) -> a `arr` b
- constF :: ArrowF f arr => f c -> a `arr` c
- none :: (Alternative f, ArrowF f arr) => a `arr` b
- results :: (Foldable f, ArrowF f arr) => (a `arr` b) -> a `arr` Bool
- isA :: (Alternative f, ArrowF f arr) => (a -> Bool) -> a `arr` a
- ifA :: (Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` b) -> (a `arr` t) -> (a `arr` t) -> a `arr` t
- when :: (Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` a) -> (a `arr` c) -> a `arr` a
- guards :: (Alternative f, Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` c) -> (a `arr` b) -> a `arr` b
- filterA :: (Alternative f, Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` c) -> a `arr` a
- notA :: (Alternative f, Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` c) -> a `arr` a
- orElse :: (Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` b) -> (a `arr` b) -> a `arr` b
- maybeA :: (Alternative f, ArrowF f arr) => Maybe a `arr` a
- optional :: (Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` b) -> a `arr` Maybe b

# Container arrow type class.

class Arrow arr => ArrowF f arr | arr -> f whereSource

A type class for arrows that produce containers of results. The container
arrow can be seen as a generalization for list arrows. Most operations
assume the container type has an `Applicative`

, an `Alternative`

and a
`Foldable`

instance.

:: f a `arr` a | Use a container as the input for an arrow. |

:: (a `arr` b) | |

-> a `arr` f b | Get the result as container. |

mapF :: ArrowF f arr => (f b -> f c) -> (a `arr` b) -> a `arr` cSource

Map a function over the result collection of a container arrow.

arrMF :: (ArrowF f arr, ArrowKleisli m arr) => (a -> m (f c)) -> a `arr` cSource

Embed a monadic function returning an ordered list into a container arrow.

# Generic arrow utilities.

unite :: ArrowPlus arr => (b, b) `arr` bSource

Take the output of an arrow producing two results and concatenate them into the result of the container arrow.

concatA :: ArrowPlus arr => [a `arr` b] -> a `arr` bSource

Collect the results of applying multiple arrows to the same input.

plus :: (Alternative f, ArrowF f arr) => (a `arr` b) -> (a `arr` b) -> a `arr` bSource

Join the results of two arrows, like (+) from ArrowPlus.

# Container arrow utilities.

constF :: ArrowF f arr => f c -> a `arr` cSource

Skip the input and produce a constant output specified as a container.

none :: (Alternative f, ArrowF f arr) => a `arr` bSource

Ignore the input and produce no results. Like `zeroArrow`

.

results :: (Foldable f, ArrowF f arr) => (a `arr` b) -> a `arr` BoolSource

Returns a `Bool`

indicating whether the input arrow produces a container
with any results.

# Conditional and filter arrows.

isA :: (Alternative f, ArrowF f arr) => (a -> Bool) -> a `arr` aSource

ifA :: (Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` b) -> (a `arr` t) -> (a `arr` t) -> a `arr` tSource

Use the result of a container arrow as a conditional, like an if-then-else
arrow. When the first arrow produces any results the *then* arrow will be
used, when the first arrow produces no results the *else* arrow will be
used.

when :: (Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` a) -> (a `arr` c) -> a `arr` aSource

Apply a container arrow only when a conditional arrow produces any
results. When the conditional produces no results the output arrow /behaves
like the identity*. The *second/ input arrow is used as the conditional,
this allow you to write: ` a `when` condition `

guards :: (Alternative f, Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` c) -> (a `arr` b) -> a `arr` bSource

Apply a container arrow only when a conditional arrow produces any
results. When the conditional produces no results the output arrow
*produces no results*. The *first* input arrow is used as the conditional,
this allow you to write: ` condition `guards` a `

filterA :: (Alternative f, Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` c) -> a `arr` aSource

Filter the results of an arrow with a predicate arrow, when the filter condition produces results the input is accepted otherwise it is excluded.

notA :: (Alternative f, Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` c) -> a `arr` aSource

Negation container arrow. Only accept the input when the condition produces no output.

orElse :: (Foldable f, ArrowF f arr, ArrowChoice arr) => (a `arr` b) -> (a `arr` b) -> a `arr` bSource

Apply the input arrow, when the arrow does not produces any results the
second fallback arrow is applied.
Likely written infix like this ` a `orElse` b `

# Optionality.

maybeA :: (Alternative f, ArrowF f arr) => Maybe a `arr` aSource