-- 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.
@package machinecell
@version 1.3.1

module Control.Arrow.Machine.Types

-- | To get multiple outputs by one input, the <a>Phase</a> parameter is
--   introduced.
--   
--   Once a value <a>Feed</a>ed, the machine is <a>Sweep</a>ed until it
--   <a>Suspend</a>s.
data Phase
Feed :: Phase
Sweep :: Phase
Suspend :: Phase
type StepType a b c = a (Phase, b) (Phase, c, ProcessA a b c)

-- | 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.
--   
--   May use <a>ArrowChoice</a> and <a>ArrowLoop</a> instance too. but
--   there is a limitation that <a>loop</a> cannot propagate
--   <tt>Event</tt>s to upstream. In such case, use <a>feedback</a>
--   instead.
data ProcessA a b c
ProcessA :: StepType a b c -> ProcessA a b c
step :: ProcessA a b c -> StepType a b c
fit :: (Arrow a, Arrow a') => (forall p q. a p q -> a' p q) -> ProcessA a b c -> ProcessA a' b c
dimapStep :: Arrow a => (b -> c) -> (d -> e) -> StepType a c d -> StepType a b e
parStep :: (Arrow a, Arrow t, Monoid t4) => t (t2, t1) (t4, t5, a b c) -> t (t2, t3) (t4, t6, a b' c') -> t (t2, (t1, t3)) (t4, (t5, t6), a (b, b') (c, c'))
arrStep :: ArrowApply a => (b -> c) -> StepType a b c

-- | Composition is proceeded by the backtracking strategy.
compositeStep :: ArrowApply a => StepType a b d -> StepType a d c -> StepType a b c
compositeStep' :: ArrowApply a => Phase -> StepType a b d -> StepType a d c -> StepType a b c
instance Eq Phase
instance Show Phase
instance (ArrowApply a, ArrowApply a', ArrowAddReader r a a') => ArrowAddReader r (ProcessA a) (ProcessA a')
instance (ArrowApply a, ArrowReader r a) => ArrowReader r (ProcessA a)
instance (ArrowApply a, ArrowLoop a) => ArrowLoop (ProcessA a)
instance ArrowApply a => ArrowChoice (ProcessA a)
instance ArrowApply a => Arrow (ProcessA a)
instance ArrowApply a => Category (ProcessA a)
instance Arrow a => Profunctor (ProcessA a)
instance Monoid Phase


-- | 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
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.Event
class Occasional a where isOccasion x = not (isNoEvent x) && not (isEnd x)
noEvent :: Occasional a => a
end :: Occasional a => a
isNoEvent :: Occasional a => a -> Bool
isEnd :: Occasional a => a -> Bool
isOccasion :: Occasional a => a -> Bool
data Event a
hEv :: ArrowApply a => a (e, b) c -> a e c -> a (e, Event b) c
hEv' :: ArrowApply a => a (e, b) c -> a e c -> a e c -> a (e, Event b) c
evMaybe :: Arrow a => c -> (b -> c) -> a (Event b) c
fromEvent :: Arrow a => b -> a (Event b) b
evMap :: Arrow a => (b -> c) -> a (Event b) (Event c)
split :: (Arrow a, Occasional b) => a (Event b) b
join :: (Arrow a, Occasional b) => a b (Event b)
split2 :: Event (Event a, Event b) -> (Event a, Event b)
join2 :: (Event a, Event b) -> Event (Event a, Event b)


-- | A coroutine monad, inspired by machines library.
module Control.Arrow.Machine.Plan
type 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
stopped :: (ArrowApply a, 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)

module Control.Arrow.Machine.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
delay :: (ArrowApply a, Occasional b) => ProcessA a b b
hold :: ArrowApply a => b -> ProcessA a (Event b) b
accum :: ArrowApply a => b -> ProcessA a (Event (b -> b)) b
edge :: (ArrowApply a, Eq b) => ProcessA a b (Event b)

-- | <i>Deprecated: Use <a>hold</a> instead</i>
passRecent :: (ArrowApply a, Occasional o) => ProcessA a (AS e) (Event b) -> ProcessA a (e, AS b) o -> ProcessA a (AS e) o

-- | <i>Deprecated: Use <a>hold</a> instead</i>
withRecent :: (ArrowApply a, Occasional o) => ProcessA a (e, AS b) o -> ProcessA a (e, AS (Event b)) o

-- | Event version of loop (member of <a>ArrowLoop</a>). Yielding an event
--   to feedback output always creates a new process cycle. So be careful
--   to make an infinite loop.

-- | <i>Deprecated: Use Pump instead</i>
feedback1 :: (ArrowApply a, Occasional d) => ProcessA a (e, AS d) (c, d) -> ProcessA a (AS e) c

-- | Artificially split into two arrow to use binary operator notation
--   rather than banana brackets.

-- | <i>Deprecated: Use Pump instead</i>
feedback :: (ArrowApply a, Occasional d) => ProcessA a (e, AS d) b -> ProcessA a (e, AS b) (c, d) -> ProcessA a (AS e) 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
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)
peekState :: (ArrowApply a, ArrowState s a) => ProcessA a e s
encloseState :: (ArrowApply a, ArrowAddState s a a') => ProcessA a b c -> s -> ProcessA a' b c

-- | Make two event streams into one. Actually <a>gather</a> is more
--   general and convenient; <tt> ... &lt;- tee -&lt; (e1, e2) </tt> is
--   equivalent to <tt> ... <a>gather -&lt; [Left &lt;$</a> e1, Right
--   <a>$</a> e2] </tt>
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)
sample :: ArrowApply a => ProcessA a (Event b1, Event b2) [b1]

