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


-- | Generic automaton arrow transformer and useful tools
--   
--   This library implements a powerful generic automaton arrow
--   transformer.
@package netwire
@version 2.0.1


-- | This module defines <a>Functor</a>, <a>Applicative</a>,
--   <a>Alternative</a>, <a>Monad</a> and <a>MonadPlus</a> instances for
--   <a>First</a> and <a>Last</a> monoids.
module Control.Wire.Instances
instance MonadPlus Last
instance Monad Last
instance Alternative Last
instance Applicative Last
instance Functor Last
instance MonadPlus First
instance Monad First
instance Alternative First
instance Applicative First
instance Functor First


-- | Utilities for creating wires.
module Control.Wire.Tools

-- | Distribute an input value over a list of arrow computations and
--   collect the results.
distA :: Arrow >~ => [a >~ b] -> (a >~ [b])

-- | Lift an arrow computation to lists of values.
mapA :: ArrowChoice >~ => (a >~ b) -> ([a] >~ [b])


-- | Type classes used in Netwire.
module Control.Wire.Classes

-- | Arrows with a clock.
class Arrow >~ => ArrowClock >~ where { type family Time >~; }
arrTime :: ArrowClock >~ => a >~ Time >~

-- | Arrows which support running IO computations.
class Arrow >~ => ArrowIO >~
arrIO :: ArrowIO >~ => IO b >~ b

-- | Arrows with support for random number generation.
class Arrow >~ => ArrowRandom >~
arrRand :: (ArrowRandom >~, Random b) => a >~ b
arrRandR :: (ArrowRandom >~, Random b) => (b, b) >~ b
instance ArrowRandom (Kleisli IO)
instance MonadIO m => ArrowIO (Kleisli m)
instance ArrowClock (Kleisli IO)


-- | Types used in the netwire library.
module Control.Wire.Types

-- | Signal networks.
data Wire e >~ a b
WGen :: !a >~ (Either e b, Wire e >~ a b) -> Wire e >~ a b
WPure :: !a -> (Either e b, Wire e >~ a b) -> Wire e >~ a b

-- | Create a wire from the given stateless transformation computation.
mkFix :: Arrow >~ => (a >~ Either e b) -> Wire e >~ a b

-- | Create a wire from the given transformation computation.
mkGen :: (a >~ (Either e b, Wire e >~ a b)) -> Wire e >~ a b

-- | Create a pure wire from the given transformation function.
mkPure :: (a -> (Either e b, Wire e >~ a b)) -> Wire e >~ a b

-- | Create a pure wire from the given transformation function.
mkPureFix :: (a -> Either e b) -> Wire e >~ a b

-- | Convert the given wire to a generic arrow computation.
toGen :: Arrow >~ => Wire e >~ a b -> (a >~ (Either e b, Wire e >~ a b))
instance ArrowChoice (>~) => Category (Wire e (>~))
instance (ArrowChoice (>~), Monoid e) => ArrowZero (Wire e (>~))
instance (ArrowChoice (>~), ArrowWriter w (>~)) => ArrowWriter w (Wire e (>~))
instance ArrowChoice (>~) => ArrowTransformer (Wire e) (>~)
instance (ArrowChoice (>~), ArrowState s (>~)) => ArrowState s (Wire e (>~))
instance (ArrowChoice (>~), ArrowReader r (>~)) => ArrowReader r (Wire e (>~))
instance (ArrowChoice (>~), Monoid e) => ArrowPlus (Wire e (>~))
instance (ArrowChoice (>~), ArrowLoop (>~)) => ArrowLoop (Wire e (>~))
instance (Applicative f, ArrowChoice (>~), ArrowIO (>~)) => ArrowIO (Wire (f SomeException) (>~))
instance ArrowChoice (>~) => ArrowError e (Wire e (>~))
instance (ArrowChoice (>~), ArrowLoop (>~)) => ArrowCircuit (Wire e (>~))
instance ArrowChoice (>~) => ArrowChoice (Wire e (>~))
instance ArrowChoice (>~) => Arrow (Wire e (>~))


-- | Wire sessions, i.e. running and/or testing wires.
module Control.Wire.Session

-- | Performs an instant of the given wire.
stepWire :: Arrow >~ => Wire e >~ a b -> (a >~ (Either e b, Wire e >~ a b))

