Portability  portable 

Stability  experimental 
Maintainer  Uwe Schmidt (uwe\@fhwedel.de) 
The list arrow class
This module defines the interface for list arrows.
A list arrow is a function, that gives a list of results for a given argument. A single element result represents a normal function. An empty list oven indicates, the function is undefined for the given argument. The empty list may also represent False, none empty lists True. A list with more than one element gives all results for a nondeterministic function.
 class (Arrow a, ArrowPlus a, ArrowZero a, ArrowApply a) => ArrowList a where
 arr2 :: (b1 > b2 > c) > a (b1, b2) c
 arr3 :: (b1 > b2 > b3 > c) > a (b1, (b2, b3)) c
 arr4 :: (b1 > b2 > b3 > b4 > c) > a (b1, (b2, (b3, b4))) c
 arr2A :: (b > a c d) > a (b, c) d
 arrL :: (b > [c]) > a b c
 arr2L :: (b > c > [d]) > a (b, c) d
 constA :: c > a b c
 constL :: [c] > a b c
 isA :: (b > Bool) > a b b
 (>>.) :: a b c > ([c] > [d]) > a b d
 (>.) :: a b c > ([c] > d) > a b d
 listA :: a b c > a b [c]
 unlistA :: a [b] b
 this :: a b b
 none :: a b c
 withDefault :: a b c > c > a b c
 single :: a b c > a b c
 applyA :: a b (a b c) > a b c
 ($<) :: (c > a b d) > a b c > a b d
 ($<<) :: (c1 > c2 > a b d) > a b (c1, c2) > a b d
 ($<<<) :: (c1 > c2 > c3 > a b d) > a b (c1, (c2, c3)) > a b d
 ($<<<<) :: (c1 > c2 > c3 > c4 > a b d) > a b (c1, (c2, (c3, c4))) > a b d
 ($<$) :: (c > a b b) > a b c > a b b
 mergeA :: (a (a1, b1) a1 > a (a1, b1) b1 > a (a1, b1) c) > a (a1, b1) c
 perform :: a b c > a b b
 catA :: [a b c] > a b c
 seqA :: [a b b] > a b b
Documentation
class (Arrow a, ArrowPlus a, ArrowZero a, ArrowApply a) => ArrowList a whereSource
arr2 :: (b1 > b2 > c) > a (b1, b2) cSource
construction of a 2 argument arrow from a binary function

 example: a1 &&& a2 >>> arr2 f
arr3 :: (b1 > b2 > b3 > c) > a (b1, (b2, b3)) cSource
construction of a 3 argument arrow from a 3ary function

 example: a1 &&& a2 &&& a3 >>> arr3 f
arr4 :: (b1 > b2 > b3 > b4 > c) > a (b1, (b2, (b3, b4))) cSource
construction of a 4 argument arrow from a 4ary function

 example: a1 &&& a2 &&& a3 &&& a4 >>> arr4 f
