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


-- | Minimal FRP library
--   
--   Defines minimal FRP library (classical FRP)
@package dyna
@version 0.1.0.0

module Dyna.Ref
class IsRef ref
newRef :: IsRef ref => a -> IO (ref a)
readRef :: IsRef ref => ref a -> IO a
writeRef :: IsRef ref => ref a -> a -> IO ()
modifyRef :: IsRef ref => ref a -> (a -> a) -> IO ()
instance Dyna.Ref.IsRef GHC.IORef.IORef
instance Dyna.Ref.IsRef GHC.Conc.Sync.TVar


-- | Dyna is functional reactive programming library. It describes event
--   streams that are based on callbacks. The event stream can produce
--   something useful with callback that it consumes. Also we have
--   continous signals called <tt>Dyn</tt> (short for dynamic). The Dyn is
--   sort of observance process of an event stream. For any event that
--   happen on event stream we remember that value and produce it at any
--   time until the next event will happen.
--   
--   # Events
--   
--   The event stream is just callback consumer funtion:
--   
--   <pre>
--   newtype Evt m a = Evt {
--     runEvt :: (a -&gt; m ()) -&gt; m ()
--   }
--   </pre>
--   
--   So it tells us: If you give me some callback <tt>(a -&gt; m ())</tt> I
--   will apply it to the event when event will occur. But when it will
--   occur we don't know until we run the event. All events happen at the
--   same time. Every event triggers a callback. This has some special
--   nuance to it. That can differ from other FRP libraries. For example
--   monoidal append of two event streams:
--   
--   <pre>
--   evtA &lt;&gt; evtB
--   </pre>
--   
--   In many FRP libraries we choose which element will happen or should we
--   also append the events if they happen "at the same time". For this
--   library we spawn two concurrent processes on background so if two
--   events will happen at the same time callback will be called twice.
--   
--   # Dynamics
--   
--   The assumption is that dynamic is a process that evolves in time. And
--   as a human beings we can only ask for current values while process
--   happens. So we assemble the dynamics with combinators an after that we
--   can run it's process:
--   
--   <pre>
--   ref &lt;-runDyn dynamicValue
--   </pre>
--   
--   It produces reference to the process which we can use to sample the
--   current value in real time:
--   
--   <pre>
--   readDyn ref
--    10
--   readDyn ref  -- 5 seconds later
--    10
--   readDyn ref  -- 5 seconds later
--    3
--   </pre>
--   
--   This reminds us of the notion of present moment. Take for example a
--   weather temperature. We can claim to build a model of weather and have
--   an assumption of which value will happen tomorrow but the exact value
--   for it we can only measure at the moment when it will actually happen.
--   
--   So the library is based on simple assumptions:
--   
--   <ul>
--   <li>Event stream is a callback processor</li>
--   <li>Event stream happen at the same time as concurrent process</li>
--   <li>Dynamic is a process and we can only query the current value for
--   it</li>
--   <li>Dynamics are based on event streams. The dynamic is an observation
--   of some underlying event streams. We just remember the last event and
--   keep producing it until the next one wil arrive.</li>
--   </ul>
module Dyna

-- | Pipe operator. We often write processors of event streams It makes it
--   convenient write them from first to the last:
--   
--   <pre>
--   evt = proc1 |&gt; proc2 |&gt; ... |&gt; procN
--   </pre>
--   
--   Instead of reversed order with <tt>($)</tt>:
--   
--   <pre>
--   evt = procN $ ... $ proc2 $ proc1
--   </pre>
(|>) :: a -> (a -> b) -> b
infixl 0 |>
class (IsRef (Ref m), MonadBaseControl IO m, MonadIO m) => Frp m where {
    type family Ref m :: * -> *;
}