-- | Test a wire. This function runs the given wire continuously printing
--   its output on a single line.
testWire :: (ArrowApply >~, ArrowIO >~, Show e) => Int -> (() >~ a) -> (Wire e >~ a String >~ ())


-- | Various wires for queuing.
module Control.Wire.Prefab.Queue

-- | Queues incoming signals and acts as a dam outputting incoming signals
--   in a FIFO fashion (one-way pipe). Note: Incorrect usage can lead to
--   congestion.
--   
--   <ul>
--   <li>Depends: current instant.</li>
--   <li>Inhibits: when the queue is empty.</li>
--   </ul>
fifo :: Monoid e => Wire e >~ [a] a

-- | Queues incoming signals and acts as a dam outputting incoming signals
--   in a LIFO fashion (stack). Note: Incorrect usage can lead to
--   congestion.
--   
--   <ul>
--   <li>Depends: current instant.</li>
--   <li>Inhibits: when the queue is empty.</li>
--   </ul>
lifo :: Monoid e => Wire e >~ [a] a


-- | Basic wires.
module Control.Wire.Prefab.Simple

-- | The constant wire. Outputs the given value all the time.
constant :: b -> Wire e >~ a b

-- | The identity wire. Outputs its input signal unchanged.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
identity :: Wire e >~ a a

-- | Force the input signal to weak head normal form, before outputting it.
--   Applies <a>seq</a> to the input signal.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
force :: Wire e >~ b b

-- | Force the input signal to normal form, before outputting it. Applies
--   <a>deepseq</a> to the input signal.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
forceNF :: NFData b => Wire e >~ b b

-- | Inject the given <a>Either</a> value as a signal. <a>Left</a> means
--   inhibition.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: When input is <a>Left</a>.</li>
--   </ul>
inject :: Wire e >~ (Either e b) b

-- | Inject the given <a>Maybe</a> value as a signal. <a>Nothing</a> means
--   inhibition.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: When input is <a>Nothing</a>.</li>
--   </ul>
injectEvent :: Monoid e => Wire e >~ (Maybe b) b


-- | Wires for signal accumulation.
module Control.Wire.Prefab.Accum

-- | General accumulator. Outputs the argument value at the first instant,
--   then applies the input function repeatedly for subsequent instants.
--   This acts like the <a>iterate</a> function for lists.
--   
--   <ul>
--   <li>Depends: current instant.</li>
--   </ul>
accum :: a -> Wire e >~ (a -> a) a

-- | Count upwards from the given starting value.
countFrom :: Enum b => b -> Wire e >~ a b

-- | Count from the given starting value, repeatedly adding the input
--   signal to it.
--   
--   <ul>
--   <li>Depends: current instant.</li>
--   </ul>
countStep :: Num a => a -> Wire e >~ a a

-- | Apply the given function at the first instant. Then act as the
--   identity wire forever.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
atFirst :: (b -> b) -> Wire e >~ b b


-- | Wires for splitting and terminating computations.
module Control.Wire.Prefab.Split

-- | Takes the input list and forks the wire for each value. Also forks a
--   single inhibiting wire. Warning: Incorrect usage will cause space
--   leaks! Use with care!
--   
--   <ul>
--   <li>Depends: Current instant</li>
--   <li>Inhibits: Always in one thread, never in all others.</li>
--   <li>Threads: Length of input list + 1.</li>
--   </ul>
fork :: (ArrowChoice >~, ArrowPlus >~, Monoid e) => Wire e >~ [b] b

-- | Terminates the current wire with no output.
--   
--   <ul>
--   <li>Threads: None.</li>
--   </ul>
quit :: ArrowZero >~ => Wire e >~ a b

-- | Terminates the current wire thread with the given input value as the
--   last output.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Threads: 1, then none.</li>
--   </ul>
quitWith :: ArrowZero >~ => Wire e >~ b b


-- | Wire transformers for handling inhibited signals.
module Control.Wire.Trans.Exhibit

-- | Produces <a>Just</a>, whenever the argument wire produces, otherwise
--   <a>Nothing</a>.
--   
--   <ul>
--   <li>Depends: like argument wire.</li>
--   </ul>
event :: Arrow >~ => Wire e >~ a b -> Wire e >~ a (Maybe b)

-- | Produces <a>Right</a>, whenever the argument wire produces, otherwise
--   <a>Left</a> with the inhibition value.
--   
--   <ul>
--   <li>Depends: like argument wire.</li>
--   </ul>
exhibit :: Arrow >~ => Wire e >~ a b -> Wire e >~ a (Either e b)


