-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Arrow based stream transducers
--   
--   Stream processing library similar to pipes, couduit, or machines.
--   
--   Arrow combinatins are supported and can be used with the arrow
--   notation. AFRP-like utilities are also available.
--   
--   A quick introduction is available in the Control.Arrow.Machine
--   documentation.
@package machinecell
@version 4.0.0


-- | Arrow utilities not related to machinecell library.
module Control.Arrow.Machine.ArrowUtil
ary0 :: (forall p q. (p -> m q) -> a p q) -> m b -> a () b
ary1 :: (forall p q. (p -> m q) -> a p q) -> (a1 -> m b) -> a a1 b
ary2 :: (forall p q. (p -> m q) -> a p q) -> (a1 -> a2 -> m b) -> a (a1, a2) b
ary3 :: (forall p q. (p -> m q) -> a p q) -> (a1 -> a2 -> a3 -> m b) -> a (a1, a2, a3) b
ary4 :: (forall p q. (p -> m q) -> a p q) -> (a1 -> a2 -> a3 -> a4 -> m b) -> a (a1, a2, a3, a4) b
ary5 :: (forall p q. (p -> m q) -> a p q) -> (a1 -> a2 -> a3 -> a4 -> a5 -> m b) -> a (a1, a2, a3, a4, a5) b
kleisli :: Monad m => (a -> m b) -> Kleisli m a b
kleisli0 :: Monad m => m b -> Kleisli m () b
kleisli2 :: Monad m => (a1 -> a2 -> m b) -> Kleisli m (a1, a2) b
kleisli3 :: Monad m => (a1 -> a2 -> a3 -> m b) -> Kleisli m (a1, a2, a3) b
kleisli4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> m b) -> Kleisli m (a1, a2, a3, a4) b
kleisli5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> m b) -> Kleisli m (a1, a2, a3, a4, a5) b
unArrowMonad :: ArrowApply a => (p -> ArrowMonad a q) -> a p q
arrowMonad :: ArrowApply a => a p q -> p -> ArrowMonad a q

-- | Isomorphsm between m and (Kleisli m)
kl :: MyIso' (a -> m b) (Kleisli m a b)

-- | Isomorphism between (ArrowMonad a) and a
am :: ArrowApply a => MyIso' (b -> ArrowMonad a c) (a b c)
uc0 :: MyIso' (m b) (() -> m b)
uc1 :: MyIso' (a1 -> m b) (a1 -> m b)
uc2 :: MyIso' (a1 -> a2 -> m b) ((a1, a2) -> m b)
uc3 :: MyIso' (a1 -> a2 -> a3 -> m b) ((a1, a2, a3) -> m b)
uc4 :: MyIso' (a1 -> a2 -> a3 -> a4 -> m b) ((a1, a2, a3, a4) -> m b)
uc5 :: MyIso' (a1 -> a2 -> a3 -> a4 -> a5 -> m b) ((a1, a2, a3, a4, a5) -> m b)
type AS e = (e, ())
toAS :: e -> AS e
fromAS :: AS e -> e

module Control.Arrow.Machine.Types

-- | The stream transducer arrow.
--   
--   To construct <a>ProcessT</a> instances, use <a>Plan</a>, <a>arr</a>,
--   functions declared in <a>Utils</a>, or arrow combinations of them.
--   
--   See an introduction at <a>Control.Arrow.Machine</a> documentation.
data ProcessT m b c

-- | Isomorphic to ProcessT when <tt>a</tt> is ArrowApply.
type ProcessA a = ProcessT (ArrowMonad a)

-- | Signals that can be absent(<a>NoEvent</a>) or end. For composite
--   structure, <a>collapse</a> can be defined as monoid sum of all member
--   occasionals.
class Occasional' a
collapse :: Occasional' a => a -> Event ()

-- | Occasional signals with creation methods.
class Occasional' a => Occasional a
burst :: Occasional a => Event Void -> a

-- | Discrete events on a time line. Created and consumed by various
--   transducers.
data Event a
noEvent :: Occasional a => a
end :: Occasional a => a
data ZeroEvent
ZeroEvent :: ZeroEvent
condEvent :: Bool -> Event a -> Event a
filterEvent :: Arrow ar => (a -> Bool) -> ar (Event a) (Event a)
filterJust :: Arrow ar => ar (Event (Maybe a)) (Event a)

-- | Split an event stream.
--   
--   <pre>
--   &gt;&gt;&gt; run (filterLeft) [Left 1, Right 2, Left 3, Right 4]
--   [1,3]
--   </pre>
filterLeft :: Arrow ar => ar (Event (Either a b)) (Event a)

