Control.Arrow.ArrowIf

Methods

• ifA :: a b c -> a b d -> a b d -> a b d

  if lifted to arrows

• ifP :: (b -> Bool) -> a b d -> a b d -> a b d

  shortcut: ifP p = ifA (isA p)

• neg :: a b c -> a b b

  negation: neg f = ifA f none this

• when :: a b b -> a b c -> a b b

  f `when` g : when the predicate g holds, f is applied, else the identity filter this

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

  shortcut: f `whenP` p = f `when` (isA p)

• whenNot :: a b b -> a b c -> a b b

  f `whenNot` g : when the predicate g does not hold, f is applied, else the identity filter this

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

  like whenP

• guards :: a b c -> a b d -> a b d

  g `guards` f : when the predicate g holds, f is applied, else none

• guardsP :: (b -> Bool) -> a b d -> a b d

  like whenP

• filterA :: a b c -> a b b

  shortcut for f guards this

• containing :: a b c -> a c d -> a b c

  f `containing` g : keep only those results from f for which g holds

  definition: f `containing` g = f >>> g `guards` this

• notContaining :: a b c -> a c d -> a b c

  f `notContaining` g : keep only those results from f for which g does not hold

  definition: f `notContaining` g = f >>> ifA g none this

• orElse :: a b c -> a b c -> a b c

  f `orElse` g : directional choice: if f succeeds, the result of f is the result, else g is applied

• choiceA :: [IfThen (a b c) (a b d)] -> a b d

  generalisation of orElse for multi way branches like in case expressions.

  An auxiliary data type IfThen with an infix constructor :-> is used for writing multi way branches

  example: choiceA [ p1 :-> e1, p2 :-> e2, this :-> default ]

• tagA :: a b c -> a b (Either b b)

  tag a value with Left or Right, if arrow has success, input is tagged with Left, else with Right

• spanA :: a b b -> a [b] ([b], [b])

  split a list value with an arrow and returns a pair of lists. This is the arrow version of span. The arrow is deterministic.

  example: runLA (spanA (isA (/= '-'))) "abc-def" gives [("abc","-def")] as result

• partitionA :: a b b -> a [b] ([b], [b])

  partition a list of values into a pair of lists

  This is the arrow Version of partition