-- | Event stream. The meaning of an event is a callback consumer function.
--   If we give callback to it it will do something useful based on it.
--   
--   The main function is runEvt:
--   
--   <pre>
--   runEvt :: Evt m a -&gt; (a -&gt; m ()) -&gt; m ()
--   runEvt events callback = ...
--   </pre>
--   
--   Let's look at simple examples of the event streams:
--   
--   Event that never produce anything:
--   
--   <pre>
--   never = Evt {
--      runEvt _ = pure ()
--    }
--   </pre>
--   
--   So it just ignores the callback and returns right away.
--   
--   Event that happens only once:
--   
--   <pre>
--   once :: m a -&gt; Evt m a
--   once get = Evt {
--       runEvt go = go =&lt;&lt; get
--    }
--   </pre>
--   
--   It just gets the value right away and applies callback to it. We can
--   try it out in the interpreter:
--   
--   <pre>
--   putStrLns $ fmap ("Your message: " &lt;&gt; ) $ once getLine
--   </pre>
--   
--   We have useful functions to print out the events: <tt>putStrLns</tt>
--   and <tt>prints</tt>.
--   
--   Also we have event streams that happen periodically:
--   
--   <pre>
--   prints $ clock 1  -- prints time every second
--   </pre>
--   
--   ## Duplication of the events.
--   
--   Note that event streams are functions that do side-effects within some
--   monad. We use them as values but it means that two values with the
--   same event stream definition can produce different results. For
--   example:
--   
--   <pre>
--   a = toRandomR (0, 10) $ clock 1
--   b = a
--   </pre>
--   
--   Note that a and b will each have their own copy of underlying random
--   event stream. So if you use it in the code don't expect values to be
--   the same.
--   
--   But if we want them to be the same we can copy event from it's
--   definition with function:
--   
--   <pre>
--   newEvt :: Evt m a -&gt; m (Evt m a)
--   </pre>
--   
--   It starts the underying event stream process n background and sends
--   all events to the result by channel. With nice property of when we
--   shut down the result event the background process also shuts down.
--   
--   <pre>
--   a &lt;- newEvt toRandomR (0, 10) $ clock 1
--   b = a
--   </pre>
--   
--   In this example event streams <tt>a</tt> and <tt>b</tt> will have the
--   same events during execution.
newtype Evt m a
Evt :: ((a -> m ()) -> m ()) -> Evt m a
[runEvt] :: Evt m a -> (a -> m ()) -> m ()

-- | Event that happens only once and happens right away.
once :: Frp m => m a -> Evt m a

-- | Event that never happens. Callback function is ignored.
never :: Frp m => Evt m a

-- | Dynamics are step-wise constant effectful functions each step
--   transition is driven by underlying stream of events.
--   
--   Meaning of the Dyn is a process that evolves in time. We can start the
--   process by running <tt>runDyn</tt>. It produces a reference to the
--   process that runs in background.
--   
--   <pre>
--   runDyn :: Frp m =&gt; Dyn m a -&gt; DynRef m a
--   </pre>
--   
--   When reference is initialized we can query current value of it:
--   
--   <pre>
--   readDyn :: DynRef m a -&gt; m a
--   </pre>
--   
--   When we are done with observations we should shut down the background
--   process with:
--   
--   <pre>
--   cancelDyn :: DynRef m a -&gt; m ()
--   </pre>
--   
--   It kills the background process and triggers the release function of
--   underlying event stream.
data Dyn m a

-- | event based dynamic
Dyn :: (s -> m a) -> Evt m s -> m s -> m () -> Dyn m a