-- | Split an event stream.
--   
--   <pre>
--   &gt;&gt;&gt; run filterRight [Left 1, Right 2, Left 3, Right 4]
--   [2,4]
--   </pre>
filterRight :: Arrow ar => ar (Event (Either a b)) (Event b)

-- | Split an event stream.
--   
--   <pre>
--   &gt;&gt;&gt; run (splitEvent &gt;&gt;&gt; arr fst) [Left 1, Right 2, Left 3, Right 4]
--   [1,3]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; run (splitEvent &gt;&gt;&gt; arr snd) [Left 1, Right 2, Left 3, Right 4]
--   [2,4]
--   </pre>
splitEvent :: Arrow ar => ar (Event (Either a b)) (Event a, Event b)

-- | Alias of "arr . fmap"
--   
--   While "ProcessT a (Event b) (Event c)" means a transducer from b to c,
--   function b-&gt;c can be lifted into a transducer by fhis function.
--   
--   But in most cases you needn't call this function in proc-do notations,
--   because <a>arr</a>s are completed automatically while desugaring.
--   
--   For example,
--   
--   <pre>
--   proc x -&gt; returnA -&lt; f &lt;$&gt; x
--   </pre>
--   
--   is equivalent to
--   
--   <pre>
--   evMap f
--   </pre>
evMap :: Arrow a => (b -> c) -> a (Event b) (Event c)
newtype PlanT i o m a
PlanT :: FT (PlanF i o) m a -> PlanT i o m a
[freePlanT] :: PlanT i o m a -> FT (PlanF i o) m a
type Plan i o a = forall m. Monad m => PlanT i o m a
class MonadAwait m a | m -> a
await :: MonadAwait m a => m a
class MonadYield m a | m -> a
yield :: MonadYield m a => a -> m ()
class MonadStop m
stop :: MonadStop m => m a
catchP :: Monad m => PlanT i o m a -> PlanT i o m a -> PlanT i o m a
stopped :: (Monad m, Occasional o) => ProcessT m i o
muted :: (Monad m, Occasional' b, Occasional c) => ProcessT m b c
constructT :: (Monad m) => PlanT i o m r -> ProcessT m (Event i) (Event o)
repeatedlyT :: Monad m => PlanT i o m r -> ProcessT m (Event i) (Event o)
construct :: Monad m => PlanT i o Identity r -> ProcessT m (Event i) (Event o)
repeatedly :: Monad m => PlanT i o Identity r -> ProcessT m (Event i) (Event o)

-- | A monad type represents time evolution of ProcessT
newtype Evolution i o m r
Evolution :: Cont (ProcessT m i o) r -> Evolution i o m r
[runEvolution] :: Evolution i o m r -> Cont (ProcessT m i o) r
packProc :: (Monad m, Occasional o) => m (ProcessT m i o) -> ProcessT m i o
awaitProc :: (Monad m, Occasional o) => (a -> ProcessT m (Event a) o) -> ProcessT m (Event a) o -> ProcessT m (Event a) o
yieldProc :: Monad m => a -> ProcessT m i (Event a) -> ProcessT m i (Event a)

-- | Run a machine.
runT :: (Monad m, Foldable f) => (c -> m ()) -> ProcessT m (Event b) (Event c) -> f b -> m ()

-- | Run a machine discarding all results.
runT_ :: (Monad m, Foldable f) => ProcessT m (Event a) (Event b) -> f a -> m ()
run :: Foldable f => ProcessT Identity (Event a) (Event b) -> f a -> [b]
run_ :: (Foldable f, ArrowApply a) => ProcessA a (Event b) (Event c) -> a (f b) ()

-- | Execute until an input consumed and the machine suspends.
--   
--   During the execution, the machine may yield values or stops. It can be
--   handled by two callbacks.
--   
--   In some case the machine failed to consume the input value. If so, the
--   value is passed to the termination callback.
stepRun :: (Monad m, Monad m') => (forall p. m p -> m' p) -> (b -> m' ()) -> (Maybe a -> m' ()) -> ProcessT m (Event a) (Event b) -> a -> m' (ProcessT m (Event a) (Event b))

-- | Execute until an output produced.
--   
--   During the execution, the machine may await values or stops. It can be
--   handled by two callbacks.
--   
--   If the machine stops without producing any value, The first element of
--   the return tuple is <a>Nothing</a>.
stepYield :: (Monad m, Monad m') => (forall p. m p -> m' p) -> m' a -> m' () -> ProcessT m (Event a) (Event b) -> m' (Maybe b, ProcessT m (Event a) (Event b))

-- | Run the 1st transducer at the beggining. Then switch to 2nd when Event
--   t occurs.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--       before = proc x -&gt;
--         do
--           trigger &lt;- filterEvent (== 3) -&lt; x
--           returnA -&lt; ((*10) &lt;$&gt; x, trigger)
--       after t = proc x -&gt; returnA -&lt; (*100) &lt;$&gt; x
--    in
--       run (switch before after) [1..5]
--   :}
--   [10,20,300,400,500]
--   </pre>
switch :: Monad m => ProcessT m b (c, Event t) -> (t -> ProcessT m b c) -> ProcessT m b c

