Control.Arrow.ListLike.Class

Container arrow type class.

class Arrow arr => ArrowListLike f arr | arr -> f where

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.

Methods

embed

Arguments

:: f a `arr` a

Use a container as the input for an arrow.

observe

Arguments

:: (a `arr` b)

-> a `arr` f b

Get the result as container.

Instances

Monad m => ArrowListLike [] (ListTArrow m)

Monad m => ArrowListLike Seq (SeqTArrow m)

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

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

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

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

Generic arrow utilities.

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

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

const :: Arrow arr => b -> a `arr` b

Skip the input and produce a constant output.

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

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

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

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

Container arrow utilities.

constF :: ArrowListLike f arr => f c -> a `arr` c

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

none :: (Alternative f, ArrowListLike f arr) => a `arr` b

Ignore the input and produce no results. Like zeroArrow.

results :: (Foldable f, ArrowListLike f arr) => (a `arr` b) -> a `arr` Bool

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

Conditional and filter arrows.

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

Create a filtering container arrow by mapping a predicate function over the input. When the predicate returns True the input will be returned in the output container, when False the empty container is returned.

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

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, ArrowListLike f arr, ArrowChoice arr) => (a `arr` a) -> (a `arr` c) -> a `arr` a infix 7

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, ArrowListLike f arr, ArrowChoice arr) => (a `arr` c) -> (a `arr` b) -> a `arr` b infix 8

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, ArrowListLike f arr, ArrowChoice arr) => (a `arr` c) -> a `arr` a

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, ArrowListLike f arr, ArrowChoice arr) => (a `arr` c) -> a `arr` a

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

orElse :: (Foldable f, ArrowListLike f arr, ArrowChoice arr) => (a `arr` b) -> (a `arr` b) -> a `arr` b infix 6

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, ArrowListLike f arr) => Maybe a `arr` a

Map a Maybe input to a container output. When the Maybe is a Nothing an empty container will be returned, Just will result in a singleton container.

optional :: (Foldable f, ArrowListLike f arr, ArrowChoice arr) => (a `arr` b) -> a `arr` Maybe b

Apply a container arrow, when there are no results a Nothing will be returned, otherwise the results will be wrapped in a Just. This function always produces result.