-- 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 3.2.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
reading :: (Monad m, Arrow a) => (forall p q. (p -> m q) -> a p q) -> (b -> ReaderT r m c) -> ReaderArrow r a b c
statefully :: (Monad m, Arrow a) => (forall p q. (p -> m q) -> a p q) -> (b -> StateT s m c) -> StateArrow s a b c

-- | 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)
rd :: (Arrow a) => (forall p q. MyIso' (p -> m q) (a p q)) -> MyIso' (b -> ReaderT r m c) (ReaderArrow r 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

-- | Alternate for <a>elimReader</a> that can be used with both ghc 7.8 and
--   older.
elimR :: ArrowAddReader r a a' => a (AS e) b -> a' (e, AS r) b

module Control.Arrow.Machine.Types

-- | The stream transducer arrow.
--   
--   To construct <a>ProcessA</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 ProcessA a b c

-- | 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
noEvent :: Occasional a => a
end :: Occasional a => a

-- | Discrete events on a time line. Created and consumed by various
--   transducers.
data Event a
condEvent :: Bool -> Event a -> Event a
filterEvent :: (a -> Bool) -> Event a -> Event a
filterJust :: Event (Maybe a) -> Event a
filterLeft :: Event (Either a b) -> Event a
filterRight :: Event (Either a b) -> Event b

-- | Alias of "arr . fmap"
--   
--   While "ProcessA 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
await :: Plan i o i
yield :: o -> Plan i o ()
stop :: Plan i o a
catchP :: Monad m => PlanT i o m a -> PlanT i o m a -> PlanT i o m a
stopped :: (ArrowApply a, Occasional c) => ProcessA a b c
muted :: (ArrowApply a, Occasional' b, Occasional c) => ProcessA a b c
constructT :: (Monad m, ArrowApply a) => (forall b. m b -> a () b) -> PlanT i o m r -> ProcessA a (Event i) (Event o)
repeatedlyT :: (Monad m, ArrowApply a) => (forall b. m b -> a () b) -> PlanT i o m r -> ProcessA a (Event i) (Event o)
construct :: ArrowApply a => Plan i o t -> ProcessA a (Event i) (Event o)
repeatedly :: ArrowApply a => Plan i o t -> ProcessA a (Event i) (Event o)

-- | Run a machine.
run :: ArrowApply a => ProcessA a (Event b) (Event c) -> a [b] [c]

-- | Run a machine with results concatenated in terms of a monoid.
runOn :: (ArrowApply a, Monoid r, Foldable f) => (c -> r) -> ProcessA a (Event b) (Event c) -> a (f b) r

-- | Run a machine discarding all results.
run_ :: ArrowApply a => ProcessA a (Event b) (Event c) -> a [b] ()

-- | Represents return values and informations of step executions.
data ExecInfo fa
ExecInfo :: fa -> Bool -> Bool -> ExecInfo fa

-- | Values yielded while the step.
[yields] :: ExecInfo fa -> fa

-- | True if the input value is consumed.
--   
--   False if the machine has stopped unless consuming the input.
--   
--   Or in the case of <a>stepYield</a>, this field become false when the
--   machine produces a value unless consuming the input.
[hasConsumed] :: ExecInfo fa -> Bool

-- | True if the machine has stopped at the end of the step.
[hasStopped] :: ExecInfo fa -> Bool

-- | Execute until an input consumed and the machine suspends.
stepRun :: ArrowApply a => ProcessA a (Event b) (Event c) -> a b (ExecInfo [c], ProcessA a (Event b) (Event c))

-- | Execute until an output produced.
stepYield :: ArrowApply a => ProcessA a (Event b) (Event c) -> a b (ExecInfo (Maybe c), ProcessA a (Event b) (Event c))
switch :: ArrowApply a => ProcessA a b (c, Event t) -> (t -> ProcessA a b c) -> ProcessA a b c
dSwitch :: ArrowApply a => ProcessA a b (c, Event t) -> (t -> ProcessA a b c) -> ProcessA a b c
rSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, Event (ProcessA a b c)) c
drSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, Event (ProcessA a b c)) c
kSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, c) (Event t) -> (ProcessA a b c -> t -> ProcessA a b c) -> ProcessA a b c
dkSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, c) (Event t) -> (ProcessA a b c -> t -> ProcessA a b c) -> ProcessA a b c
gSwitch :: ArrowApply a => ProcessA a b (p, r) -> ProcessA a p q -> ProcessA a (q, r) (c, Event t) -> (ProcessA a p q -> t -> ProcessA a b c) -> ProcessA a b c
dgSwitch :: ArrowApply a => ProcessA a b (p, r) -> ProcessA a p q -> ProcessA a (q, r) (c, Event t) -> (ProcessA a p q -> t -> ProcessA a b c) -> ProcessA a b c
pSwitch :: (ArrowApply a, Traversable col) => (forall sf. b -> col sf -> col (ext, sf)) -> col (ProcessA a ext c) -> ProcessA a (b, col c) (Event mng) -> (col (ProcessA a ext c) -> mng -> ProcessA a b (col c)) -> ProcessA a b (col c)
pSwitchB :: (ArrowApply a, Traversable col) => col (ProcessA a b c) -> ProcessA a (b, col c) (Event mng) -> (col (ProcessA a b c) -> mng -> ProcessA a b (col c)) -> ProcessA a b (col c)
dpSwitch :: (ArrowApply a, Traversable col) => (forall sf. b -> col sf -> col (ext, sf)) -> col (ProcessA a ext c) -> ProcessA a (b, col c) (Event mng) -> (col (ProcessA a ext c) -> mng -> ProcessA a b (col c)) -> ProcessA a b (col c)
dpSwitchB :: (ArrowApply a, Traversable col) => col (ProcessA a b c) -> ProcessA a (b, col c) (Event mng) -> (col (ProcessA a b c) -> mng -> ProcessA a b (col c)) -> ProcessA a b (col c)
rpSwitch :: (ArrowApply a, Traversable col) => (forall sf. b -> col sf -> col (ext, sf)) -> col (ProcessA a ext c) -> ProcessA a (b, Event (col (ProcessA a ext c) -> col (ProcessA a ext c))) (col c)
rpSwitchB :: (ArrowApply a, Traversable col) => col (ProcessA a b c) -> ProcessA a (b, Event (col (ProcessA a b c) -> col (ProcessA a b c))) (col c)
drpSwitch :: (ArrowApply a, Traversable col) => (forall sf. b -> col sf -> col (ext, sf)) -> col (ProcessA a ext c) -> ProcessA a (b, Event (col (ProcessA a ext c) -> col (ProcessA a ext c))) (col c)
drpSwitchB :: (ArrowApply a, Traversable col) => col (ProcessA a b c) -> ProcessA a (b, Event (col (ProcessA a b c) -> col (ProcessA a b c))) (col c)
par :: (ArrowApply a, Traversable col) => (forall sf. b -> col sf -> col (ext, sf)) -> col (ProcessA a ext c) -> ProcessA a b (col c)
parB :: (ArrowApply a, Traversable col) => col (ProcessA a b c) -> ProcessA a b (col c)