-- | Delayed version of <a>switch</a>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--       before = proc x -&gt;
--         do
--           trigger &lt;- filterEvent (== 3) -&lt; x
--           returnA -&lt; ((*10) &lt;$&gt; x, trigger)
--       after t = proc x -&gt; returnA -&lt; (*100) &lt;$&gt; x
--    in
--       run (dSwitch before after) [1..5]
--   :}
--   [10,20,30,400,500]
--   </pre>
dSwitch :: Monad m => ProcessT m b (c, Event t) -> (t -> ProcessT m b c) -> ProcessT m b c

-- | Recurring switch.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let pa = proc evtp -&gt;
--         do
--           evx &lt;- returnA -&lt; fst &lt;$&gt; evtp
--           evarr &lt;- filterJust -&lt; snd &lt;$&gt; evtp
--           rSwitch (evMap (*10)) -&lt; (evx, evarr)
--       l = [(1, Nothing),
--            (2, Just (arr $ fmap (*100))),
--            (3, Nothing),
--            (4, Just (arr $ fmap (*1000))),
--            (5, Nothing)]
--     in
--       run pa l
--   :}
--   [10,200,300,4000,5000]
--   </pre>
rSwitch :: Monad m => ProcessT m b c -> ProcessT m (b, Event (ProcessT m b c)) c

-- | Delayed version of <a>rSwitch</a>.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let pa = proc evtp -&gt;
--         do
--           evx &lt;- returnA -&lt; fst &lt;$&gt; evtp
--           evarr &lt;- filterJust -&lt; snd &lt;$&gt; evtp
--           drSwitch (evMap (*10)) -&lt; (evx, evarr)
--       l = [(1, Nothing),
--            (2, Just (arr $ fmap (*100))),
--            (3, Nothing),
--            (4, Just (arr $ fmap (*1000))),
--            (5, Nothing)]
--     in
--       run pa l
--   :}
--   [10,20,300,400,5000]
--   </pre>
drSwitch :: Monad m => ProcessT m b c -> ProcessT m (b, Event (ProcessT m b c)) c
kSwitch :: Monad m => ProcessT m b c -> ProcessT m (b, c) (Event t) -> (ProcessT m b c -> t -> ProcessT m b c) -> ProcessT m b c
dkSwitch :: Monad m => ProcessT m b c -> ProcessT m (b, c) (Event t) -> (ProcessT m b c -> t -> ProcessT m b c) -> ProcessT m b c
gSwitch :: Monad m => ProcessT m b (p, r) -> ProcessT m p q -> ProcessT m (q, r) (c, Event t) -> (ProcessT m p q -> t -> ProcessT m b c) -> ProcessT m b c
dgSwitch :: Monad m => ProcessT m b (p, r) -> ProcessT m p q -> ProcessT m (q, r) (c, Event t) -> (ProcessT m p q -> t -> ProcessT m b c) -> ProcessT m b c
pSwitch :: (Monad m, Traversable col) => (forall sf. (b -> col sf -> col (ext, sf))) -> col (ProcessT m ext c) -> ProcessT m (b, col c) (Event mng) -> (col (ProcessT m ext c) -> mng -> ProcessT m b (col c)) -> ProcessT m b (col c)
pSwitchB :: (Monad m, Traversable col) => col (ProcessT m b c) -> ProcessT m (b, col c) (Event mng) -> (col (ProcessT m b c) -> mng -> ProcessT m b (col c)) -> ProcessT m b (col c)
dpSwitch :: (Monad m, Traversable col) => (forall sf. (b -> col sf -> col (ext, sf))) -> col (ProcessT m ext c) -> ProcessT m (b, col c) (Event mng) -> (col (ProcessT m ext c) -> mng -> ProcessT m b (col c)) -> ProcessT m b (col c)
dpSwitchB :: (Monad m, Traversable col) => col (ProcessT m b c) -> ProcessT m (b, col c) (Event mng) -> (col (ProcessT m b c) -> mng -> ProcessT m b (col c)) -> ProcessT m b (col c)
rpSwitch :: (Monad m, Traversable col) => (forall sf. (b -> col sf -> col (ext, sf))) -> col (ProcessT m ext c) -> ProcessT m (b, Event (col (ProcessT m ext c) -> col (ProcessT m ext c))) (col c)
rpSwitchB :: (Monad m, Traversable col) => col (ProcessT m b c) -> ProcessT m (b, Event (col (ProcessT m b c) -> col (ProcessT m b c))) (col c)
drpSwitch :: (Monad m, Traversable col) => (forall sf. (b -> col sf -> col (ext, sf))) -> col (ProcessT m ext c) -> ProcessT m (b, Event (col (ProcessT m ext c) -> col (ProcessT m ext c))) (col c)
drpSwitchB :: (Monad m, Traversable col) => col (ProcessT m b c) -> ProcessT m (b, Event (col (ProcessT m b c) -> col (ProcessT m b c))) (col c)
par :: (Monad m, Traversable col) => (forall sf. (b -> col sf -> col (ext, sf))) -> col (ProcessT m ext c) -> ProcessT m b (col c)
parB :: (Monad m, Traversable col) => col (ProcessT m b c) -> ProcessT m b (col c)

