hxt-7.3: doc/hdoc/Control-Arrow-ArrowList.html
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--Rendered using the Haskell Html Library v0.2-->
<HTML
><HEAD
><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
><TITLE
>Control.Arrow.ArrowList</TITLE
><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
><SCRIPT SRC="haddock-util.js" TYPE="text/javascript"
></SCRIPT
></HEAD
><BODY
><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
><TR
><TD CLASS="topbar"
><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
><TR
><TD
><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
></TD
><TD CLASS="title"
>Haskell Xml Toolbox 7.3: The complete API</TD
><TD CLASS="topbut"
><A HREF="http://darcs.fh-wedel.de/hxt/src/./Control/Arrow/ArrowList.hs"
>Source code</A
></TD
><TD CLASS="topbut"
><A HREF="index.html"
>Contents</A
></TD
><TD CLASS="topbut"
><A HREF="doc-index.html"
>Index</A
></TD
></TR
></TABLE
></TD
></TR
><TR
><TD CLASS="modulebar"
><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
><TR
><TD
><FONT SIZE="6"
>Control.Arrow.ArrowList</FONT
></TD
><TD ALIGN="right"
><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
><TR
><TD CLASS="infohead"
>Portability</TD
><TD CLASS="infoval"
>portable</TD
></TR
><TR
><TD CLASS="infohead"
>Stability</TD
><TD CLASS="infoval"
>experimental</TD
></TR
><TR
><TD CLASS="infohead"
>Maintainer</TD
><TD CLASS="infoval"
>Uwe Schmidt (uwe\@fh-wedel.de)</TD
></TR
></TABLE
></TD
></TR
></TABLE
></TD
></TR
><TR
><TD CLASS="s15"
></TD
></TR
><TR
><TD CLASS="section1"
>Description</TD
></TR
><TR
><TD CLASS="doc"
><P
>Version : $Id: ArrowList.hs,v 1.11 2006<EM
>06</EM
>01 12:59:04 hxml Exp $
</P
><P
>The List Arrow Class
</P
><P
>This module defines the interface for list arrows.
</P
><P
>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.
</P
></TD
></TR
><TR
><TD CLASS="s15"
></TD
></TR
><TR
><TD CLASS="section1"
>Synopsis</TD
></TR
><TR
><TD CLASS="s15"
></TD
></TR
><TR
><TD CLASS="body"
><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
><TR
><TD CLASS="decl"
><SPAN CLASS="keyword"
>class</SPAN
> (Arrow a, ArrowPlus a, ArrowZero a, ArrowApply a) => <A HREF="#t%3AArrowList"
>ArrowList</A
> a <SPAN CLASS="keyword"
>where</SPAN
></TD
></TR
><TR
><TD CLASS="body"
><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
><TR
><TD CLASS="decl"
><A HREF="#v%3Aarr2"
>arr2</A
> :: (b1 -> b2 -> c) -> a (b1, b2) c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3Aarr3"
>arr3</A
> :: (b1 -> b2 -> b3 -> c) -> a (b1, (b2, b3)) c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3Aarr4"
>arr4</A
> :: (b1 -> b2 -> b3 -> b4 -> c) -> a (b1, (b2, (b3, b4))) c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3Aarr2A"
>arr2A</A
> :: (b -> a c d) -> a (b, c) d</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3AarrL"
>arrL</A
> :: (b -> [c]) -> a b c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3Aarr2L"
>arr2L</A
> :: (b -> c -> [d]) -> a (b, c) d</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3AconstA"
>constA</A
> :: c -> a b c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3AconstL"
>constL</A
> :: [c] -> a b c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3AisA"
>isA</A
> :: (b -> Bool) -> a b b</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3A%3E%3E."
>(>>.)</A
> :: a b c -> ([c] -> [d]) -> a b d</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3A%3E."
>(>.)</A
> :: a b c -> ([c] -> d) -> a b d</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3AlistA"
>listA</A
> :: a b c -> a b [c]</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3Athis"
>this</A
> :: a b b</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3Anone"
>none</A
> :: a b c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3AwithDefault"
>withDefault</A
> :: a b c -> c -> a b c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3Asingle"
>single</A
> :: a b c -> a b c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3AapplyA"
>applyA</A
> :: a b (a b c) -> a b c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3A%24%3C"
>($<)</A
> :: (c -> a b d) -> a b c -> a b d</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3A%24%3C%3C"
>($<<)</A
> :: (c1 -> c2 -> a b d) -> a b (c1, c2) -> a b d</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3A%24%3C%3C%3C"
>($<<<)</A
> :: (c1 -> c2 -> c3 -> a b d) -> a b (c1, (c2, c3)) -> a b d</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3A%24%3C%3C%3C%3C"
>($<<<<)</A
> :: (c1 -> c2 -> c3 -> c4 -> a b d) -> a b (c1, (c2, (c3, c4))) -> a b d</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3A%24%3C%24"
>($<$)</A
> :: (c -> a b b) -> a b c -> a b b</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3Aperform"
>perform</A
> :: a b c -> a b b</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3AcatA"
>catA</A
> :: [a b c] -> a b c</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="#v%3AseqA"
>seqA</A
> :: [a b b] -> a b b</TD
></TR
></TABLE
></TD
></TR
></TABLE
></TD
></TR
><TR
><TD CLASS="s15"
></TD
></TR
><TR
><TD CLASS="section1"
>Documentation</TD
></TR
><TR
><TD CLASS="s15"
></TD
></TR
><TR
><TD CLASS="decl"
><SPAN CLASS="keyword"
>class</SPAN
> (Arrow a, ArrowPlus a, ArrowZero a, ArrowApply a) => <A NAME="t%3AArrowList"
></A
><B
>ArrowList</B
> a <SPAN CLASS="keyword"
>where</SPAN
></TD
></TR
><TR
><TD CLASS="body"
><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
><TR
><TD CLASS="ndoc"
><P
>The interface for list arrows
</P
><P
>Only mkA, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3Aarr2A"
>arr2A</A
></TT
>, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3AisA"
>isA</A
></TT
> '(>>.)' don't have default implementations
</P
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="section4"
>Methods</TD
></TR
><TR
><TD CLASS="body"
><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
><TR
><TD CLASS="decl"
><A NAME="v%3Aarr2"
></A
><B
>arr2</B
> :: (b1 -> b2 -> c) -> a (b1, b2) c</TD
></TR
><TR
><TD CLASS="doc"
>construction of a 2 argument arrow from a binary function
|
| example: <TT
> a1 &&& a2 >>> arr2 f </TT
>
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3Aarr3"
></A
><B
>arr3</B
> :: (b1 -> b2 -> b3 -> c) -> a (b1, (b2, b3)) c</TD
></TR
><TR
><TD CLASS="doc"
>construction of a 3 argument arrow from a 3-ary function
|
| example: <TT
> a1 &&& a2 &&& a3 >>> arr3 f </TT
>
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3Aarr4"
></A
><B
>arr4</B
> :: (b1 -> b2 -> b3 -> b4 -> c) -> a (b1, (b2, (b3, b4))) c</TD
></TR
><TR
><TD CLASS="doc"
>construction of a 4 argument arrow from a 4-ary function
|
| example: <TT
> a1 &&& a2 &&& a3 &&& a4 >>> arr4 f </TT
>
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3Aarr2A"
></A
><B
>arr2A</B
> :: (b -> a c d) -> a (b, c) d</TD
></TR
><TR
><TD CLASS="doc"
>construction of a 2 argument arrow from a singe argument arrow
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3AarrL"
></A
><B
>arrL</B
> :: (b -> [c]) -> a b c</TD
></TR
><TR
><TD CLASS="doc"
>constructor for a list arrow from a function with a list as result
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3Aarr2L"
></A
><B
>arr2L</B
> :: (b -> c -> [d]) -> a (b, c) d</TD
></TR
><TR
><TD CLASS="doc"
>constructor for a list arrow with 2 arguments
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3AconstA"
></A
><B
>constA</B
> :: c -> a b c</TD
></TR
><TR
><TD CLASS="doc"
>constructor for a const arrow: <TT
> constA = arr . const </TT
>
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3AconstL"
></A
><B
>constL</B
> :: [c] -> a b c</TD
></TR
><TR
><TD CLASS="doc"
>constructor for a const arrow: <TT
> constL = arrL . const </TT
>
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3AisA"
></A
><B
>isA</B
> :: (b -> Bool) -> a b b</TD
></TR
><TR
><TD CLASS="doc"
>builds an arrow from a predicate.
If the predicate holds, the single list containing the input is returned, else the empty list
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3A%3E%3E."
></A
><B
>(>>.)</B
> :: a b c -> ([c] -> [d]) -> a b d</TD
></TR
><TR
><TD CLASS="doc"
><P
>combinator for converting the result of a list arrow into another list
</P
><P
>example: <TT
> foo >>. reverse </TT
> reverses the the result of foo
</P
><P
>example: <TT
> foo >>. take 1 </TT
> constructs a deterministic version of foo by deleting all further results
</P
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3A%3E."
></A
><B
>(>.)</B
> :: a b c -> ([c] -> d) -> a b d</TD
></TR
><TR
><TD CLASS="doc"
>combinator for converting the result of an arrow into a single element result
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3AlistA"
></A
><B
>listA</B
> :: a b c -> a b [c]</TD
></TR
><TR
><TD CLASS="doc"
><P
>combinator for converting an arrow into a determinstic version with all results collected in a single element list
</P
><PRE
> listA af = af >>. (:[]) </PRE
><P
>this is useful when the list of results computed by an arrow must be manipulated (e.g. sorted)
</P
><P
>example for sorting the results of a filter
</P
><PRE
> collectAndSort :: a b c -> a b c
collectAndSort collect = listA collect >>> arrL sort
</PRE
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3Athis"
></A
><B
>this</B
> :: a b b</TD
></TR
><TR
><TD CLASS="doc"
>the identity arrow, alias for returnA
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3Anone"
></A
><B
>none</B
> :: a b c</TD
></TR
><TR
><TD CLASS="doc"
>the zero arrow, alias for zeroArrow
</TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3AwithDefault"
></A
><B
>withDefault</B
> :: a b c -> c -> a b c</TD
></TR
><TR
><TD CLASS="doc"
><P
>converts an arrow, that may fail, into an arrow that always succeeds
</P
><P
>example: <TT
> withDefault none "abc" </TT
> is equivalent to <TT
> constA "abc" </TT
>
</P
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3Asingle"
></A
><B
>single</B
> :: a b c -> a b c</TD
></TR
><TR
><TD CLASS="doc"
><P
>makes a list arrow deterministic, the number of results is at most 1
</P
><P
>definition
</P
><PRE
> single f = f >>. take 1
</PRE
><P
>examples with strings:
</P
><PRE
> runLA ( single none ) "x" == []
runLA ( single this ) "x" == ["x"]
runLA ( single
(constA "y"
<+> this ) ) "x" == ["y"]
</PRE
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3AapplyA"
></A
><B
>applyA</B
> :: a b (a b c) -> a b c</TD
></TR
><TR
><TD CLASS="doc"
><P
>compute an arrow from the input and apply the arrow to this input
</P
><P
>definition: <TT
> (f &&& this) >>> app </TT
>
</P
><P
>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
</P
><P
>applyA coresponds to: <TT
> apply f x = let g = f x in g x </TT
>
</P
><P
>see also: <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C"
>$<</A
></TT
>, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C%3C"
>$<<</A
></TT
>, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C%3C%3C"
>$<<<</A
></TT
>, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C%3C%3C%3C"
>$<<<<</A
></TT
>, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C%24"
>$<$</A
></TT
>
</P
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3A%24%3C"
></A
><B
>($<)</B
> :: (c -> a b d) -> a b c -> a b d</TD
></TR
><TR
><TD CLASS="doc"
><P
>compute the parameter for an arrow with extra parameters from the input
and apply the arrow for all parameter values to the input
</P
><P
>a kind of "function call" for arrows, useful for joining arrows
</P
><PRE
> infixl 2 ($<)
</PRE
><P
>definition:
</P
><PRE
> g $< f = applyA (f >>> arr g)
</PRE
><P
>if <TT
>f</TT
> fails, the whole arrow fails, e.g. <TT
> g $< none == none </TT
>
</P
><P
>if <TT
>f</TT
> computes n values and <TT
>g</TT
> is deterministic, the whole arrow computes n values
</P
><P
>examples with simple list arrows with strings
</P
><PRE
> 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"]
</PRE
><P
>see also: <TT
><A HREF="Control-Arrow-ArrowList.html#v%3AapplyA"
>applyA</A
></TT
>, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C%3C"
>$<<</A
></TT
>, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C%3C%3C"
>$<<<</A
></TT
>, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C%3C%3C%3C"
>$<<<<</A
></TT
>, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C%24"
>$<$</A
></TT
>
</P
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3A%24%3C%3C"
></A
><B
>($<<)</B
> :: (c1 -> c2 -> a b d) -> a b (c1, c2) -> a b d</TD
></TR
><TR
><TD CLASS="doc"
><P
>binary version of <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C"
>$<</A
></TT
>
</P
><P
>example with simple list arrows with strings
</P
><PRE
> 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"]
</PRE
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3A%24%3C%3C%3C"
></A
><B
>($<<<)</B
> :: (c1 -> c2 -> c3 -> a b d) -> a b (c1, (c2, c3)) -> a b d</TD
></TR
><TR
><TD CLASS="doc"
><P
>version of <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C"
>$<</A
></TT
> for arrows with 3 extra parameters
</P
><P
>typical usage
</P
><PRE
> f $<<< g1 &&& g2 &&& g3
</PRE
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3A%24%3C%3C%3C%3C"
></A
><B
>($<<<<)</B
> :: (c1 -> c2 -> c3 -> c4 -> a b d) -> a b (c1, (c2, (c3, c4))) -> a b d</TD
></TR
><TR
><TD CLASS="doc"
><P
>version of <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C"
>$<</A
></TT
> for arrows with 4 extra parameters
</P
><P
>typical usage
</P
><PRE
> f $<<<< g1 &&& g2 &&& g3 &&& g4
</PRE
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3A%24%3C%24"
></A
><B
>($<$)</B
> :: (c -> a b b) -> a b c -> a b b</TD
></TR
><TR
><TD CLASS="doc"
><P
>compute the parameter for an arrow <TT
>f</TT
> with an extra parameter by an arrow <TT
>g</TT
>
and apply all the results from <TT
>g</TT
> sequentially to the input
</P
><PRE
> infixl 2 ($<$)
</PRE
><P
>typical usage:
</P
><PRE
> g :: a b c
g = ...
f :: c -> a b b
f x = ... x ...
f $<$ g
</PRE
><P
><TT
>f</TT
> computes the extra parameters for <TT
>g</TT
> from the input of type <TT
>b</TT
> and <TT
>g</TT
> is applied with this
parameter to the input. This allows programming in a point wise style in <TT
>g</TT
>, which becomes
neccessary, when a value is needed more than once.
</P
><P
>this combinator is useful, when transforming a single value (document) step by step,
with <TT
>g</TT
> for collecting the data for all steps, and <TT
>f</TT
> for transforming the input step by step
</P
><P
>if <TT
>g</TT
> is deterministic (computes exactly one result),
<TT
> g $<$ f == g $< f </TT
> holds
</P
><P
>if <TT
>g</TT
> fails, <TT
> f $<$ g == this </TT
>
</P
><P
>if <TT
>g</TT
> computes more than one result, <TT
>f</TT
> is applied sequentially to the input for every result from <TT
>g</TT
>
</P
><P
>examples with simple list arrows with strings
</P
><PRE
> 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"]
</PRE
><P
>example with two extra parameter
</P
><PRE
> g1 :: a b c1
g2 :: a b c2
f :: (c1, c2) -> a b b
f (x1, x2) = ... x1 ... x2 ...
f $<$ g1 &&& g2
</PRE
><P
>see also: <TT
><A HREF="Control-Arrow-ArrowList.html#v%3AapplyA"
>applyA</A
></TT
>, <TT
><A HREF="Control-Arrow-ArrowList.html#v%3A%24%3C"
>$<</A
></TT
>
</P
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3Aperform"
></A
><B
>perform</B
> :: a b c -> a b b</TD
></TR
><TR
><TD CLASS="doc"
><P
>useful only for arrows with side effects: perform applies an arrow to the input
ignores the result and returns the input
</P
><P
>example: <TT
> ... >>> perform someTraceArrow >>> ... </TT
>
</P
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3AcatA"
></A
><B
>catA</B
> :: [a b c] -> a b c</TD
></TR
><TR
><TD CLASS="doc"
><P
>generalization of arrow combinator <+>
</P
><P
>definition: <TT
> catA = foldl (<A HREF="+"
>+</A
>) none </TT
>
</P
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="decl"
><A NAME="v%3AseqA"
></A
><B
>seqA</B
> :: [a b b] -> a b b</TD
></TR
><TR
><TD CLASS="doc"
><P
>generalization of arrow combinator >>>
</P
><P
>definition: <TT
> seqA = foldl (>>>) this </TT
>
</P
></TD
></TR
></TABLE
></TD
></TR
><TR
><TD CLASS="s8"
></TD
></TR
><TR
><TD CLASS="section4"
><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:ArrowList')" ALT="show/hide"
> Instances</TD
></TR
><TR
><TD CLASS="body"
><DIV ID="i:ArrowList" STYLE="display:block;"
><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
><TR
><TD CLASS="decl"
><A HREF="Control-Arrow-ArrowList.html#t%3AArrowList"
>ArrowList</A
> <A HREF="Control-Arrow-IOListArrow.html#t%3AIOLA"
>IOLA</A
></TD
></TR
><TR
><TD CLASS="decl"
><A HREF="Control-Arrow-ArrowList.html#t%3AArrowList"
>ArrowList</A
> <A HREF="Control-Arrow-ListArrow.html#t%3ALA"
>LA</A
></TD
></TR
><TR
><TD CLASS="decl"
><A HREF="Control-Arrow-ArrowList.html#t%3AArrowList"
>ArrowList</A
> (<A HREF="Control-Arrow-IOStateListArrow.html#t%3AIOSLA"
>IOSLA</A
> s)</TD
></TR
><TR
><TD CLASS="decl"
><A HREF="Control-Arrow-ArrowList.html#t%3AArrowList"
>ArrowList</A
> (<A HREF="Control-Arrow-StateListArrow.html#t%3ASLA"
>SLA</A
> s)</TD
></TR
></TABLE
></DIV
></TD
></TR
></TABLE
></TD
></TR
><TR
><TD CLASS="s15"
></TD
></TR
><TR
><TD CLASS="botbar"
>Produced by <A HREF="http://www.haskell.org/haddock/"
>Haddock</A
> version 0.8</TD
></TR
></TABLE
></BODY
></HTML
>