Control.Arrow.ArrowList

Methods

• arr2 :: (b1 -> b2 -> c) -> a (b1, b2) c

  construction of a 2 argument arrow from a binary function | | example: a1 &&& a2 >>> arr2 f

• arr3 :: (b1 -> b2 -> b3 -> c) -> a (b1, (b2, b3)) c

  construction of a 3 argument arrow from a 3-ary function | | example: a1 &&& a2 &&& a3 >>> arr3 f

• arr4 :: (b1 -> b2 -> b3 -> b4 -> c) -> a (b1, (b2, (b3, b4))) c

  construction of a 4 argument arrow from a 4-ary function | | example: a1 &&& a2 &&& a3 &&& a4 >>> arr4 f

• arr2A :: (b -> a c d) -> a (b, c) d

  construction of a 2 argument arrow from a singe argument arrow

• arrL :: (b -> [c]) -> a b c

  constructor for a list arrow from a function with a list as result

• arr2L :: (b -> c -> [d]) -> a (b, c) d

  constructor for a list arrow with 2 arguments

• constA :: c -> a b c

  constructor for a const arrow: constA = arr . const

• constL :: [c] -> a b c

  constructor for a const arrow: constL = arrL . const

• isA :: (b -> Bool) -> a b b

  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 dinfixl 8

  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 dinfixl 8

  combinator for converting the result of an arrow into a single element result

• listA :: a b c -> a b [c]

  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

• unlistA :: a [b] b

  the inverse of listA

   listA af >>> unlistA = af

  unlistA is defined as arrL id

• this :: a b b

  the identity arrow, alias for returnA

• none :: a b c

  the zero arrow, alias for zeroArrow

• withDefault :: a b c -> c -> a b c

  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 c

  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 c

  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

  see also: $<, $<<, $<<<, $<<<<, $<$

• ($<) :: (c -> a b d) -> a b c -> a b dinfixl 2

  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"]

  see also: applyA, $<<, $<<<, $<<<<, $<$

• ($<<) :: (c1 -> c2 -> a b d) -> a b (c1, c2) -> a b dinfixl 2

  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 dinfixl 2

  version of $< for arrows with 3 extra parameters

  typical usage

  f $<<< g1 &&& g2 &&& g3

• ($<<<<) :: (c1 -> c2 -> c3 -> c4 -> a b d) -> a b (c1, (c2, (c3, c4))) -> a b dinfixl 2

  version of $< for arrows with 4 extra parameters

  typical usage

  f $<<<< g1 &&& g2 &&& g3 &&& g4

• ($<$) :: (c -> a b b) -> a b c -> a b binfixl 2

  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

  see also: applyA, $<

• mergeA :: (a (a1, b1) a1 -> a (a1, b1) b1 -> a (a1, b1) c) -> a (a1, b1) c

  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 b

  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 c

  generalization of arrow combinator <+>

  definition: catA = foldl (<+>) none

• seqA :: [a b b] -> a b b

  generalization of arrow combinator >>>

  definition: seqA = foldl (>>>) this