-- | Natural transformation
fit :: (Monad m, Monad m') => (forall p. m p -> m' p) -> ProcessT m b c -> ProcessT m' b c

-- | Experimental: more general fit.
--   
--   Should w be a comonad?
fitW :: (Monad m, Monad m', Functor w) => (forall p. w p -> p) -> (forall p q. (p -> m q) -> w p -> m' q) -> ProcessT m b c -> ProcessT m' (w b) c

-- | Repeatedly call <tt>p</tt>.
--   
--   How many times <tt>p</tt> is called is indefinite. So <tt>p</tt> must
--   satisfy the equation below;
--   
--   <pre>
--   p &amp;&amp;&amp; (p &gt;&gt;&gt; arr null) === p &amp;&amp;&amp; arr (const True)
--   </pre>
--   
--   where
--   
--   <pre>
--   null = getAll . foldMap (_ -&gt; All False)
--   </pre>
unsafeExhaust :: (Monad m, Foldable f) => (b -> m (f c)) -> ProcessT m b (Event c)
instance GHC.Base.Monad (Control.Arrow.Machine.Types.PlanT i o m)
instance GHC.Base.Applicative (Control.Arrow.Machine.Types.PlanT i o m)
instance GHC.Base.Functor (Control.Arrow.Machine.Types.PlanT i o m)
instance GHC.Base.Monad (Control.Arrow.Machine.Types.Evolution i o m)
instance GHC.Base.Applicative (Control.Arrow.Machine.Types.Evolution i o m)
instance GHC.Base.Functor (Control.Arrow.Machine.Types.Evolution i o m)
instance GHC.Enum.Bounded Control.Arrow.Machine.Types.ZeroEvent
instance GHC.Enum.Enum Control.Arrow.Machine.Types.ZeroEvent
instance GHC.Show.Show Control.Arrow.Machine.Types.ZeroEvent
instance GHC.Classes.Eq Control.Arrow.Machine.Types.ZeroEvent
instance GHC.Show.Show Control.Arrow.Machine.Types.Phase
instance GHC.Classes.Eq Control.Arrow.Machine.Types.Phase
instance (GHC.Base.Monad m, Data.Traversable.Traversable col) => Control.Arrow.Machine.Types.Stepper m b (col c) (Control.Arrow.Machine.Types.PluralStep ext col m b c)
instance GHC.Base.Monad m => GHC.Base.Alternative (Control.Arrow.Machine.Types.PlanT i o m)
instance GHC.Base.Monad m => GHC.Base.MonadPlus (Control.Arrow.Machine.Types.PlanT i o m)
instance GHC.Base.Monad m => Control.Arrow.Machine.Types.MonadStop (Control.Arrow.Machine.Types.PlanT i o m)
instance (GHC.Base.Monad m, Control.Arrow.Machine.Types.Occasional o) => Control.Arrow.Machine.Types.MonadStop (Control.Arrow.Machine.Types.Evolution i o m)
instance GHC.Base.Monad m => Control.Arrow.Machine.Types.MonadYield (Control.Arrow.Machine.Types.PlanT i o m) o
instance GHC.Base.Monad m => Control.Arrow.Machine.Types.MonadYield (Control.Arrow.Machine.Types.Evolution i (Control.Arrow.Machine.Types.Event a) m) a
instance GHC.Base.Monad m => Control.Arrow.Machine.Types.MonadAwait (Control.Arrow.Machine.Types.PlanT i o m) i
instance (GHC.Base.Monad m, Control.Arrow.Machine.Types.Occasional o) => Control.Arrow.Machine.Types.MonadAwait (Control.Arrow.Machine.Types.Evolution (Control.Arrow.Machine.Types.Event a) o m) a
instance Control.Monad.Trans.Class.MonadTrans (Control.Arrow.Machine.Types.PlanT i o)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Arrow.Machine.Types.PlanT i o m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Arrow.Machine.Types.PlanT i o m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Arrow.Machine.Types.PlanT i o m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Arrow.Machine.Types.PlanT i o m)
instance GHC.Base.Functor (Control.Arrow.Machine.Types.PlanF i o)
instance Control.Arrow.Machine.Types.Occasional o => Control.Monad.Trans.Class.MonadTrans (Control.Arrow.Machine.Types.Evolution i o)
instance (Control.Monad.IO.Class.MonadIO m, Control.Arrow.Machine.Types.Occasional o) => Control.Monad.IO.Class.MonadIO (Control.Arrow.Machine.Types.Evolution i o m)
instance GHC.Base.Monoid Control.Arrow.Machine.Types.ZeroEvent
instance Control.Arrow.Machine.Types.Occasional' Control.Arrow.Machine.Types.ZeroEvent
instance (Control.Arrow.Machine.Types.Occasional a, Control.Arrow.Machine.Types.Occasional b) => Control.Arrow.Machine.Types.Occasional (a, b)
instance Control.Arrow.Machine.Types.Occasional (Control.Arrow.Machine.Types.Event a)
instance (Control.Arrow.Machine.Types.Occasional' a, Control.Arrow.Machine.Types.Occasional' b) => Control.Arrow.Machine.Types.Occasional' (a, b)
instance Control.Arrow.Machine.Types.Occasional' (Control.Arrow.Machine.Types.Event a)
instance GHC.Base.Functor Control.Arrow.Machine.Types.Event
instance Data.Semigroup.Semigroup a => GHC.Base.Monoid (Control.Arrow.Machine.Types.Event a)
instance GHC.Base.Monad m => Control.Arrow.Machine.Types.Stepper m b c (Control.Arrow.Machine.Types.ParStep m b c s1 s2)
instance GHC.Base.Monad m => Control.Arrow.Machine.Types.Stepper m b c (Control.Arrow.Machine.Types.ArrStep m b c)
instance GHC.Base.Monad m => Control.Arrow.Machine.Types.Stepper m b c (Control.Arrow.Machine.Types.IDStep m b c)
instance GHC.Base.Monad m => Control.Arrow.Machine.Types.Stepper m b c (Control.Arrow.Machine.Types.CompositeStep m b c s1 s2)
instance Control.Arrow.Machine.Types.ProcessHelper Data.Functor.Identity.Identity
instance Control.Arrow.Machine.Types.ProcessHelper GHC.Base.Maybe
instance GHC.Base.Monad m => Control.Arrow.ArrowChoice (Control.Arrow.Machine.Types.ProcessT m)
instance GHC.Base.Monad m => Control.Arrow.ArrowLoop (Control.Arrow.Machine.Types.ProcessT m)
instance Control.Arrow.Machine.Types.Stepper a b c (Control.Arrow.Machine.Types.ProcessT a b c)
instance GHC.Base.Monad m => Data.Profunctor.Unsafe.Profunctor (Control.Arrow.Machine.Types.ProcessT m)
instance GHC.Base.Monad m => GHC.Base.Functor (Control.Arrow.Machine.Types.ProcessT m i)
instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Arrow.Machine.Types.ProcessT m i)
instance (GHC.Base.Monad m, GHC.Base.Monoid o) => GHC.Base.Monoid (Control.Arrow.Machine.Types.ProcessT m i o)
instance GHC.Base.Monad m => Control.Category.Category (Control.Arrow.Machine.Types.ProcessT m)
instance GHC.Base.Monad m => Control.Arrow.Arrow (Control.Arrow.Machine.Types.ProcessT m)
instance GHC.Base.Monoid Control.Arrow.Machine.Types.Phase