arr2A :: (b > a c d) > a (b, c) dSource
construction of a 2 argument arrow from a singe argument arrow
arrL :: (b > [c]) > a b cSource
constructor for a list arrow from a function with a list as result
arr2L :: (b > c > [d]) > a (b, c) dSource
constructor for a list arrow with 2 arguments
constructor for a const arrow: constA = arr . const
constructor for a const arrow: constL = arrL . const
isA :: (b > Bool) > a b bSource
builds an arrow from a predicate. If the predicate holds, the single list containing the input is returned, else the empty list
(>>.) :: a b c > ([c] > [d]) > a b dSource
combinator for converting the result of a list arrow into another list
example: foo >>. reverse
reverses the the result of foo
example: foo >>. take 1
constructs a deterministic version of foo by deleting all further results
(>.) :: a b c > ([c] > d) > a b dSource
combinator for converting the result of an arrow into a single element result
listA :: a b c > a b [c]Source
combinator for converting an arrow into a determinstic version with all results collected in a single element list
listA af = af >>. (:[])
this is useful when the list of results computed by an arrow must be manipulated (e.g. sorted)
example for sorting the results of a filter
collectAndSort :: a b c > a b c collectAndSort collect = listA collect >>> arrL sort
the identity arrow, alias for returnA
the zero arrow, alias for zeroArrow
withDefault :: a b c > c > a b cSource
converts an arrow, that may fail, into an arrow that always succeeds
example: withDefault none "abc"
is equivalent to constA "abc"
single :: a b c > a b cSource
makes a list arrow deterministic, the number of results is at most 1
definition
single f = f >>. take 1
examples with strings:
runLA ( single none ) "x" == [] runLA ( single this ) "x" == ["x"] runLA ( single (constA "y" <+> this ) ) "x" == ["y"]
applyA :: a b (a b c) > a b cSource
compute an arrow from the input and apply the arrow to this input
definition: (f &&& this) >>> app
in a point free style, there is no way to use an argument in 2 places, this is a combinator for simulating this. first the argument is used to compute an arrow, then this new arrow is applied to the input
applyA coresponds to: apply f x = let g = f x in g x
($<) :: (c > a b d) > a b c > a b dSource
compute the parameter for an arrow with extra parameters from the input and apply the arrow for all parameter values to the input
a kind of "function call" for arrows, useful for joining arrows
infixl 2 ($<)
definition:
g $< f = applyA (f >>> arr g)
if f
fails, the whole arrow fails, e.g. g $< none == none
if f
computes n values and g
is deterministic, the whole arrow computes n values
examples with simple list arrows with strings
prefixString :: String > a String String prefixString s = arr (s++) runLA ( prefixString $< none ) "x" == [] runLA ( prefixString $< constA "y" ) "x" == ["yx"] runLA ( prefixString $< this ) "x" == ["xx"] runLA ( prefixString $< constA "y" <+> constA "z" ) "x" == ["yx","zx"] runLA ( prefixString $< constA "y" <+> this <+> constA "z" ) "x" == ["yx","xx","zx"]
($<<) :: (c1 > c2 > a b d) > a b (c1, c2) > a b dSource
binary version of $<
example with simple list arrows with strings
infixString :: String > String > a String String infixString s1 s2 = arr (\ s > s1 ++ s ++ s2) runLA ( infixString $<< constA "y" &&& constA "z" ) "x" = ["yxz"] runLA ( infixString $<< this &&& this ) "x" = ["xxx"] runLA ( infixString $<< constA "y" &&& (constA "z" <+> this) ) "x" = ["yxz", "yxx"]
($<<<) :: (c1 > c2 > c3 > a b d) > a b (c1, (c2, c3)) > a b dSource
($<<<<) :: (c1 > c2 > c3 > c4 > a b d) > a b (c1, (c2, (c3, c4))) > a b dSource
($<$) :: (c > a b b) > a b c > a b bSource
compute the parameter for an arrow f
with an extra parameter by an arrow g
and apply all the results from g
sequentially to the input
infixl 2 ($<$)
typical usage:
g :: a b c g = ... f :: c > a b b f x = ... x ... f $<$ g
f
computes the extra parameters for g
from the input of type b
and g
is applied with this
parameter to the input. This allows programming in a point wise style in g
, which becomes
neccessary, when a value is needed more than once.
this combinator is useful, when transforming a single value (document) step by step,
with g
for collecting the data for all steps, and f
for transforming the input step by step
if g
is deterministic (computes exactly one result),
g $<$ f == g $< f
holds
if g
fails, f $<$ g == this
if g
computes more than one result, f
is applied sequentially to the input for every result from g
examples with simple list arrows with strings
prefixString :: String > a String String prefixString s = arr (s++) runLA ( prefixString $<$ none ) "x" == ["x"] runLA ( prefixString $<$ constA "y" ) "x" == ["yx"] runLA ( prefixString $<$ constA "y" <+> constA "z" ) "x" == ["zyx"] runLA ( prefixString $<$ constA "y" <+> this <+> constA "z" ) "x" == ["zxyx"]
example with two extra parameter
g1 :: a b c1 g2 :: a b c2 f :: (c1, c2) > a b b f (x1, x2) = ... x1 ... x2 ... f $<$ g1 &&& g2
mergeA :: (a (a1, b1) a1 > a (a1, b1) b1 > a (a1, b1) c) > a (a1, b1) cSource
merge the result pairs of an arrow with type a a1 (b1, b2)
by combining the tuple components with the op
arrow
examples with simple list arrows working on strings and XmlTrees
a1 :: a String (XmlTree, XmlTree) a1 = selem "foo" [this >>> mkText] &&& selem "bar" [arr (++"0") >>> mkText] runLA (a1 >>> mergeA (<+>) >>> xshow this) "42" == ["<foo>42</foo>","<bar>420</bar>"] runLA (a1 >>> mergeA (+=) >>> xshow this) "42" == ["<foo>42<bar>420</bar></foo>"]
see also: applyA
, $<
and +=
in class Text.XML.HXT.Arrow.ArrowXml
perform :: a b c > a b bSource
useful only for arrows with side effects: perform applies an arrow to the input ignores the result and returns the input
example: ... >>> perform someTraceArrow >>> ...
catA :: [a b c] > a b cSource
generalization of arrow combinator <+>
definition: catA = foldl (<+>) none
seqA :: [a b b] > a b bSource
generalization of arrow combinator >>>
definition: seqA = foldl (>>>) this