-- | Provides a source event stream. A dummy input event stream is needed.
--   <tt> run af [...] </tt> is equivalent to <tt> run (source [...]
--   &gt;&gt;&gt; af) (repeat ()) </tt>
source :: (ArrowApply a, Foldable f) => f c -> ProcessA a (Event b) (Event c)

-- | 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 o Bool -> ProcessA a (Event o) (Event o)
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)
onEnd :: (ArrowApply a, Occasional b) => ProcessA a b (Event ())

-- | Observe a previous value of a signal. Tipically used with rec
--   statement.
cycleDelay :: ArrowApply a => ProcessA a b b

module Control.Arrow.Machine.Running

-- | 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) => (c -> r) -> ProcessA a (Event b) (Event c) -> a [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
yields :: ExecInfo fa -> fa
hasConsumed :: ExecInfo fa -> Bool
hasStopped :: ExecInfo fa -> Bool

-- | Execute until an input consumed and the machine suspended.
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))
instance Eq fa => Eq (ExecInfo fa)
instance Show fa => Show (ExecInfo fa)
instance Alternative f => Monoid (ExecInfo (f a))
instance Monoid r => Monoid (WithEnd r)


-- | Extracted stuff to be used unqualified from ../Machine.hs.
module Control.Arrow.Machine.Core

-- | 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.
--   
--   May use <a>ArrowChoice</a> and <a>ArrowLoop</a> instance too. but
--   there is a limitation that <a>loop</a> cannot propagate
--   <tt>Event</tt>s to upstream. In such case, use <a>feedback</a>
--   instead.
data ProcessA a b c
fit :: (Arrow a, Arrow a') => (forall p q. a p q -> a' p q) -> ProcessA a b c -> ProcessA a' b c

module Control.Arrow.Machine

-- | 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.
--   
--   May use <a>ArrowChoice</a> and <a>ArrowLoop</a> instance too. but
--   there is a limitation that <a>loop</a> cannot propagate
--   <tt>Event</tt>s to upstream. In such case, use <a>feedback</a>
--   instead.
data ProcessA a b c
fit :: (Arrow a, Arrow a') => (forall p q. a p q -> a' p q) -> ProcessA a b c -> ProcessA a' b c

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)