-- | Simple wire transformers.
module Control.Wire.Trans.Simple

-- | Apply the given function to the input, until the argument wire starts
--   producing.
--   
--   <ul>
--   <li>Depends: Like argument wire. * Inhibits: Like argument wire.</li>
--   </ul>
(--<) :: Arrow >~ => Wire e >~ a b -> (a -> a) -> Wire e >~ a b

-- | Apply the given function to the input, until the argument wire starts
--   producing.
--   
--   <ul>
--   <li>Depends: Like argument wire. * Inhibits: Like argument wire.</li>
--   </ul>
(>--) :: Arrow >~ => (a -> a) -> Wire e >~ a b -> Wire e >~ a b


-- | Wires for calculus over time.
module Control.Wire.Prefab.Calculus

-- | Integrate over time.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
integral :: (ArrowClock >~, Num t, (Scalar v) ~ t, (Time >~) ~ t, VectorSpace v) => v -> Wire e >~ v v

-- | Calculates the derivative of the input signal over time.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
derivative :: (ArrowClock >~, Fractional t, (Scalar v) ~ t, (Time >~) ~ t, VectorSpace v) => Wire e >~ v v


-- | Various clocks.
module Control.Wire.Prefab.Clock

-- | Time deltas starting from the first instant.
dtime :: (ArrowClock >~, (Time >~) ~ t, Num t) => Wire e >~ a t

-- | Time deltas starting from the given instant.
dtimeFrom :: (ArrowClock >~, (Time >~) ~ t, Num t) => t -> Wire e >~ a t

-- | Current time with origin 0 at the first instant.
time :: (ArrowClock >~, (Time >~) ~ t, Num t) => Wire e >~ a t

-- | Current time with the given origin at the first instant.
timeFrom :: (ArrowClock >~, (Time >~) ~ t, Num t) => t -> Wire e >~ a t

-- | Current time with the given offset.
timeOffset :: (ArrowClock >~, (Time >~) ~ t, Num t) => t -> Wire e >~ a t


-- | Various signal analysis tools
module Control.Wire.Prefab.Analyze

-- | Calculate the average of the signal over the given number of last
--   samples. If you need an average over all samples ever produced,
--   consider using <a>avgAll</a> instead.
--   
--   <ul>
--   <li>Complexity: O(n) space, O(1) time wrt number of samples.</li>
--   <li>Depends: current instant.</li>
--   </ul>
avg :: (Arrow >~, Fractional v, Unbox v) => Int -> Wire e >~ v v

-- | Calculate the average of the signal over all samples.
--   
--   Please note that somewhat surprisingly this wire runs in constant
--   space and is generally faster than <a>avg</a>, but most applications
--   will benefit from averages over only the last few samples.
--   
--   <ul>
--   <li>Depends: current instant.</li>
--   </ul>
avgAll :: (Arrow >~, Fractional v) => Wire e >~ v v

-- | Calculate the average number of frames per virtual second for the last
--   given number of frames.
--   
--   Please note that this wire uses the clock from the <a>ArrowClock</a>
--   instance for the underlying arrow. If this clock doesn't represent
--   real time, then the output of this wire won't either.
avgFps :: (ArrowChoice >~, ArrowClock >~, Fractional t, (Time >~) ~ t, Unbox t) => Int -> Wire e >~ a t

-- | Outputs the high peak of the input signal.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
highPeak :: Ord b => Wire e >~ b b

-- | Outputs the low peak of the input signal.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
lowPeak :: Ord b => Wire e >~ b b

-- | Outputs the high peak of the input signal with respect to the given
--   comparison function.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
peakBy :: (b -> b -> Ordering) -> Wire e >~ b b

-- | Collects all distinct inputs ever received.
--   
--   <ul>
--   <li>Complexity: O(n) space, O(log n) time wrt collected inputs so
--   far.</li>
--   <li>Depends: current instant.</li>
--   </ul>
collect :: Ord b => Wire e >~ b (Set b)

-- | Outputs the last input value on every change of the input signal. Acts
--   like the identity wire at the first instant.
--   
--   <ul>
--   <li>Depends: current instant.</li>
--   <li>Inhibits: on no change after the first instant.</li>
--   </ul>
diff :: (Eq b, Monoid e) => Wire e >~ b b

