<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Control.Arrow</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[
window.onload = function () {pageLoad();setSynopsis("mini_Control-Arrow.html");};
//]]>
</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">base-4.5.1.0: Basic libraries</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>portable</td></tr><tr><th>Stability</th><td>provisional</td></tr><tr><th>Maintainer</th><td>libraries@haskell.org</td></tr><tr><th>Safe Haskell</th><td>Trustworthy</td></tr></table><p class="caption">Control.Arrow</p></div><div id="table-of-contents"><p class="caption">Contents</p><ul><li><a href="#g:1">Arrows
</a><ul><li><a href="#g:2">Derived combinators
</a></li><li><a href="#g:3">Right-to-left variants
</a></li></ul></li><li><a href="#g:4">Monoid operations
</a></li><li><a href="#g:5">Conditionals
</a></li><li><a href="#g:6">Arrow application
</a></li><li><a href="#g:7">Feedback
</a></li></ul></div><div id="description"><p class="caption">Description</p><div class="doc"><p>Basic arrow definitions, based on
* <em>Generalising Monads to Arrows</em>, by John Hughes,
<em>Science of Computer Programming</em> 37, pp67-111, May 2000.
plus a couple of definitions (<code><a href="Control-Arrow.html#v:returnA">returnA</a></code> and <code><a href="Control-Arrow.html#v:loop">loop</a></code>) from
* <em>A New Notation for Arrows</em>, by Ross Paterson, in <em>ICFP 2001</em>,
Firenze, Italy, pp229-240.
These papers and more information on arrows can be found at
<a href="http://www.haskell.org/arrows/">http://www.haskell.org/arrows/</a>.
</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short"><span class="keyword">class</span> <a href="Control-Category.html#t:Category">Category</a> a => <a href="#t:Arrow">Arrow</a> a <span class="keyword">where</span><ul class="subs"><li><a href="#v:arr">arr</a> :: (b -> c) -> a b c</li><li><a href="#v:first">first</a> :: a b c -> a (b, d) (c, d)</li><li><a href="#v:second">second</a> :: a b c -> a (d, b) (d, c)</li><li><a href="#v:-42--42--42-">(***)</a> :: a b c -> a b' c' -> a (b, b') (c, c')</li><li><a href="#v:-38--38--38-">(&&&)</a> :: a b c -> a b c' -> a b (c, c')</li></ul></li><li class="src short"><span class="keyword">newtype</span> <a href="#t:Kleisli">Kleisli</a> m a b = <a href="#v:Kleisli">Kleisli</a> {<ul class="subs"><li><a href="#v:runKleisli">runKleisli</a> :: a -> m b</li></ul>}</li><li class="src short"><a href="#v:returnA">returnA</a> :: <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => a b b</li><li class="src short"><a href="#v:-94--62--62-">(^>>)</a> :: <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => (b -> c) -> a c d -> a b d</li><li class="src short"><a href="#v:-62--62--94-">(>>^)</a> :: <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => a b c -> (c -> d) -> a b d</li><li class="src short"><a href="#v:-62--62--62-">(>>>)</a> :: <a href="Control-Category.html#t:Category">Category</a> cat => cat a b -> cat b c -> cat a c</li><li class="src short"><a href="#v:-60--60--60-">(<<<)</a> :: <a href="Control-Category.html#t:Category">Category</a> cat => cat b c -> cat a b -> cat a c</li><li class="src short"><a href="#v:-60--60--94-">(<<^)</a> :: <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => a c d -> (b -> c) -> a b d</li><li class="src short"><a href="#v:-94--60--60-">(^<<)</a> :: <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => (c -> d) -> a b c -> a b d</li><li class="src short"><span class="keyword">class</span> <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => <a href="#t:ArrowZero">ArrowZero</a> a <span class="keyword">where</span><ul class="subs"><li><a href="#v:zeroArrow">zeroArrow</a> :: a b c</li></ul></li><li class="src short"><span class="keyword">class</span> <a href="Control-Arrow.html#t:ArrowZero">ArrowZero</a> a => <a href="#t:ArrowPlus">ArrowPlus</a> a <span class="keyword">where</span><ul class="subs"><li><a href="#v:-60--43--62-">(<+>)</a> :: a b c -> a b c -> a b c</li></ul></li><li class="src short"><span class="keyword">class</span> <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => <a href="#t:ArrowChoice">ArrowChoice</a> a <span class="keyword">where</span><ul class="subs"><li><a href="#v:left">left</a> :: a b c -> a (<a href="Data-Either.html#t:Either">Either</a> b d) (<a href="Data-Either.html#t:Either">Either</a> c d)</li><li><a href="#v:right">right</a> :: a b c -> a (<a href="Data-Either.html#t:Either">Either</a> d b) (<a href="Data-Either.html#t:Either">Either</a> d c)</li><li><a href="#v:-43--43--43-">(+++)</a> :: a b c -> a b' c' -> a (<a href="Data-Either.html#t:Either">Either</a> b b') (<a href="Data-Either.html#t:Either">Either</a> c c')</li><li><a href="#v:-124--124--124-">(|||)</a> :: a b d -> a c d -> a (<a href="Data-Either.html#t:Either">Either</a> b c) d</li></ul></li><li class="src short"><span class="keyword">class</span> <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => <a href="#t:ArrowApply">ArrowApply</a> a <span class="keyword">where</span><ul class="subs"><li><a href="#v:app">app</a> :: a (a b c, b) c</li></ul></li><li class="src short"><span class="keyword">newtype</span> <a href="#t:ArrowMonad">ArrowMonad</a> a b = <a href="#v:ArrowMonad">ArrowMonad</a> (a <a href="../ghc-prim-0.2.0.0/GHC-Tuple.html#t:-40--41-">()</a> b)</li><li class="src short"><a href="#v:leftApp">leftApp</a> :: <a href="Control-Arrow.html#t:ArrowApply">ArrowApply</a> a => a b c -> a (<a href="Data-Either.html#t:Either">Either</a> b d) (<a href="Data-Either.html#t:Either">Either</a> c d)</li><li class="src short"><span class="keyword">class</span> <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => <a href="#t:ArrowLoop">ArrowLoop</a> a <span class="keyword">where</span><ul class="subs"><li><a href="#v:loop">loop</a> :: a (b, d) (c, d) -> a b c</li></ul></li></ul></div><div id="interface"><h1 id="g:1">Arrows
</h1><div class="top"><p class="src"><span class="keyword">class</span> <a href="Control-Category.html#t:Category">Category</a> a => <a name="t:Arrow" class="def">Arrow</a> a <span class="keyword">where</span></p><div class="doc"><p>The basic arrow class.
</p><p>Minimal complete definition: <code><a href="Control-Arrow.html#v:arr">arr</a></code> and <code><a href="Control-Arrow.html#v:first">first</a></code>, satisfying the laws
</p><ul><li><pre><code><a href="Control-Arrow.html#v:arr">arr</a></code> id = <code><a href="Control-Category.html#v:id">id</a></code></pre></li><li><pre><code><a href="Control-Arrow.html#v:arr">arr</a></code> (f >>> g) = <code><a href="Control-Arrow.html#v:arr">arr</a></code> f >>> <code><a href="Control-Arrow.html#v:arr">arr</a></code> g</pre></li><li><pre><code><a href="Control-Arrow.html#v:first">first</a></code> (<code><a href="Control-Arrow.html#v:arr">arr</a></code> f) = <code><a href="Control-Arrow.html#v:arr">arr</a></code> (<code><a href="Control-Arrow.html#v:first">first</a></code> f)</pre></li><li><pre><code><a href="Control-Arrow.html#v:first">first</a></code> (f >>> g) = <code><a href="Control-Arrow.html#v:first">first</a></code> f >>> <code><a href="Control-Arrow.html#v:first">first</a></code> g</pre></li><li><pre><code><a href="Control-Arrow.html#v:first">first</a></code> f >>> <code><a href="Control-Arrow.html#v:arr">arr</a></code> <code><a href="Data-Tuple.html#v:fst">fst</a></code> = <code><a href="Control-Arrow.html#v:arr">arr</a></code> <code><a href="Data-Tuple.html#v:fst">fst</a></code> >>> f</pre></li><li><pre><code><a href="Control-Arrow.html#v:first">first</a></code> f >>> <code><a href="Control-Arrow.html#v:arr">arr</a></code> (<code><a href="Control-Category.html#v:id">id</a></code> *** g) = <code><a href="Control-Arrow.html#v:arr">arr</a></code> (<code><a href="Control-Category.html#v:id">id</a></code> *** g) >>> <code><a href="Control-Arrow.html#v:first">first</a></code> f</pre></li><li><pre><code><a href="Control-Arrow.html#v:first">first</a></code> (<code><a href="Control-Arrow.html#v:first">first</a></code> f) >>> <code><a href="Control-Arrow.html#v:arr">arr</a></code> <code>assoc</code> = <code><a href="Control-Arrow.html#v:arr">arr</a></code> <code>assoc</code> >>> <code><a href="Control-Arrow.html#v:first">first</a></code> f</pre></li></ul><p>where
</p><pre> assoc ((a,b),c) = (a,(b,c))
</pre><p>The other combinators have sensible default definitions,
which may be overridden for efficiency.
</p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:arr" class="def">arr</a> :: (b -> c) -> a b c</p><div class="doc"><p>Lift a function to an arrow.
</p></div><p class="src"><a name="v:first" class="def">first</a> :: a b c -> a (b, d) (c, d)</p><div class="doc"><p>Send the first component of the input through the argument
arrow, and copy the rest unchanged to the output.
</p></div><p class="src"><a name="v:second" class="def">second</a> :: a b c -> a (d, b) (d, c)</p><div class="doc"><p>A mirror image of <code><a href="Control-Arrow.html#v:first">first</a></code>.
</p><p>The default definition may be overridden with a more efficient
version if desired.
</p></div><p class="src"><a name="v:-42--42--42-" class="def">(***)</a> :: a b c -> a b' c' -> a (b, b') (c, c')</p><div class="doc"><p>Split the input between the two argument arrows and combine
their output. Note that this is in general not a functor.
</p><p>The default definition may be overridden with a more efficient
version if desired.
</p></div><p class="src"><a name="v:-38--38--38-" class="def">(&&&)</a> :: a b c -> a b c' -> a b (c, c')</p><div class="doc"><p>Fanout: send the input to both argument arrows and combine
their output.
</p><p>The default definition may be overridden with a more efficient
version if desired.
</p></div></div><div class="subs instances"><p id="control.i:Arrow" class="caption collapser" onclick="toggleSection('i:Arrow')">Instances</p><div id="section.i:Arrow" class="show"><table><tr><td class="src"><a href="Control-Arrow.html#t:Arrow">Arrow</a> (->)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Control-Arrow.html#t:Arrow">Arrow</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">newtype</span> <a name="t:Kleisli" class="def">Kleisli</a> m a b </p><div class="doc"><p>Kleisli arrows of a monad.
</p></div><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:Kleisli" class="def">Kleisli</a></td><td class="doc empty"> </td></tr><tr><td colspan="2"><div class="subs fields"><p class="caption">Fields</p><dl><dt class="src"><a name="v:runKleisli" class="def">runKleisli</a> :: a -> m b</dt><dd class="doc empty"> </dd></dl><div class="clear"></div></div></td></tr></table></div><div class="subs instances"><p id="control.i:Kleisli" class="caption collapser" onclick="toggleSection('i:Kleisli')">Instances</p><div id="section.i:Kleisli" class="show"><table><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Control-Category.html#t:Category">Category</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad-Fix.html#t:MonadFix">MonadFix</a> m => <a href="Control-Arrow.html#t:ArrowLoop">ArrowLoop</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc"><p>Beware that for many monads (those for which the <code><a href="Control-Monad.html#v:-62--62--61-">>>=</a></code> operation
is strict) this instance will <em>not</em> satisfy the right-tightening law
required by the <code><a href="Control-Arrow.html#t:ArrowLoop">ArrowLoop</a></code> class.
</p></td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Control-Arrow.html#t:ArrowApply">ArrowApply</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Control-Arrow.html#t:ArrowChoice">ArrowChoice</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> m => <a href="Control-Arrow.html#t:ArrowPlus">ArrowPlus</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> m => <a href="Control-Arrow.html#t:ArrowZero">ArrowZero</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Control-Arrow.html#t:Arrow">Arrow</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr></table></div></div></div><h2 id="g:2">Derived combinators
</h2><div class="top"><p class="src"><a name="v:returnA" class="def">returnA</a> :: <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => a b b</p><div class="doc"><p>The identity arrow, which plays the role of <code><a href="Control-Monad.html#v:return">return</a></code> in arrow notation.
</p></div></div><div class="top"><p class="src"><a name="v:-94--62--62-" class="def">(^>>)</a> :: <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => (b -> c) -> a c d -> a b d</p><div class="doc"><p>Precomposition with a pure function.
</p></div></div><div class="top"><p class="src"><a name="v:-62--62--94-" class="def">(>>^)</a> :: <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => a b c -> (c -> d) -> a b d</p><div class="doc"><p>Postcomposition with a pure function.
</p></div></div><div class="top"><p class="src"><a name="v:-62--62--62-" class="def">(>>>)</a> :: <a href="Control-Category.html#t:Category">Category</a> cat => cat a b -> cat b c -> cat a c</p><div class="doc"><p>Left-to-right composition
</p></div></div><div class="top"><p class="src"><a name="v:-60--60--60-" class="def">(<<<)</a> :: <a href="Control-Category.html#t:Category">Category</a> cat => cat b c -> cat a b -> cat a c</p><div class="doc"><p>Right-to-left composition
</p></div></div><h2 id="g:3">Right-to-left variants
</h2><div class="top"><p class="src"><a name="v:-60--60--94-" class="def">(<<^)</a> :: <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => a c d -> (b -> c) -> a b d</p><div class="doc"><p>Precomposition with a pure function (right-to-left variant).
</p></div></div><div class="top"><p class="src"><a name="v:-94--60--60-" class="def">(^<<)</a> :: <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => (c -> d) -> a b c -> a b d</p><div class="doc"><p>Postcomposition with a pure function (right-to-left variant).
</p></div></div><h1 id="g:4">Monoid operations
</h1><div class="top"><p class="src"><span class="keyword">class</span> <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => <a name="t:ArrowZero" class="def">ArrowZero</a> a <span class="keyword">where</span></p><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:zeroArrow" class="def">zeroArrow</a> :: a b c</p></div><div class="subs instances"><p id="control.i:ArrowZero" class="caption collapser" onclick="toggleSection('i:ArrowZero')">Instances</p><div id="section.i:ArrowZero" class="show"><table><tr><td class="src"><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> m => <a href="Control-Arrow.html#t:ArrowZero">ArrowZero</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">class</span> <a href="Control-Arrow.html#t:ArrowZero">ArrowZero</a> a => <a name="t:ArrowPlus" class="def">ArrowPlus</a> a <span class="keyword">where</span></p><div class="doc"><p>A monoid on arrows.
</p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:-60--43--62-" class="def">(<+>)</a> :: a b c -> a b c -> a b c</p><div class="doc"><p>An associative operation with identity <code><a href="Control-Arrow.html#v:zeroArrow">zeroArrow</a></code>.
</p></div></div><div class="subs instances"><p id="control.i:ArrowPlus" class="caption collapser" onclick="toggleSection('i:ArrowPlus')">Instances</p><div id="section.i:ArrowPlus" class="show"><table><tr><td class="src"><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> m => <a href="Control-Arrow.html#t:ArrowPlus">ArrowPlus</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr></table></div></div></div><h1 id="g:5">Conditionals
</h1><div class="top"><p class="src"><span class="keyword">class</span> <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => <a name="t:ArrowChoice" class="def">ArrowChoice</a> a <span class="keyword">where</span></p><div class="doc"><p>Choice, for arrows that support it. This class underlies the
<code>if</code> and <code>case</code> constructs in arrow notation.
Minimal complete definition: <code><a href="Control-Arrow.html#v:left">left</a></code>, satisfying the laws
</p><ul><li><pre><code><a href="Control-Arrow.html#v:left">left</a></code> (<code><a href="Control-Arrow.html#v:arr">arr</a></code> f) = <code><a href="Control-Arrow.html#v:arr">arr</a></code> (<code><a href="Control-Arrow.html#v:left">left</a></code> f)</pre></li><li><pre><code><a href="Control-Arrow.html#v:left">left</a></code> (f >>> g) = <code><a href="Control-Arrow.html#v:left">left</a></code> f >>> <code><a href="Control-Arrow.html#v:left">left</a></code> g</pre></li><li><pre><code><a href="Control-Arrow.html#v:left">left</a></code> f >>> <code><a href="Control-Arrow.html#v:arr">arr</a></code> <code><a href="Data-Either.html#v:Left">Left</a></code> = <code><a href="Control-Arrow.html#v:arr">arr</a></code> <code><a href="Data-Either.html#v:Left">Left</a></code> >>> f</pre></li><li><pre><code><a href="Control-Arrow.html#v:left">left</a></code> f >>> <code><a href="Control-Arrow.html#v:arr">arr</a></code> (<code><a href="Control-Category.html#v:id">id</a></code> +++ g) = <code><a href="Control-Arrow.html#v:arr">arr</a></code> (<code><a href="Control-Category.html#v:id">id</a></code> +++ g) >>> <code><a href="Control-Arrow.html#v:left">left</a></code> f</pre></li><li><pre><code><a href="Control-Arrow.html#v:left">left</a></code> (<code><a href="Control-Arrow.html#v:left">left</a></code> f) >>> <code><a href="Control-Arrow.html#v:arr">arr</a></code> <code>assocsum</code> = <code><a href="Control-Arrow.html#v:arr">arr</a></code> <code>assocsum</code> >>> <code><a href="Control-Arrow.html#v:left">left</a></code> f</pre></li></ul><p>where
</p><pre> assocsum (Left (Left x)) = Left x
assocsum (Left (Right y)) = Right (Left y)
assocsum (Right z) = Right (Right z)
</pre><p>The other combinators have sensible default definitions, which may
be overridden for efficiency.
</p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:left" class="def">left</a> :: a b c -> a (<a href="Data-Either.html#t:Either">Either</a> b d) (<a href="Data-Either.html#t:Either">Either</a> c d)</p><div class="doc"><p>Feed marked inputs through the argument arrow, passing the
rest through unchanged to the output.
</p></div><p class="src"><a name="v:right" class="def">right</a> :: a b c -> a (<a href="Data-Either.html#t:Either">Either</a> d b) (<a href="Data-Either.html#t:Either">Either</a> d c)</p><div class="doc"><p>A mirror image of <code><a href="Control-Arrow.html#v:left">left</a></code>.
</p><p>The default definition may be overridden with a more efficient
version if desired.
</p></div><p class="src"><a name="v:-43--43--43-" class="def">(+++)</a> :: a b c -> a b' c' -> a (<a href="Data-Either.html#t:Either">Either</a> b b') (<a href="Data-Either.html#t:Either">Either</a> c c')</p><div class="doc"><p>Split the input between the two argument arrows, retagging
and merging their outputs.
Note that this is in general not a functor.
</p><p>The default definition may be overridden with a more efficient
version if desired.
</p></div><p class="src"><a name="v:-124--124--124-" class="def">(|||)</a> :: a b d -> a c d -> a (<a href="Data-Either.html#t:Either">Either</a> b c) d</p><div class="doc"><p>Fanin: Split the input between the two argument arrows and
merge their outputs.
</p><p>The default definition may be overridden with a more efficient
version if desired.
</p></div></div><div class="subs instances"><p id="control.i:ArrowChoice" class="caption collapser" onclick="toggleSection('i:ArrowChoice')">Instances</p><div id="section.i:ArrowChoice" class="show"><table><tr><td class="src"><a href="Control-Arrow.html#t:ArrowChoice">ArrowChoice</a> (->)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Control-Arrow.html#t:ArrowChoice">ArrowChoice</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr></table></div></div></div><h1 id="g:6">Arrow application
</h1><div class="top"><p class="src"><span class="keyword">class</span> <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => <a name="t:ArrowApply" class="def">ArrowApply</a> a <span class="keyword">where</span></p><div class="doc"><p>Some arrows allow application of arrow inputs to other inputs.
Instances should satisfy the following laws:
</p><ul><li><pre><code><a href="Control-Arrow.html#v:first">first</a></code> (<code><a href="Control-Arrow.html#v:arr">arr</a></code> (\x -> <code><a href="Control-Arrow.html#v:arr">arr</a></code> (\y -> (x,y)))) >>> <code><a href="Control-Arrow.html#v:app">app</a></code> = <code><a href="Control-Category.html#v:id">id</a></code></pre></li><li><pre><code><a href="Control-Arrow.html#v:first">first</a></code> (<code><a href="Control-Arrow.html#v:arr">arr</a></code> (g >>>)) >>> <code><a href="Control-Arrow.html#v:app">app</a></code> = <code><a href="Control-Arrow.html#v:second">second</a></code> g >>> <code><a href="Control-Arrow.html#v:app">app</a></code></pre></li><li><pre><code><a href="Control-Arrow.html#v:first">first</a></code> (<code><a href="Control-Arrow.html#v:arr">arr</a></code> (>>> h)) >>> <code><a href="Control-Arrow.html#v:app">app</a></code> = <code><a href="Control-Arrow.html#v:app">app</a></code> >>> h</pre></li></ul><p>Such arrows are equivalent to monads (see <code><a href="Control-Arrow.html#t:ArrowMonad">ArrowMonad</a></code>).
</p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:app" class="def">app</a> :: a (a b c, b) c</p></div><div class="subs instances"><p id="control.i:ArrowApply" class="caption collapser" onclick="toggleSection('i:ArrowApply')">Instances</p><div id="section.i:ArrowApply" class="show"><table><tr><td class="src"><a href="Control-Arrow.html#t:ArrowApply">ArrowApply</a> (->)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Control-Arrow.html#t:ArrowApply">ArrowApply</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc empty"> </td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">newtype</span> <a name="t:ArrowMonad" class="def">ArrowMonad</a> a b </p><div class="doc"><p>The <code><a href="Control-Arrow.html#t:ArrowApply">ArrowApply</a></code> class is equivalent to <code><a href="Control-Monad.html#t:Monad">Monad</a></code>: any monad gives rise
to a <code><a href="Control-Arrow.html#t:Kleisli">Kleisli</a></code> arrow, and any instance of <code><a href="Control-Arrow.html#t:ArrowApply">ArrowApply</a></code> defines a monad.
</p></div><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:ArrowMonad" class="def">ArrowMonad</a> (a <a href="../ghc-prim-0.2.0.0/GHC-Tuple.html#t:-40--41-">()</a> b)</td><td class="doc empty"> </td></tr></table></div><div class="subs instances"><p id="control.i:ArrowMonad" class="caption collapser" onclick="toggleSection('i:ArrowMonad')">Instances</p><div id="section.i:ArrowMonad" class="show"><table><tr><td class="src"><a href="Control-Arrow.html#t:ArrowApply">ArrowApply</a> a => <a href="Control-Monad.html#t:Monad">Monad</a> (<a href="Control-Arrow.html#t:ArrowMonad">ArrowMonad</a> a)</td><td class="doc empty"> </td></tr></table></div></div></div><div class="top"><p class="src"><a name="v:leftApp" class="def">leftApp</a> :: <a href="Control-Arrow.html#t:ArrowApply">ArrowApply</a> a => a b c -> a (<a href="Data-Either.html#t:Either">Either</a> b d) (<a href="Data-Either.html#t:Either">Either</a> c d)</p><div class="doc"><p>Any instance of <code><a href="Control-Arrow.html#t:ArrowApply">ArrowApply</a></code> can be made into an instance of
<code><a href="Control-Arrow.html#t:ArrowChoice">ArrowChoice</a></code> by defining <code><a href="Control-Arrow.html#v:left">left</a></code> = <code><a href="Control-Arrow.html#v:leftApp">leftApp</a></code>.
</p></div></div><h1 id="g:7">Feedback
</h1><div class="top"><p class="src"><span class="keyword">class</span> <a href="Control-Arrow.html#t:Arrow">Arrow</a> a => <a name="t:ArrowLoop" class="def">ArrowLoop</a> a <span class="keyword">where</span></p><div class="doc"><p>The <code><a href="Control-Arrow.html#v:loop">loop</a></code> operator expresses computations in which an output value
is fed back as input, although the computation occurs only once.
It underlies the <code>rec</code> value recursion construct in arrow notation.
<code><a href="Control-Arrow.html#v:loop">loop</a></code> should satisfy the following laws:
</p><dl><dt><em>extension</em></dt><dd>
<code><code><a href="Control-Arrow.html#v:loop">loop</a></code> (<code><a href="Control-Arrow.html#v:arr">arr</a></code> f) = <code><a href="Control-Arrow.html#v:arr">arr</a></code> (\ b -> <code><a href="Data-Tuple.html#v:fst">fst</a></code> (<code><a href="Data-Function.html#v:fix">fix</a></code> (\ (c,d) -> f (b,d))))</code>
</dd><dt><em>left tightening</em></dt><dd>
<code><code><a href="Control-Arrow.html#v:loop">loop</a></code> (<code><a href="Control-Arrow.html#v:first">first</a></code> h >>> f) = h >>> <code><a href="Control-Arrow.html#v:loop">loop</a></code> f</code>
</dd><dt><em>right tightening</em></dt><dd>
<code><code><a href="Control-Arrow.html#v:loop">loop</a></code> (f >>> <code><a href="Control-Arrow.html#v:first">first</a></code> h) = <code><a href="Control-Arrow.html#v:loop">loop</a></code> f >>> h</code>
</dd><dt><em>sliding</em></dt><dd>
<code><code><a href="Control-Arrow.html#v:loop">loop</a></code> (f >>> <code><a href="Control-Arrow.html#v:arr">arr</a></code> (<code><a href="Control-Category.html#v:id">id</a></code> *** k)) = <code><a href="Control-Arrow.html#v:loop">loop</a></code> (<code><a href="Control-Arrow.html#v:arr">arr</a></code> (<code><a href="Control-Category.html#v:id">id</a></code> *** k) >>> f)</code>
</dd><dt><em>vanishing</em></dt><dd>
<code><code><a href="Control-Arrow.html#v:loop">loop</a></code> (<code><a href="Control-Arrow.html#v:loop">loop</a></code> f) = <code><a href="Control-Arrow.html#v:loop">loop</a></code> (<code><a href="Control-Arrow.html#v:arr">arr</a></code> unassoc >>> f >>> <code><a href="Control-Arrow.html#v:arr">arr</a></code> assoc)</code>
</dd><dt><em>superposing</em></dt><dd>
<code><code><a href="Control-Arrow.html#v:second">second</a></code> (<code><a href="Control-Arrow.html#v:loop">loop</a></code> f) = <code><a href="Control-Arrow.html#v:loop">loop</a></code> (<code><a href="Control-Arrow.html#v:arr">arr</a></code> assoc >>> <code><a href="Control-Arrow.html#v:second">second</a></code> f >>> <code><a href="Control-Arrow.html#v:arr">arr</a></code> unassoc)</code>
</dd></dl><p>where
</p><pre> assoc ((a,b),c) = (a,(b,c))
unassoc (a,(b,c)) = ((a,b),c)
</pre></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:loop" class="def">loop</a> :: a (b, d) (c, d) -> a b c</p></div><div class="subs instances"><p id="control.i:ArrowLoop" class="caption collapser" onclick="toggleSection('i:ArrowLoop')">Instances</p><div id="section.i:ArrowLoop" class="show"><table><tr><td class="src"><a href="Control-Arrow.html#t:ArrowLoop">ArrowLoop</a> (->)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad-Fix.html#t:MonadFix">MonadFix</a> m => <a href="Control-Arrow.html#t:ArrowLoop">ArrowLoop</a> (<a href="Control-Arrow.html#t:Kleisli">Kleisli</a> m)</td><td class="doc"><p>Beware that for many monads (those for which the <code><a href="Control-Monad.html#v:-62--62--61-">>>=</a></code> operation
is strict) this instance will <em>not</em> satisfy the right-tightening law
required by the <code><a href="Control-Arrow.html#t:ArrowLoop">ArrowLoop</a></code> class.
</p></td></tr></table></div></div></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.11.0</p></div></body></html>
distrib
>
Mageia
>
5
>
i586
>
media
>
core-release
>
by-pkgid
>
6e204a966e8c42d976f99a1700ce5f20
>
files
>
2213