module Control.Arrow.Machine.Misc.Exception
catch :: Monad m => PlanT i o m a -> PlanT i o m a -> PlanT i o m a
handle :: Monad m => PlanT i o m a -> PlanT i o m a -> PlanT i o m a
bracket :: Monad m => PlanT i o m a -> (a -> PlanT i o m b) -> (a -> PlanT i o m c) -> PlanT i o m c
bracket_ :: Monad m => PlanT i o m a -> PlanT i o m b -> PlanT i o m c -> PlanT i o m c
bracketOnError :: Monad m => PlanT i o m a -> (a -> PlanT i o m b) -> (a -> PlanT i o m c) -> PlanT i o m c
finally :: Monad m => PlanT i o m a -> PlanT i o m b -> PlanT i o m a
onException :: Monad m => PlanT i o m a -> PlanT i o m b -> PlanT i o m a

module Control.Arrow.Machine.Evolution
switchAfter :: Monad m => ProcessT m i (o, Event r) -> Evolution i o m r
dSwitchAfter :: Monad m => ProcessT m i (o, Event r) -> Evolution i o m r
kSwitchAfter :: Monad m => ProcessT m (i, o) (Event r) -> ProcessT m i o -> Evolution i o m (ProcessT m i o, r)
dkSwitchAfter :: Monad m => ProcessT m (i, o) (Event r) -> ProcessT m i o -> Evolution i o m (ProcessT m i o, r)
gSwitchAfter :: Monad m => ProcessT m i (p, r) -> ProcessT m (q, r) (o, Event t) -> ProcessT m p q -> Evolution i o m (ProcessT m p q, t)
dgSwitchAfter :: Monad m => ProcessT m i (p, r) -> ProcessT m (q, r) (o, Event t) -> ProcessT m p q -> Evolution i o m (ProcessT m p q, t)
finishWith :: Monad m => ProcessT m i o -> Evolution i o m r
evolve :: Evolution i o m Void -> ProcessT m i o