-- | get the value from internal state
[dyn'get] :: Dyn m a -> s -> m a

-- | stream of state updates
[dyn'evt] :: Dyn m a -> Evt m s

-- | initial state
[dyn'init] :: Dyn m a -> m s

-- | release resources for dynamic
[dyn'release] :: Dyn m a -> m ()

-- | Constant value
ConstDyn :: a -> Dyn m a

-- | Dyn that is constructed from effectful callback.
constDyn :: Frp m => m a -> Dyn m a

-- | Executes dynamic for observation. The dynamic is step-wise constant
--   function that is driven by some event stream. The function runs the
--   event stream process in background and samples the updated state.
--   
--   We can observe the value with <tt>readDyn</tt>. We need to shut down
--   the stream when we no longer need it with <tt>cancelDyn</tt> function.
runDyn :: Frp m => Dyn m a -> m (DynRef m a)

-- | Reference to running dynamic process by which we can query values
--   (<tt>readDyn</tt>). Also note that we no longer need the reference we
--   should release the resources by calling <tt>cancelDyn</tt>.
data DynRef m a
DynRef :: (s -> m a) -> Ref m s -> ThreadId -> m () -> DynRef m a
ConstRef :: a -> DynRef m a

-- | Reads current dynamic value.
readDyn :: Frp m => DynRef m a -> m a

-- | Shuts down the background process for dynamic and releases resulrces
--   for event stream that drives the dynamic.
cancelDyn :: Frp m => DynRef m a -> m ()

-- | Runs the argument event stream as background process and produces
--   event stream that is fed with events over channel (unagi-channel
--   package). When result event stream shuts down the background process
--   also shuts down.
newEvt :: Frp m => Evt m a -> m (Evt m a)

-- | Runs the dynamic process in background and returns dynamic that just
--   samples the background proces with <tt>readDyn</tt>.
newDyn :: Frp m => Dyn m a -> m (Dyn m a)

-- | Runs dynamic within the scope of the function. It provides a callback
--   with dyn getter as argument and after callback finishes it shutdowns
--   the dyn process.
withDyn :: Frp m => Dyn m a -> (m a -> m b) -> m b

-- | scan over event stream. Example:
--   
--   <pre>
--   naturals = scan (+) 0 pulse
--   </pre>
scan :: Frp m => (a -> b -> b) -> b -> Evt m a -> Evt m b

-- | scan combined with filter. If accumulator function produces
--   <tt>Nothing</tt> on event then that event is ignored and state is kept
--   to previous state.
scanMay :: Frp m => (a -> b -> Maybe b) -> b -> Evt m a -> Evt m b

-- | Map with filtering. When <tt>Nothing</tt> is produced event is omitted
--   from the stream.
mapMay :: Frp m => (a -> Maybe b) -> Evt m a -> Evt m b

-- | Accumulate over event stream.
accum :: Frp m => (a -> s -> (b, s)) -> s -> Evt m a -> Evt m b

-- | Accumulates the values with event stream that produce functions.
accumB :: Frp m => a -> Evt m (a -> a) -> Dyn m a

-- | Accumulate over event stream.
accumMay :: Frp m => (a -> s -> Maybe (b, s)) -> s -> Evt m a -> Evt m b

-- | Filtering of the event strewams. Only events that produce True remain
--   in the stream.
filters :: Frp m => (a -> Bool) -> Evt m a -> Evt m a

-- | Filters based on Maybe. If <tt>Nothing</tt> is produced forthe event
--   it is omitted from the stream.
filterJust :: Frp m => Evt m (Maybe a) -> Evt m a

-- | Filters with dynamic. When dynamic is true events pass through and
--   when it's false events are omitted.
whens :: Frp m => Dyn m Bool -> Evt m a -> Evt m a

-- | Splits the either event stream.
splits :: Frp m => Evt m (Either a b) -> (Evt m a, Evt m b)

-- | Gets all left events from the stream
lefts :: Frp m => Evt m (Either a b) -> Evt m a

-- | Gets all right events from the stream
rights :: Frp m => Evt m (Either a b) -> Evt m b

-- | Iterates over event stream. It's like scan but it ignores the values
--   of underying stream and starts with initial value as first element.
iterates :: Frp m => (a -> a) -> a -> Evt m b -> Evt m a
withIterates :: Frp m => (a -> a) -> a -> Evt m b -> Evt m (a, b)

-- | Recursion on event streams. As event streams are functions we can not
--   use normal recursion that haskell provides. It will stuck the
--   execution. But we can use <tt>fix1</tt> to create event stream that
--   feeds back the events to itself.
--   
--   Note that any sort of recursion can be implemented with <tt>fix1</tt>.
--   For example if we need 3-recursive event stream:
--   
--   <pre>
--   fix3 ::
--        (Evt m a -&gt; Evt m b -&gt; Evt m c -&gt; m (Evt m a, Evt m b, Evt m c))
--     -&gt; (Evt m a, Evt m b, Evt m c)
--   </pre>
--   
--   we can use sum tpye tags to join it to single stream:
--   
--   <pre>
--   data Tag a b c = TagA a | TagB b | TagC c
--   </pre>
--   
--   <pre>
--   fix3 f = unwrap $ fix1 g
--     where
--        g x = wrap &lt;$&gt; f (unwrapA x) (unwrapB x) (unwrapC x)
--   
--        wrap a b c = mconcat [TagA &lt;$&gt; a, TagB &lt;$&gt; b, TagC &lt;$&gt; c]
--        unwrap evt = (unwrapA evt, unwrapB evt, unwrapC evt)
--   
--        unwrapA = flip mapMay $ \x -&gt; case x of
--                                    TagA a -&gt; Just a
--                                    _      -&gt; Nothing
--   </pre>
--   
--   We can use this trck with any number of streams. There are helper
--   functions: <tt>fix2</tt>, <tt>fix3</tt>, <tt>fix4</tt>
fix1 :: Frp m => (Evt m a -> m (Evt m a)) -> Evt m a

-- | Recursion for binary functions
fix2 :: Frp m => (Evt m a -> Evt m b -> m (Evt m a, Evt m b)) -> (Evt m a, Evt m b)

-- | Recursion for ternary functions
fix3 :: Frp m => (Evt m a -> Evt m b -> Evt m c -> m (Evt m a, Evt m b, Evt m c)) -> (Evt m a, Evt m b, Evt m c)

-- | Recursion for functions of four arguments
fix4 :: Frp m => (Evt m a -> Evt m b -> Evt m c -> Evt m d -> m (Evt m a, Evt m b, Evt m c, Evt m d)) -> (Evt m a, Evt m b, Evt m c, Evt m d)

-- | Flattens event stream producer by switching between event streams.
--   When next event stream happens it shuts down the previous one.
switch :: Frp m => Evt m (Evt m a) -> Evt m a

-- | Joins event stream of streams. If stream is started it runs until the
--   end.
joins :: Frp m => Evt m (Evt m a) -> Evt m a

-- | Delays in the thread of execution. Note that it can interfere and
--   screw up functions like clock, timer, pulse, ticks
delay :: Frp m => NominalDiffTime -> Evt m a -> Evt m a

-- | Delays in background by forking on each event. Note tht if delayed
--   event was put into background prior to stopping of the main event
--   stream it will fire anyway. There is no way to stop it.
delayFork :: Frp m => NominalDiffTime -> Evt m a -> Evt m a

-- | Sums all the elements in the event stream
sums :: (Frp m, Num a) => Evt m a -> Evt m a

-- | Sums all points in the signal with given time step
sumD :: (Frp m, Num a) => NominalDiffTime -> Dyn m a -> Dyn m a

-- | Integrates signal of vectors with given time step
integrate :: (Frp m, VectorSpace v, Real (Scalar v), Fractional (Scalar v)) => Scalar v -> Dyn m v -> Dyn m v

-- | More accurate integration of signal of vectors with given time step
integrate2 :: (Frp m, VectorSpace v, Real (Scalar v), Fractional (Scalar v)) => Scalar v -> Dyn m v -> Dyn m v

-- | Finds the product of all elements in the event stream.
products :: (Frp m, Num a) => Evt m a -> Evt m a

-- | Counts how many events accured so far on the stream.
count :: Frp m => Evt m a -> Evt m Int
withCount :: Frp m => Evt m a -> Evt m (Int, a)

-- | Monoidal append of all elements in the stream
appends :: (Frp m, Monoid a) => Evt m a -> Evt m a

-- | Same as foldMap only for streams.
foldMaps :: (Frp m, Monoid b) => (a -> b) -> Evt m a -> Evt m b

-- | Takes only so many events from the stream
takes :: Frp m => Int -> Evt m a -> Evt m a

-- | Drops first so many events from the stream
drops :: Frp m => Int -> Evt m a -> Evt m a

-- | Takes events only while predicate is true.
takesWhile :: Frp m => (a -> Bool) -> Evt m a -> Evt m a

-- | Drops events while predicate is true.
dropsWhile :: Frp m => (a -> Bool) -> Evt m a -> Evt m a

-- | Cycles the values in the list over event sream.
cycles :: Frp m => [a] -> Evt m b -> Evt m a

-- | Takes elements from the list by index. If index is out of bounds the
--   event is omitted.
listAt :: Frp m => [a] -> Evt m Int -> Evt m a

-- | Turns event stream to toggle stream. It produce cyclic sequence of
--   [True, False]
toToggle :: Frp m => Evt m a -> Evt m Bool

-- | Takes an event and repeats it all the time.
forevers :: Frp m => Evt m a -> Evt m a

-- | Shutdown the remaining event if one of the events close up early.
races :: Frp m => Evt m a -> Evt m a -> Evt m a

-- | Execute each callback in separate thread
forks :: Frp m => Evt m a -> Evt m a
heads :: Frp m => Evt m a -> m a

-- | Starts event stream process and as callback prints it values.
prints :: (Frp m, Show a) => Evt m a -> m ()

-- | Starts event stream process and as callback prints it values.
putStrLns :: Frp m => Evt m String -> m ()

-- | Monoidal fold for event streams, note that stream have to be finite
--   for the function to complete
folds :: (Frp m, Monoid a) => Evt m a -> m a

-- | Left fold for event streams, note that stream have to be finite for
--   the function to complete
foldls :: Frp m => (b -> a -> b) -> b -> Evt m a -> m b

-- | Effectful left fold
foldls' :: Frp m => (b -> a -> m b) -> b -> Evt m a -> m b

-- | Right fold for event streams, note that stream have to be finite for
--   the function to complete
foldrs :: Frp m => (a -> b -> b) -> b -> Evt m a -> m b

-- | Effectful right fold
foldrs' :: Frp m => (a -> b -> m b) -> b -> Evt m a -> m b
data Parser m a b
runParser :: Frp m => Parser m a b -> Evt m a -> m (Maybe b)

-- | Reads single event
takeP :: Frp m => Parser m a b -> Evt m a -> Evt m b
cycleP :: Frp m => Parser m a b -> Evt m a -> Evt m b

-- | Takes first element of the event stream and shuts the stream down.
headP :: Frp m => Parser m a a
maybeP :: Frp m => (a -> Maybe b) -> Parser m a b

-- | Turns event stream to dynamic. It holds the values of events until the
--   next event happen. It starts with initial value.
--   
--   <pre>
--   hold initVal events = ...
--   </pre>
hold :: Frp m => a -> Evt m a -> Dyn m a

-- | Turns dynamic into event stream of underlying events that trigger
--   dynamic updates.
unhold :: Frp m => Dyn m a -> Evt m a

-- | scans over event stream and converts it to dynamic.
scanD :: Frp m => (a -> b -> b) -> b -> Evt m a -> Dyn m b

-- | Dynamic scan that can also filter out events. If Nothing is produced
--   then the event is skipped.
scanMayD :: Frp m => (a -> b -> Maybe b) -> b -> Evt m a -> Dyn m b

-- | Switches between dynamic producers.
switchD :: Frp m => Dyn m a -> Evt m (Dyn m a) -> Dyn m a

-- | Queries the event stream form dynamic and runs it all next event
--   streams are ignored.
switchDyn :: Frp m => Dyn m (Evt m a) -> Evt m a

-- | Applies a function to event stream value. The function is sampled from
--   dynamic process.
apply :: Frp m => Dyn m (a -> b) -> Evt m a -> Evt m b

-- | Apply combined with filter.
applyMay :: Frp m => Dyn m (a -> Maybe b) -> Evt m a -> Evt m b

-- | Snapshot of dynamic process with event stream. All values in the event
--   stream are substituted with current value of dynamic.
snap :: Frp m => Dyn m a -> Evt m b -> Evt m a

-- | Attach element from dyn to event stream.
attach :: Frp m => Dyn m a -> Evt m b -> Evt m (a, b)

-- | Kind of <tt>zipWith</tt> function for dynamics and event streams.
attachWith :: Frp m => (a -> b -> c) -> Dyn m a -> Evt m b -> Evt m c

-- | Attach with filtering. When <tt>Nothing</tt> is produced event is
--   omitted from the stream.
attachWithMay :: Frp m => (a -> b -> Maybe c) -> Dyn m a -> Evt m b -> Evt m c

-- | Infix variant of <tt>apply</tt>
(<@>) :: Frp m => Dyn m (a -> b) -> Evt m a -> Evt m b
infixl 4 <@>

-- | Infix variant of <tt>snap</tt>.
(<@) :: Frp m => Dyn m a -> Evt m b -> Evt m a
infixl 4 <@
class FunctorM f
fmap' :: (FunctorM f, Frp m) => (a -> m b) -> f m a -> f m b

-- | Adds some procedure to callback. Procedure is called prior to callback
--   execution.
foreach :: Frp m => (a -> m ()) -> Evt m a -> Evt m a

-- | Adds some procedure to callback. Procedure is called after callback
--   execution.
posteach :: Frp m => (a -> m ()) -> Evt m a -> Evt m a

-- | Effectful version for <tt>iterates</tt>.
iterates' :: Frp m => (a -> m a) -> a -> Evt m b -> Evt m a

-- | scan over event stream with effectful function.
scan' :: Frp m => (a -> b -> m b) -> b -> Evt m a -> Evt m b

-- | scan combined with filter for effectful function. See <tt>scanMay</tt>
--   for details.
scanMay' :: Frp m => (a -> b -> m (Maybe b)) -> b -> Evt m a -> Evt m b

-- | Accumulate over event stream.
accum' :: Frp m => (a -> s -> m (b, s)) -> s -> Evt m a -> Evt m b

-- | Accumulate over event stream.
accumMay' :: Frp m => (a -> s -> m (Maybe (b, s))) -> s -> Evt m a -> Evt m b

-- | Effectful filtering for event streams.
filters' :: Frp m => (a -> m Bool) -> Evt m a -> Evt m a

-- | Effectful <tt>mapMay</tt>
mapMay' :: Frp m => (a -> m (Maybe b)) -> Evt m a -> Evt m b

-- | Effectful variant of <tt>apply</tt>.
apply' :: Frp m => Dyn m (a -> m b) -> Evt m a -> Evt m b

-- | Effectful <tt>applyMay</tt>.
applyMay' :: Frp m => Dyn m (a -> m (Maybe b)) -> Evt m a -> Evt m b

-- | Creates the event stream that listens to MVar based channel. If any
--   value is put chan the event stream fires the callback.
mchanEvt :: Frp m => Chan a -> Evt m a

-- | Creates the event stream that listens to <tt>TChan</tt> based channel.
--   If any value is put chan the event stream fires the callback.
tchanEvt :: Frp m => TChan a -> Evt m a

-- | Creates the event stream that listens to unagi channel (package
--   <tt>unagi-chan</tt>). If any value is put chan the event stream fires
--   the callback.
uchanEvt :: Frp m => InChan a -> Evt m a
type UChan a = (InChan a, OutChan a)

-- | Create a new Event and a function that will cause the Event to fire
newTriggerEvt :: (Frp m, MonadIO io) => m (Evt m a, a -> io ())

-- | Stream of user inputs
getLines :: Frp m => Evt m String

-- | Queries current time periodically with given period in seconds.
clock :: Frp m => NominalDiffTime -> Evt m UTCTime

-- | Produces pulse events with given period in seconds.
pulse :: Frp m => NominalDiffTime -> Evt m ()

-- | Produces pulse events with given period in seconds and also tells how
--   many seconds exactly has passed. It can be useful for simulations of
--   models that are based on differential equations. As event streams
--   carries how much time has passed between simulation steps.
ticks :: Frp m => NominalDiffTime -> Evt m NominalDiffTime

-- | Timer behaves like tocks only it produces accumulated time since
--   beginning of the process. It calculates them by querying current time
--   and suntracting start time from it.
--   
--   It can be though of as:
--   
--   <pre>
--   sums ticks
--   </pre>
timer :: Frp m => NominalDiffTime -> Evt m NominalDiffTime

-- | Timer as dynamic signal.
timerD :: Frp m => NominalDiffTime -> Dyn m NominalDiffTime

-- | Substitutes values in event stream with random values.
toRandom :: forall m a b. (Frp m, Random b) => Evt m a -> Evt m b

-- | Substitutes values in event stream with random values from the given
--   range.
toRandomR :: forall m a b. (Frp m, Random b) => (b, b) -> Evt m a -> Evt m b

-- | Substitutes values in event stream with random values.
withRandom :: forall m a b. (Frp m, Random b) => Evt m a -> Evt m (b, a)

-- | Substitutes values in event stream with random values from the given
--   range.
withRandomR :: forall m a b. (Frp m, Random b) => (b, b) -> Evt m a -> Evt m (b, a)

-- | Picks at random one element from the list
oneOf :: Frp m => [a] -> Evt m b -> Evt m a

-- | Picks at random one element from the list
withOneOf :: Frp m => [a] -> Evt m b -> Evt m (a, b)

-- | Picks at random one element from the list. We also provide
--   distribution of events. Probability to pick up the element. Sum of
--   probabilities should equal to 1.
freqOf :: (MonadRandom m, Frp m) => Dyn m [(a, Rational)] -> Evt m b -> Evt m a

-- | Picks at random one element from the list. We also provide
--   distribution of events. Probability to pick up the element. Sum of
--   probabilities should equal to 1.
withFreqOf :: (MonadRandom m, Frp m) => Dyn m [(a, Rational)] -> Evt m b -> Evt m (a, b)

-- | Skips at random elements from the list. We provide frequency to skip
--   events with dynamic first argument.
randSkip :: Frp m => Dyn m Double -> Evt m a -> Evt m a

-- | Skips elements at random. The probability to skip element depends on
--   the element itself.
randSkipBy :: Frp m => Dyn m (a -> Double) -> Evt m a -> Evt m a

-- | Lift a binary function to actions.
--   
--   Some functors support an implementation of <a>liftA2</a> that is more
--   efficient than the default one. In particular, if <a>fmap</a> is an
--   expensive operation, it is likely better to use <a>liftA2</a> than to
--   <a>fmap</a> over the structure and then use <a>&lt;*&gt;</a>.
--   
--   This became a typeclass method in 4.10.0.0. Prior to that, it was a
--   function defined in terms of <a>&lt;*&gt;</a> and <a>fmap</a>.
--   
--   Using <tt>ApplicativeDo</tt>: '<tt><a>liftA2</a> f as bs</tt>' can be
--   understood as the <tt>do</tt> expression
--   
--   <pre>
--   do a &lt;- as
--      b &lt;- bs
--      pure (f a b)
--   </pre>
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c

-- | Lift a ternary function to actions.
--   
--   Using <tt>ApplicativeDo</tt>: '<tt><a>liftA3</a> f as bs cs</tt>' can
--   be understood as the <tt>do</tt> expression
--   
--   <pre>
--   do a &lt;- as
--      b &lt;- bs
--      c &lt;- cs
--      pure (f a b c)
--   </pre>
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
class BasisArity v
basisArity :: BasisArity v => v -> Int
instance GHC.Base.Functor Dyna.St
instance Dyna.Frp m => GHC.Base.Functor (Dyna.Parser m a)
instance Dyna.Frp m => GHC.Base.Applicative (Dyna.Parser m a)
instance Dyna.BasisArity GHC.Types.Float
instance Dyna.BasisArity GHC.Types.Double
instance (Dyna.BasisArity a, Dyna.BasisArity b) => Dyna.BasisArity (a, b)
instance (Dyna.BasisArity a, Dyna.BasisArity b, Dyna.BasisArity c) => Dyna.BasisArity (a, b, c)
instance (Dyna.Frp m, Dyna.BasisArity v) => Dyna.BasisArity (Dyna.Dyn m v)
instance (Dyna.BasisArity v, Data.Basis.HasBasis v, Dyna.Frp m) => Data.Basis.HasBasis (Dyna.Dyn m v)
instance Dyna.FunctorM Dyna.Evt
instance Dyna.FunctorM Dyna.Dyn
instance GHC.Base.Functor m => GHC.Base.Functor (Dyna.Dyn m)
instance Dyna.Frp m => GHC.Base.Applicative (Dyna.Dyn m)
instance (Dyna.Frp m, GHC.Num.Num a) => GHC.Num.Num (Dyna.Dyn m a)
instance (Dyna.Frp m, GHC.Real.Fractional a) => GHC.Real.Fractional (Dyna.Dyn m a)
instance (Dyna.Frp m, GHC.Base.Semigroup a) => GHC.Base.Semigroup (Dyna.Dyn m a)
instance (Dyna.Frp m, GHC.Base.Monoid a) => GHC.Base.Monoid (Dyna.Dyn m a)
instance (Dyna.Frp m, Data.String.IsString a) => Data.String.IsString (Dyna.Dyn m a)
instance (Data.Boolean.Boolean b, Dyna.Frp m) => Data.Boolean.Boolean (Dyna.Dyn m b)
instance (Dyna.Frp m, Data.Boolean.IfB a) => Data.Boolean.IfB (Dyna.Dyn m a)
instance (Data.Boolean.EqB a, Dyna.Frp m) => Data.Boolean.EqB (Dyna.Dyn m a)
instance (Data.Boolean.OrdB a, Dyna.Frp m) => Data.Boolean.OrdB (Dyna.Dyn m a)
instance (Data.AdditiveGroup.AdditiveGroup a, Dyna.Frp m) => Data.AdditiveGroup.AdditiveGroup (Dyna.Dyn m a)
instance (Data.VectorSpace.VectorSpace a, Dyna.Frp m) => Data.VectorSpace.VectorSpace (Dyna.Dyn m a)
instance (Data.AffineSpace.AffineSpace p, Dyna.Frp m) => Data.AffineSpace.AffineSpace (Dyna.Dyn m p)
instance (Data.Cross.HasNormal v, Dyna.Frp m) => Data.Cross.HasNormal (Dyna.Dyn m v)
instance (Data.Cross.HasCross2 v, Dyna.Frp m) => Data.Cross.HasCross2 (Dyna.Dyn m v)
instance (Data.Cross.HasCross3 v, Dyna.Frp m) => Data.Cross.HasCross3 (Dyna.Dyn m v)
instance GHC.Base.Functor (Dyna.Evt m)
instance Dyna.Frp m => GHC.Base.Semigroup (Dyna.Evt m a)
instance Dyna.Frp m => GHC.Base.Monoid (Dyna.Evt m a)
instance Dyna.Frp m => GHC.Base.Applicative (Dyna.Evt m)
instance Dyna.Frp m => GHC.Base.Monad (Dyna.Evt m)
instance Dyna.Frp m => Temporal.Class.Melody (Dyna.Evt m a)
instance Dyna.Frp m => Temporal.Class.Harmony (Dyna.Evt m a)
instance Dyna.Frp m => Temporal.Class.Compose (Dyna.Evt m a)
instance Dyna.Frp m => Temporal.Class.Loop (Dyna.Evt m a)
instance Dyna.Frp m => Temporal.Class.Limit (Dyna.Evt m a)
instance Dyna.Frp GHC.Types.IO