-- | Reports the first time the given input was seen.
--   
--   <ul>
--   <li>Complexity: O(n) space, O(log n) time wrt collected inputs so
--   far.</li>
--   <li>Depends: Current instant.</li>
--   </ul>
firstSeen :: (ArrowChoice >~, ArrowClock >~, Monoid e, Ord a, (Time >~) ~ t) => Wire e >~ a t

-- | Reports the last time the given input was seen. Inhibits when seeing a
--   signal for the first time.
--   
--   <ul>
--   <li>Complexity: O(n) space, O(log n) time wrt collected inputs so
--   far.</li>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: On first sight of a signal.</li>
--   </ul>
lastSeen :: (ArrowClock >~, Monoid e, Ord a, (Time >~) ~ t) => Wire e >~ a t


-- | Wires for generating and manipulating events.
module Control.Wire.Prefab.Event

-- | Produces once after the input time delta has passed.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: Always except at the target instant.</li>
--   </ul>
after :: (ArrowClock >~, Monoid e, Num t, Ord t, (Time >~) ~ t) => Wire e >~ t ()

-- | Produces once as soon as the current time is later than or equal to
--   the current time and never again.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: Always except at the target instant.</li>
--   </ul>
at :: (ArrowClock >~, Monoid e, Ord t, (Time >~) ~ t) => Wire e >~ t ()

-- | Delays each incoming event (left signal) by the given time delta
--   (right signal). The time delta at the instant the event happened is
--   significant.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: When no delayed event happened.</li>
--   </ul>
delayEvents :: (ArrowClock >~, Monoid e, Num t, Ord t, (Time >~) ~ t) => Wire e >~ ([b], t) b

-- | Delays each incoming event (left signal) by the given time delta
--   (middle signal). The time delta at the instant the event happened is
--   significant. The right signal gives a maximum number of events queued.
--   When exceeded, new events are dropped, until there is enough room.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: When no delayed event happened.</li>
--   </ul>
delayEventsSafe :: (ArrowClock >~, Monoid e, Num t, Ord t, (Time >~) ~ t) => Wire e >~ (([b], t), Int) b

-- | Periodically produces an event. The period is given by the input time
--   delta and can change over time. The current time delta with respect to
--   the last production is significant. Does not produce at the first
--   instant, unless the first delta is nonpositive.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: Always except at the periodic ticks.</li>
--   </ul>
periodically :: (ArrowClock >~, Monoid e, Num t, Ord t, (Time >~) ~ t) => Wire e >~ t ()

-- | Never produces. Always inhibits with the current input signal.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: Always.</li>
--   </ul>
inhibit :: Wire e >~ e b

-- | Never produces. Equivalent to <a>zeroArrow</a>.
--   
--   <ul>
--   <li>Inhibits: Always.</li>
--   </ul>
never :: Monoid e => Wire e >~ a b

-- | Inhibits as long as the input signal is <a>False</a>. Once it switches
--   to <a>True</a>, it produces forever.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: As long as input signal is <a>False</a>, then never
--   again.</li>
--   </ul>
asSoonAs :: Monoid e => Wire e >~ Bool ()

-- | Produces once whenever the input signal switches from <a>False</a> to
--   <a>True</a>.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: Always except at the above mentioned instants.</li>
--   </ul>
edge :: Monoid e => Wire e >~ Bool ()

-- | Produces, whenever the current input signal is <a>True</a>.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: When input is <a>False</a>.</li>
--   </ul>
require :: Monoid e => Wire e >~ Bool ()

-- | Produces, whenever the current input signal is <a>False</a>.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: When input is <a>True</a>.</li>
--   </ul>
forbid :: Monoid e => Wire e >~ Bool ()

-- | Produce as long as the input signal is <a>True</a>. Once it switches
--   to <a>False</a>, never produce again. Corresponds to <a>takeWhile</a>
--   for lists.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   <li>Inhibits: As soon as input becomes <a>False</a>.</li>
--   </ul>
while :: Monoid e => Wire e >~ Bool ()

-- | Inhibit at the first instant. Then produce forever.
--   
--   <ul>
--   <li>Inhibits: At the first instant.</li>
--   </ul>
notYet :: Monoid e => Wire e >~ b b

-- | Acts like the identity function once and never again.
--   
--   <ul>
--   <li>Inhibits: After the first instant.</li>
--   </ul>
once :: Monoid e => Wire e >~ b b


-- | Wires for generating random noise.
module Control.Wire.Prefab.Random