module Control.Arrow.Machine.Utils
hold :: Monad m => b -> ProcessT m (Event b) b
dHold :: Monad m => b -> ProcessT m (Event b) b

-- | Accumulate inputs like fold.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let pa = proc evx -&gt;
--         do
--           val &lt;- accum 0 -&lt; (+1) &lt;$ evx
--           returnA -&lt; val &lt;$ evx
--     in
--       run pa (replicate 10 ())
--   :}
--   [1,2,3,4,5,6,7,8,9,10]
--   </pre>
--   
--   Since 4.0.0, this function become strict for the first argument
--   because lazy one could rarely be used.
--   
--   You can make <a>switch</a>es to make lazy one.
accum :: Monad m => b -> ProcessT m (Event (b -> b)) b

-- | Delayed version of <a>accum</a>.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let pa = proc evx -&gt;
--         do
--           val &lt;- dAccum 0 -&lt; (+1) &lt;$ evx
--           returnA -&lt; val &lt;$ evx
--     in
--       run pa (replicate 10 ())
--   :}
--   [0,1,2,3,4,5,6,7,8,9]
--   </pre>
--   
--   Since 4.0.0, this function become strict for the first argument
--   because lazy one could rarely be used.
--   
--   You can make <a>switch</a>es to make lazy one.
dAccum :: Monad m => b -> ProcessT m (Event (b -> b)) b

-- | Detects edges of input behaviour.
--   
--   <pre>
--   &gt;&gt;&gt; run (hold 0 &gt;&gt;&gt; edge) [1, 1, 2, 2, 2, 3]
--   [0,1,2,3]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; run (hold 0 &gt;&gt;&gt; edge) [0, 1, 1, 2, 2, 2, 3]
--   [0,1,2,3]
--   </pre>
edge :: (Monad m, Eq b) => ProcessT m b (Event b)

-- | Run the 1st transducer at the beggining. Then switch to 2nd when Event
--   t occurs.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--       before = proc x -&gt;
--         do
--           trigger &lt;- filterEvent (== 3) -&lt; x
--           returnA -&lt; ((*10) &lt;$&gt; x, trigger)
--       after t = proc x -&gt; returnA -&lt; (*100) &lt;$&gt; x
--    in
--       run (switch before after) [1..5]
--   :}
--   [10,20,300,400,500]
--   </pre>
switch :: Monad m => ProcessT m b (c, Event t) -> (t -> ProcessT m b c) -> ProcessT m b c

-- | Delayed version of <a>switch</a>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--       before = proc x -&gt;
--         do
--           trigger &lt;- filterEvent (== 3) -&lt; x
--           returnA -&lt; ((*10) &lt;$&gt; x, trigger)
--       after t = proc x -&gt; returnA -&lt; (*100) &lt;$&gt; x
--    in
--       run (dSwitch before after) [1..5]
--   :}
--   [10,20,30,400,500]
--   </pre>
dSwitch :: Monad m => ProcessT m b (c, Event t) -> (t -> ProcessT m b c) -> ProcessT m b c

-- | Recurring switch.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let pa = proc evtp -&gt;
--         do
--           evx &lt;- returnA -&lt; fst &lt;$&gt; evtp
--           evarr &lt;- filterJust -&lt; snd &lt;$&gt; evtp
--           rSwitch (evMap (*10)) -&lt; (evx, evarr)
--       l = [(1, Nothing),
--            (2, Just (arr $ fmap (*100))),
--            (3, Nothing),
--            (4, Just (arr $ fmap (*1000))),
--            (5, Nothing)]
--     in
--       run pa l
--   :}
--   [10,200,300,4000,5000]
--   </pre>
rSwitch :: Monad m => ProcessT m b c -> ProcessT m (b, Event (ProcessT m b c)) c