-- | Natural transformation
fit :: (ArrowApply a, ArrowApply a') => (forall p q. a p q -> a' p q) -> ProcessA a b c -> ProcessA a' b c

-- | Experimental: more general fit.
--   
--   Should w be a comonad?
fitW :: (ArrowApply a, ArrowApply a', Functor w) => (forall p. w p -> p) -> (forall p q. a p q -> a' (w p) q) -> ProcessA a b c -> ProcessA a' (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 :: (ArrowApply a, Foldable f) => a b (f c) -> ProcessA a b (Event c)
instance GHC.Show.Show fa => GHC.Show.Show (Control.Arrow.Machine.Types.ExecInfo fa)
instance GHC.Classes.Eq fa => GHC.Classes.Eq (Control.Arrow.Machine.Types.ExecInfo fa)
instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Arrow.Machine.Types.PlanT i o m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Arrow.Machine.Types.PlanT i o)
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.Show.Show Control.Arrow.Machine.Types.Phase
instance GHC.Classes.Eq Control.Arrow.Machine.Types.Phase
instance GHC.Base.Monoid Control.Arrow.Machine.Types.Phase
instance Control.Arrow.Machine.Types.Stepper a b c (Control.Arrow.Machine.Types.ProcessA a b c)
instance Control.Arrow.Machine.Types.ProcessHelper Data.Functor.Identity.Identity
instance Control.Arrow.Machine.Types.ProcessHelper GHC.Base.Maybe
instance Control.Arrow.ArrowApply a => Control.Arrow.Machine.Types.Stepper a b c (Control.Arrow.Machine.Types.CompositeStep a b c s1 s2)
instance Control.Arrow.ArrowApply a => Control.Arrow.Machine.Types.Stepper a b c (Control.Arrow.Machine.Types.IDStep a b c)
instance Control.Arrow.ArrowApply a => Control.Arrow.Machine.Types.Stepper a b c (Control.Arrow.Machine.Types.ArrStep a b c)
instance Control.Arrow.ArrowApply a => Control.Arrow.Machine.Types.Stepper a b c (Control.Arrow.Machine.Types.ParStep a b c s1 s2)
instance Control.Arrow.ArrowApply a => Data.Profunctor.Unsafe.Profunctor (Control.Arrow.Machine.Types.ProcessA a)
instance Control.Arrow.ArrowApply a => GHC.Base.Functor (Control.Arrow.Machine.Types.ProcessA a i)
instance Control.Arrow.ArrowApply a => GHC.Base.Applicative (Control.Arrow.Machine.Types.ProcessA a i)
instance Control.Arrow.ArrowApply a => Control.Category.Category (Control.Arrow.Machine.Types.ProcessA a)
instance Control.Arrow.ArrowApply a => Control.Arrow.Arrow (Control.Arrow.Machine.Types.ProcessA a)
instance Control.Arrow.ArrowApply a => Control.Arrow.ArrowChoice (Control.Arrow.Machine.Types.ProcessA a)
instance Control.Arrow.ArrowApply a => Control.Arrow.ArrowLoop (Control.Arrow.Machine.Types.ProcessA 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 (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 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 (Control.Arrow.Machine.Types.Event a)
instance GHC.Base.Functor (Control.Arrow.Machine.Types.PlanF 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 (GHC.Base.Monad m, GHC.Base.Alternative m) => GHC.Base.MonadPlus (Control.Arrow.Machine.Types.PlanT i o m)
instance (Control.Arrow.ArrowApply a, Data.Traversable.Traversable col) => Control.Arrow.Machine.Types.Stepper a b (col c) (Control.Arrow.Machine.Types.PluralStep ext col a b c)
instance GHC.Base.Monoid r => GHC.Base.Monoid (Control.Arrow.Machine.Types.WithEnd r)
instance GHC.Base.Monoid (Control.Arrow.Machine.Types.Builder a)
instance GHC.Base.Alternative f => GHC.Base.Monoid (Control.Arrow.Machine.Types.ExecInfo (f a))

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.Utils
hold :: ArrowApply a => b -> ProcessA a (Event b) b
dHold :: ArrowApply a => b -> ProcessA a (Event b) b
accum :: ArrowApply a => b -> ProcessA a (Event (b -> b)) b
dAccum :: ArrowApply a => b -> ProcessA a (Event (b -> b)) b
edge :: (ArrowApply a, Eq b) => ProcessA a b (Event b)
switch :: ArrowApply a => ProcessA a b (c, Event t) -> (t -> ProcessA a b c) -> ProcessA a b c
dSwitch :: ArrowApply a => ProcessA a b (c, Event t) -> (t -> ProcessA a b c) -> ProcessA a b c
rSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, Event (ProcessA a b c)) c
drSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, Event (ProcessA a b c)) c
kSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, c) (Event t) -> (ProcessA a b c -> t -> ProcessA a b c) -> ProcessA a b c
dkSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, c) (Event t) -> (ProcessA a b c -> t -> ProcessA a b c) -> ProcessA a b c
pSwitch :: (ArrowApply a, Traversable col) => (forall sf. b -> col sf -> col (ext, sf)) -> col (ProcessA a ext c) -> ProcessA a (b, col c) (Event mng) -> (col (ProcessA a ext c) -> mng -> ProcessA a b (col c)) -> ProcessA a b (col c)
pSwitchB :: (ArrowApply a, Traversable col) => col (ProcessA a b c) -> ProcessA a (b, col c) (Event mng) -> (col (ProcessA a b c) -> mng -> ProcessA a b (col c)) -> ProcessA a b (col c)
rpSwitch :: (ArrowApply a, Traversable col) => (forall sf. b -> col sf -> col (ext, sf)) -> col (ProcessA a ext c) -> ProcessA a (b, Event (col (ProcessA a ext c) -> col (ProcessA a ext c))) (col c)
rpSwitchB :: (ArrowApply a, Traversable col) => col (ProcessA a b c) -> ProcessA a (b, Event (col (ProcessA a b c) -> col (ProcessA a 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 :: (ArrowApply a, Foldable f) => f c -> ProcessA a (Event b) (Event c)

-- | Provides a blocking event stream.
blockingSource :: (ArrowApply a, Foldable f) => f c -> ProcessA a () (Event c)

-- | Make a blocking source interleaved.
interleave :: ArrowApply a => ProcessA a () (Event c) -> ProcessA a (Event b) (Event c)

-- | Make an interleaved source blocking.
blocking :: ArrowApply a => ProcessA a (Event ()) (Event c) -> ProcessA a () (Event c)

-- | 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 :: ArrowApply a => ProcessA a (Event b1, Event b2) (Event (Either b1 b2))

-- | Make multiple event channels into one. If simultaneous events are
--   given, lefter one is emitted earlier.
gather :: (ArrowApply a, Foldable f) => ProcessA a (f (Event b)) (Event b)

-- | Given an array-valued event and emit it's values as inidvidual events.
fork :: (ArrowApply a, Foldable f) => ProcessA a (Event (f b)) (Event b)
filter :: ArrowApply a => a b Bool -> ProcessA a (Event b) (Event b)
echo :: ArrowApply a => ProcessA a (Event b) (Event b)

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

-- | Run reader of base arrow.
readerProc :: (ArrowApply a, ArrowApply a', ArrowAddReader r a a') => ProcessA a b c -> ProcessA a' (b, r) c


module Control.Arrow.Machine

module Control.Arrow.Machine.Misc.Pump
data Duct a
intake :: ArrowApply a => ProcessA a (Event b, Event ()) (Duct b)
outlet :: ArrowApply a => ProcessA a (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 :: ArrowApply a => (b -> c) -> ProcessA a (T b) (T c)
arr2 :: ArrowApply a => (b1 -> b2 -> c) -> ProcessA a (T b1, T b2) (T c)
arr3 :: ArrowApply a => (b1 -> b2 -> b3 -> c) -> ProcessA a (T b1, T b2, T b3) (T c)
arr4 :: ArrowApply a => (b1 -> b2 -> b3 -> b4 -> c) -> ProcessA a (T b1, T b2, T b3, T b4) (T c)
arr5 :: ArrowApply a => (b1 -> b2 -> b3 -> b4 -> b5 -> c) -> ProcessA a (T b1, T b2, T b3, T b4, T b5) (T c)
constant :: ArrowApply a => c -> ProcessA a b (T c)

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

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