-- | Generate random noise.
noise :: (ArrowRandom >~, Random b) => Wire e >~ a b

-- | Generate random noise in a certain range given by the input signal.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
noiseR :: (ArrowRandom >~, Random b) => Wire e >~ (b, b) b

-- | Generate random noise in range 0 &lt;= x &lt; 1.
noiseF :: ArrowRandom >~ => Wire e >~ a Double

-- | Generate random noise in range -1 &lt;= x &lt; 1.
noiseF1 :: ArrowRandom >~ => Wire e >~ a Double

-- | Generate a random boolean, where the input signal is the probability
--   to be <a>True</a>.
--   
--   <ul>
--   <li>Depends: Current instant.</li>
--   </ul>
wackelkontakt :: ArrowRandom >~ => Wire e >~ Double Bool


-- | Signal sampling wires.
module Control.Wire.Prefab.Sample

-- | Sample the right signal at discrete intervals given by the left input
--   signal.
--   
--   <ul>
--   <li>Depends: Current instant (left), last sampling instant
--   (right).</li>
--   </ul>
discrete :: (ArrowClock >~, Num t, Ord t, (Time >~) ~ t) => Wire e >~ (t, b) b

-- | Keep the signal in the first instant forever.
--   
--   <ul>
--   <li>Depends: First instant.</li>
--   </ul>
keep :: Wire e >~ b b


-- | Convenience module importing all the prefab wires.
module Control.Wire.Prefab


-- | Wire transformers for combining wires.
module Control.Wire.Trans.Combine

-- | Make the given wire context-sensitive. The right signal is a context
--   and the wire will evolve individually for each context.
--   
--   <ul>
--   <li>Depends: Like context wire (left), current instant (right). *
--   Inhibits: Like context wire.</li>
--   </ul>
context :: (ArrowApply >~, ArrowChoice >~, Ord k) => Wire e >~ a b -> Wire e >~ (a, k) b

-- | Same as <a>context</a>, but with a time limit. The third signal
--   specifies a maximum age. Contexts not used for longer than the maximum
--   age are forgotten.
--   
--   <ul>
--   <li>Depends: Like context wire (left), current instant (right). *
--   Inhibits: Like context wire.</li>
--   </ul>
contextLimit :: (ArrowApply >~, ArrowClock >~, Num t, Ord k, Ord t, (Time >~) ~ t) => Wire e >~ a b -> Wire e >~ ((a, k), t) b

-- | Distribute the input signal over the given wires, evolving each of
--   them individually. Collects produced outputs.
--   
--   Note: This wire transformer discards all inhibited signals.
--   
--   <ul>
--   <li>Depends: as strict as the strictest subwire.</li>
--   </ul>
distribute :: ArrowApply >~ => [Wire e >~ a b] -> Wire e >~ a [b]


-- | Wire transformers for sampling wires.
module Control.Wire.Trans.Sample

-- | Keeps the latest produced value.
--   
--   <ul>
--   <li>Depends: Like argument wire. * Inhibits: Until first
--   production.</li>
--   </ul>
hold :: Arrow >~ => Wire e >~ a b -> Wire e >~ a b

-- | Keeps the latest produced value. Produces the argument value until the
--   argument wire starts producing.
--   
--   <ul>
--   <li>Depends: Like argument wire.</li>
--   </ul>
holdWith :: Arrow >~ => b -> Wire e >~ a b -> Wire e >~ a b

-- | Samples the given wire at discrete intervals. Only runs the input
--   through the wire, then the next sampling interval has elapsed.
--   
--   <ul>
--   <li>Depends: Current instant (left), like argument wire at sampling
--   intervals (right). * Inhibits: Starts inhibiting when argument wire
--   inhibits. Keeps inhibiting until next sampling interval.</li>
--   </ul>
sample :: (ArrowChoice >~, ArrowClock >~, Num t, Ord t, (Time >~) ~ t) => Wire e >~ a b -> Wire e >~ (a, t) b

-- | Waits for the argument wire to produce and then keeps the first
--   produced value forever.
--   
--   <ul>
--   <li>Depends: Like argument wire until first production. Then stops
--   depending. * Inhibits: Until the argument wire starts producing.</li>
--   </ul>
swallow :: ArrowChoice >~ => Wire e >~ a b -> Wire e >~ a b


-- | Wire transformers.
module Control.Wire.Trans


-- | Convenience module for the Netwire library.
module Control.Wire