-- | Delayed version of <a>rSwitch</a>.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let pa = proc evtp -&gt;
--         do
--           evx &lt;- returnA -&lt; fst &lt;$&gt; evtp
--           evarr &lt;- filterJust -&lt; snd &lt;$&gt; evtp
--           drSwitch (evMap (*10)) -&lt; (evx, evarr)
--       l = [(1, Nothing),
--            (2, Just (arr $ fmap (*100))),
--            (3, Nothing),
--            (4, Just (arr $ fmap (*1000))),
--            (5, Nothing)]
--     in
--       run pa l
--   :}
--   [10,20,300,400,5000]
--   </pre>
drSwitch :: Monad m => ProcessT m b c -> ProcessT m (b, Event (ProcessT m b c)) c
kSwitch :: Monad m => ProcessT m b c -> ProcessT m (b, c) (Event t) -> (ProcessT m b c -> t -> ProcessT m b c) -> ProcessT m b c
dkSwitch :: Monad m => ProcessT m b c -> ProcessT m (b, c) (Event t) -> (ProcessT m b c -> t -> ProcessT m b c) -> ProcessT m b c
pSwitch :: (Monad m, Traversable col) => (forall sf. (b -> col sf -> col (ext, sf))) -> col (ProcessT m ext c) -> ProcessT m (b, col c) (Event mng) -> (col (ProcessT m ext c) -> mng -> ProcessT m b (col c)) -> ProcessT m b (col c)
pSwitchB :: (Monad m, Traversable col) => col (ProcessT m b c) -> ProcessT m (b, col c) (Event mng) -> (col (ProcessT m b c) -> mng -> ProcessT m b (col c)) -> ProcessT m b (col c)
rpSwitch :: (Monad m, Traversable col) => (forall sf. (b -> col sf -> col (ext, sf))) -> col (ProcessT m ext c) -> ProcessT m (b, Event (col (ProcessT m ext c) -> col (ProcessT m ext c))) (col c)
rpSwitchB :: (Monad m, Traversable col) => col (ProcessT m b c) -> ProcessT m (b, Event (col (ProcessT m b c) -> col (ProcessT m b c))) (col c)

-- | Provides a source event stream. A dummy input event stream is needed.
--   
--   <pre>
--   run af [...]
--   </pre>
--   
--   is equivalent to
--   
--   <pre>
--   run (source [...] &gt;&gt;&gt; af) (repeat ())
--   </pre>
source :: (Monad m, Foldable f) => f a -> ProcessT m (Event i) (Event a)

-- | Provides a blocking event stream.
blockingSource :: (Monad m, Foldable f) => f a -> ProcessT m ZeroEvent (Event a)

-- | Make a blocking source interleaved.
interleave :: Monad m => ProcessT m ZeroEvent (Event a) -> ProcessT m (Event i) (Event a)

-- | Make an interleaved source blocking.
blocking :: Monad m => ProcessT m (Event ()) (Event a) -> ProcessT m ZeroEvent (Event a)

-- | Make two event streams into one. Actually <a>gather</a> is more
--   general and convenient;
--   
--   <pre>
--   ... &lt;- tee -&lt; (e1, e2)
--   </pre>
--   
--   is equivalent to
--   
--   <pre>
--   ... &lt;- gather -&lt; [Left &lt;$&gt; e1, Right &lt;$&gt; e2]
--   </pre>
tee :: Monad m => ProcessT m (Event b1, Event b2) (Event (Either b1 b2))

-- | Make multiple event channels into one. If simultaneous events are
--   given, lefter one is emitted earlier.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let pa = proc x -&gt;
--         do
--           r1 &lt;- filterEvent (\x -&gt; x `mod` 2 == 0) -&lt; x
--           r2 &lt;- filterEvent (\x -&gt; x `mod` 3 == 0) -&lt; x
--           gather -&lt; [r1, r2]
--     in
--       run pa [1..6]
--   :}
--   [2,3,4,6,6]
--   </pre>
--   
--   It is terminated when the last input finishes.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let pa = proc x -&gt;
--         do
--           r1 &lt;- filterEvent (\x -&gt; x `mod` 3 == 0) -&lt; x :: Event Int
--           r2 &lt;- stopped -&lt; x
--           r3 &lt;- returnA -&lt; r2
--           fin &lt;- gather -&lt; [r1, r2, r3]
--           val &lt;- hold 0 -&lt; r1
--           end &lt;- onEnd -&lt; fin
--           returnA -&lt; val &lt;$ end
--     in
--       run pa [1..5]
--   :}
--   [3]
--   </pre>
gather :: (Monad m, Foldable f) => ProcessT m (f (Event b)) (Event b)

-- | Given an array-valued event and emit it's values as inidvidual events.
--   
--   <pre>
--   &gt;&gt;&gt; run fork [[1,2,3],[],[4,5]]
--   [1,2,3,4,5]
--   </pre>
fork :: (Monad m, Foldable f) => ProcessT m (Event (f b)) (Event b)

-- | Executes an action once per an input event is provided.
fire :: Monad m => (b -> m c) -> ProcessT m (Event b) (Event c)

-- | Executes an action once per an input event is provided.
fire0 :: Monad m => m c -> ProcessT m (Event ()) (Event c)

-- | Executes an action once per an input event is provided.
anytime :: ArrowApply a => a b c -> ProcessA a (Event b) (Event c)
par :: (Monad m, Traversable col) => (forall sf. (b -> col sf -> col (ext, sf))) -> col (ProcessT m ext c) -> ProcessT m b (col c)
parB :: (Monad m, Traversable col) => col (ProcessT m b c) -> ProcessT m b (col c)

-- | Emit an event of given value as soon as possible.
oneshot :: Monad m => c -> ProcessT m b (Event c)

-- | Emit an event as soon as possible.
--   
--   <pre>
--   now = oneshot ()
--   </pre>
now :: Monad m => ProcessT m b (Event ())

-- | Emit an event at the end of the input stream. &gt;&gt;&gt; :{ let pa =
--   proc evx -&gt; do x &lt;- hold 0 -&lt; evx ed &lt;- onEnd -&lt; evx
--   returnA -&lt; x &lt;$ ed in run pa [1..10] :} [10]
onEnd :: (Monad m, Occasional' b) => ProcessT m b (Event ())


module Control.Arrow.Machine

module Control.Arrow.Machine.Misc.Pump
data Duct a
intake :: Monad m => ProcessT m (Event b, Event ()) (Duct b)
outlet :: Monad m => ProcessT m (Duct b, Event ()) (Event b)

module Control.Arrow.Machine.Misc.Discrete

-- | The discrete signal type.
data T a
updates :: T a -> (Event ())
value :: T a -> a
arr :: Monad m => (b -> c) -> ProcessT m (T b) (T c)
arr2 :: Monad m => (b1 -> b2 -> c) -> ProcessT m (T b1, T b2) (T c)
arr3 :: Monad m => (b1 -> b2 -> b3 -> c) -> ProcessT m (T b1, T b2, T b3) (T c)
arr4 :: Monad m => (b1 -> b2 -> b3 -> b4 -> c) -> ProcessT m (T b1, T b2, T b3, T b4) (T c)
arr5 :: Monad m => (b1 -> b2 -> b3 -> b4 -> b5 -> c) -> ProcessT m (T b1, T b2, T b3, T b4, T b5) (T c)
constant :: Monad m => c -> ProcessT m b (T c)

-- | Constant without initial notifications. Users must manage
--   initialization manually.
unsafeConstant :: Monad m => c -> ProcessT m b (T c)
hold :: Monad m => b -> ProcessT m (Event b) (T b)
accum :: Monad m => b -> ProcessT m (Event (b -> b)) (T b)
fromEq :: (Monad m, Eq b) => ProcessT m b (T b)
edge :: Monad m => ProcessT m (T b) (Event b)
asUpdater :: Monad m => (b -> m c) -> ProcessT m (T b) (Event c)
kSwitch :: Monad m => ProcessT m b (T c) -> ProcessT m (b, T c) (Event t) -> (ProcessT m b (T c) -> t -> ProcessT m b (T c)) -> ProcessT m b (T c)
dkSwitch :: Monad m => ProcessT m b (T c) -> ProcessT m (b, T c) (Event t) -> (ProcessT m b (T c) -> t -> ProcessT m b (T c)) -> ProcessT m b (T c)

-- | Discrete algebra type.
newtype Alg m i o
Alg :: ProcessT m i (T o) -> Alg m i o
[eval] :: Alg m i o -> ProcessT m i (T o)
refer :: Monad m => (e -> T b) -> Alg m e b
instance GHC.Base.Monad m => GHC.Base.Functor (Control.Arrow.Machine.Misc.Discrete.Alg m i)
instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Arrow.Machine.Misc.Discrete.Alg m i)
instance (GHC.Base.Monad m, GHC.Num.Num o) => GHC.Num.Num (Control.Arrow.Machine.Misc.Discrete.Alg m i o)