úÎhŇ_ôR      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQNone6B!R8The phases every signal goes through during a superstep.hA signal generator is the only source of stateful signals. It can be thought of as a function of type Nat -> aŤ, where the result is an arbitrary data structure that can potentially contain new signals, and the argument is the creation time of these new signals. It exposes the Să interface, which makes it possible to define signals in terms of each other. Unlike the simple variant, the denotation of signal generators differs from that of signals. We will use the following notation for generators: g = <|g0 g1 g2 ...|>hJust like signals, generators behave as functions of time, but they can also refer to the clock signal: -g t_start s_clock = [g0,g1,g2,...] !! t_startĺThe conceptual difference between the two notions is that signals are passed a sampling time, while generators expect a start time that will be the creation time of all the freshly generated signals in the resulting structure.TKA dynamic set of actions to update a network without breaking consistency.UA pointer to an update pair.Vclocked subnetwork superstepWordinary signalXA pair of actions to update a signal in two phases: internal update without changing the output, finalisation (throwing away previous state).]A signal represents a value changing over time. It can be thought of as a function of type Nat -> a4, where the argument is the sampling time, and the Yą instance agrees with the intuition (bind corresponds to extracting the current sample). Signals and the values they carry are denoted the following way in the documentation: s = <<s0 s1 s2 ...>>This says that s is a signal that reads s0 during the first sampling, s16 during the second and so on. You can also think of s as the following function: 's t_sample = [s0,s1,s2,...] !! t_sample‚Signals are constrained to be sampled sequentially, there is no random access. The only way to observe their output is through .Embedding a signal into an Z˙Ł environment. Repeated calls to the computation returned cause the whole network to be updated, and the current sample of the top-level signal is produced as a result. This is the only way to extract a signal generator outside the network, and it is equivalent to passing zero to the function representing the generator. The clock associated with the top-level signal ticks at every sampling point. In general: NreplicateM n =<< start <|<<x0 x1 x2 x3 ...>> ...|> == take n [x0,x1,x2,x3,...]Example: Odo smp <- start (stateful 3 (+2)) res <- replicateM 5 smp print resOutput:  [3,5,7,9,11][#Performing the two-phase superstep.\NAuxiliary function used by all the primitives that create a mutable variable.The Ţ combinator is the elementary building block for adding state to the signal network by constructing delayed versions of a signal that emit a given value at creation time and the previous output of the signal afterwards.5The clock signal associated to the generator affects ˙+ elements the following way: if the clock signal is true, the delay works as usual, otherwise it remembers its current output and throws away its current input. If we consider signals to be functions of time (natural numbers), the behaviour of delay can be described by the following function: ˙"delay x0 s t_start s_clock t_sample | t_start == t_sample = x0 | t_start < t_sample = if s_clock t_sample then s (t_sample-1) else delay x0 s t_start s_clock (t_sample-1) | otherwise = error "stream doesn't exist yet"+The way signal generators are extracted by * ensures that the error can never happen.Example (requires the DoRec extension): Ădo smp <- start $ do rec let fib'' = liftA2 (+) fib' fib fib' <- delay 1 fib'' fib <- delay 1 fib' return fib res <- replicateM 7 smp print resOutput: [1,1,2,3,5,8,13]˙GA formal conversion from signals to signal generators, which effectively allows for retrieving the current value of a previously created signal within a generator. This includes both signals defined in an external scope as well as those created earlier in the same generator. It can be modelled by the following function: &snapshot s t_start s_clock = s t_start]Auxiliary function.˙A reactive signal that takes the value to output from a signal generator carried by its input with the sampling time provided as the start time for the generated structure. It is possible to create new signals in the monad, which is the key to defining dynamic data-flow networks. ˙ generator << <|x00 x01 x02 ...|> <|x10 x11 x12 ...|> <|x20 x21 x22 ...|> ... >> = <| <<x00 x11 x22 ...>> <<x00 x11 x22 ...>> <<x00 x11 x22 ...>> ... |>/It can be thought of as the following function: Bgenerator g t_start s_clock t_sample = g t_sample s_clock t_sampleIt has to live in the ˙i monad, because it needs to maintain an internal state to be able to cache the current sample for efficiency reasons. However, this state is not carried between samples, therefore start time doesn't matter and can be ignored. Also, even though it does not make use of the clock itself, part of its job is to distribute it among the newly generated signals.-Refer to the longer example at the bottom of FRP.Elerea.Simple to see how it can be used.ÄMemoising combinator. It can be used to cache results of applicative combinators in case they are used in several places. Unlike in the simple variant, it is not observationally equivalent to ^ in the X monad, because it only samples its input signal when the associated clock ticks. The memo7 combinator can be modelled by the following function: |memo s t_start s_clock t_sample | s_clock t_sample = s t_sample | otherwise = memo s t_start s_clock (t_sample-1)For instance, if  s = f <$> s', then f1 will be recalculated once for each sampling of s". This can be avoided by writing s <- memo (f <$> s') instead. However, C incurs a small overhead, therefore it should not be used blindly.AAll the functions defined in this module return memoised signals.ŽA signal that is true exactly once: the first time the input signal is true. Afterwards, it is constantly false, and it holds no reference to the input signal. Note that e always follows the master clock, i.e. the fastest one, therefore it never creates a long spike of True?. For instance (assuming the rest of the input is constantly False): ˙Ountil <<False False True True False True ...>> = <| <<False False True False False False False False False False ...>> << --- False True False False False False False False False ...>> << --- --- True False False False False False False False ...>> << --- --- --- True False False False False False False ...>> << --- --- --- --- False True False False False False ...>> << --- --- --- --- --- True False False False False ...>> << --- --- --- --- --- --- False False False False ...>> ... |>UIt is observationally equivalent to the following expression (which would hold onto s forever): wuntil s = global $ do step <- transfer False (||) s dstep <- delay False step memo (liftA2 (/=) step dstep)Example: Źdo smp <- start $ do cnt <- stateful 0 (+1) tick <- until ((>=3) <$> cnt) return $ liftA2 (,) cnt tick res <- replicateM 6 smp print resOutput: <[(0,False),(1,False),(2,False),(3,True),(4,False),(5,False)] ˙Override the clock used in a generator. Note that clocks don't interact unless one is used in the definition of the other, i.e. it is possible to provide a fast clock within a generator with a slow associated clock. It is equivalent to the following function: +withClock s g t_start s_clock = g t_start s.For instance, the following equivalence holds: /withClock (pure False) (stateful x f) == pure x Equivalent to withClock (pure True), but more efficient. ˙şA signal that can be directly fed through the sink function returned. This can be used to attach the network to the outer world. The signal always yields the value last written to the sink. In other words, if the sink is written less frequently than the network sampled, the output remains the same during several samples. If values are pushed in the sink more frequently, only the last one before sampling is visible on the output.Example: Şdo (sig,snk) <- external 4 smp <- start (return sig) r1 <- smp r2 <- smp snk 7 r3 <- smp snk 9 snk 2 r4 <- smp print [r1,r2,r3,r4]Output:  [4,4,7,2] űAn event-like signal that can be fed through the sink function returned. The signal carries a list of values fed in since the last sampling (always synchronised to the top-level samplings regardless of any associated clock), i.e. it is constantly []– if the sink is never invoked. The order of elements is reversed, so the last value passed to the sink is the head of the list. Note that unlike  — this function only returns a generator to be used within the expression constructing the top-level stream, and this generator can only be used once.Example: ¤do (gen,snk) <- externalMulti smp <- start gen r1 <- smp snk 7 r2 <- smp r3 <- smp snk 9 snk 2 r4 <- smp print [r1,r2,r3,r4]Output: [[],[7],[],[2,9]] ĐA pure stateful signal. The initial state is the first output, and every subsequent state is derived from the preceding one by applying a pure transformation. It is affected by the associated clock like W: no transformation is performed in the absence of a tick; see the example at the top.Example: Sdo smp <- start (stateful "x" ('x':)) res <- replicateM 5 smp print resOutput: ["x","xx","xxx","xxxx","xxxxx"]˙ŽA stateful transfer function. The current input affects the current output, i.e. the initial state given in the first argument is considered to appear before the first output, and can never be observed, and subsequent states are determined by combining the preceding state with the current output of the input signal using the function supplied. It is affected by the associated clock like W: no transformation is performed in the absence of a tick; see the example at the top.Example: }do smp <- start $ do cnt <- stateful 1 (+1) transfer 10 (+) cnt res <- replicateM 5 smp print resOutput: [11,13,16,20,25]A variation of  with two input signals.A variation of  with three input signals.A variation of  with four input signals.An IO action executed in the  monad. Can be used as _.@A signal that executes a given IO action once at every sampling.˙7In essence, this combinator provides cooperative multitasking capabilities, and its primary purpose is to assist library writers in wrapping effectful APIs as conceptually pure signals. If there are several effectful signals in the system, their order of execution is undefined and should not be relied on.Example: ëdo smp <- start $ do ref <- execute $ newIORef 0 effectful $ do x <- readIORef ref putStrLn $ "Count: " ++ show x writeIORef ref $! x+1 return () replicateM_ 5 smpOutput: ,Count: 0 Count: 1 Count: 2 Count: 3 Count: 4+Another example (requires mersenne-random): mdo smp <- start $ effectful $ return randomIO :: IO (IO Double) res <- replicateM 5 smp print resOutput: a[0.12067753390401374,0.8658877349182655,0.7159264443196786,0.1756941896012891,0.9513646060896676]ŒA signal that executes a parametric IO action once at every sampling. The parameter is supplied by another signal at every sampling step.Like !, but with two parameter signals.Like #, but with three parameter signals.Like ", but with four parameter signals.`3Error message for unimplemented instance functions.7RabcdTUVWXef%the generator of the top-level signal$the computation to sample the signal[\sampling functionaging function&the mutable variable behind the signalthe pool of update actionsthe signal createdinitial output at creation timethe signal to delaythe delayed signal]the signal of generators to run"the signal of generated structuresthe signal to cache3a signal observationally equivalent to the argumentthe boolean input signal<a one-shot signal true only the first time the input is true  initial value(the signal and an IO function to feed it 8a generator for the event signal and the associated sink  initial statestate transformationinitial internal statestate updater function input signalinitial internal statestate updater functioninput signal 1input signal 2initial internal statestate updater functioninput signal 1input signal 2input signal 3initial internal statestate updater functioninput signal 1input signal 2input signal 3input signal 4$the action to be executed repeatedly$the action to be executed repeatedlyparameter signal$the action to be executed repeatedlyparameter signal 1parameter signal 2$the action to be executed repeatedlyparameter signal 1parameter signal 2parameter signal 3$the action to be executed repeatedlyparameter signal 1parameter signal 2parameter signal 3parameter signal 4`ghijklmnopqrstuv   0RbacdTUWVXef[\] `ghijklmnopqrstuvNone6Bw8The phases every signal goes through during a superstep.hA signal generator is the only source of stateful signals. It can be thought of as a function of type Nat -> Signal p -> aä, where the result is an arbitrary data structure that can potentially contain new signals, the first argument is the creation time of these new signals, and the second is a globally accessible input signal. It exposes the Să interface, which makes it possible to define signals in terms of each other. Unlike the simple variant, the denotation of signal generators differs from that of signals. We will use the following notation for generators: g = <|g0 g1 g2 ...|>hJust like signals, generators behave as functions of time, but they can also refer to the input signal: -g t_start s_input = [g0,g1,g2,...] !! t_startĺThe conceptual difference between the two notions is that signals are passed a sampling time, while generators expect a start time that will be the creation time of all the freshly generated signals in the resulting structure.xKA dynamic set of actions to update a network without breaking consistency.]A signal represents a value changing over time. It can be thought of as a function of type Nat -> a4, where the argument is the sampling time, and the Yą instance agrees with the intuition (bind corresponds to extracting the current sample). Signals and the values they carry are denoted the following way in the documentation: s = <<s0 s1 s2 ...>>This says that s is a signal that reads s0 during the first sampling, s16 during the second and so on. You can also think of s as the following function: 's t_sample = [s0,s1,s2,...] !! t_sample‚Signals are constrained to be sampled sequentially, there is no random access. The only way to observe their output is through .Embedding a signal into an Z˙ő environment. Repeated calls to the computation returned cause the whole network to be updated, and the current sample of the top-level signal is produced as a result. The computation accepts a global parameter that will be distributed to all signals. For instance, this can be the time step, if we want to model continuous-time signals. This is the only way to extract a signal generator outside the network, and it is equivalent to passing zero to the function representing the generator.Example: Sdo smp <- start (stateful 10 (+)) res <- forM [5,3,2,9,4] smp print resOutput: [10,15,18,20,29]y#Performing the two-phase superstep.zNAuxiliary function used by all the primitives that create a mutable variable.The ß combinator is the elementary building block for adding state to the signal network by constructing delayed versions of a signal that emit a given value at creation time and the previous output of the signal afterwards (-- is undefined): żdelay x0 s = <| <<x0 s0 s1 s2 s3 ...>> <<-- x0 s1 s2 s3 ...>> <<-- -- x0 s2 s3 ...>> <<-- -- -- x0 s3 ...>> ... |>iIt can be thought of as the following function (which should also make it clear why the return value is ): Ÿdelay x0 s t_start s_input t_sample | t_start == t_sample = x0 | t_start < t_sample = s (t_sample-1) | otherwise = error \"Premature sample!\"+The way signal generators are extracted by T ensures that the error can never happen. It is also clear that the behaviour of 0 is not affected in any way by the global input.Example (requires the DoRec extension): Ďdo smp <- start $ do rec let fib'' = liftA2 (+) fib' fib fib' <- delay 1 fib'' fib <- delay 1 fib' return fib res <- replicateM 7 (smp undefined) print resOutput: [1,1,2,3,5,8,13]˙GA formal conversion from signals to signal generators, which effectively allows for retrieving the current value of a previously created signal within a generator. This includes both signals defined in an external scope as well as those created earlier in the same generator. It can be modelled by the following function: &snapshot s t_start s_input = s t_start{Auxiliary function.˙A reactive signal that takes the value to output from a signal generator carried by its input with the sampling time provided as the start time for the generated structure. It is possible to create new signals in the monad, which is the key to defining dynamic data-flow networks. ˙ generator << <|x00 x01 x02 ...|> <|x10 x11 x12 ...|> <|x20 x21 x22 ...|> ... >> = <| <<x00 x11 x22 ...>> <<x00 x11 x22 ...>> <<x00 x11 x22 ...>> ... |>/It can be thought of as the following function: Bgenerator g t_start s_input t_sample = g t_sample t_sample s_inputIt has to live in the ˙q monad, because it needs to maintain an internal state to be able to cache the current sample for efficiency reasons. However, this state is not carried between samples, therefore start time doesn't matter and can be ignored. Also, even though it does not make use of the global input itself, part of its job is to distribute it among the newly generated signals.-Refer to the longer example at the bottom of FRP.Elerea.Simple to see how it can be used.ĄMemoising combinator. It can be used to cache results of applicative combinators in case they are used in several places. It is observationally equivalent to ^ in the  monad. memo s = <|s s s s ...|>For instance, if  s = f <$> s', then f1 will be recalculated once for each sampling of s". This can be avoided by writing s <- memo (f <$> s') instead. However, C incurs a small overhead, therefore it should not be used blindly.MAll the functions defined in this module return memoised signals. Just like (, it is independent of the global input.ŕA signal that is true exactly once: the first time the input signal is true. Afterwards, it is constantly false, and it holds no reference to the input signal. For instance (assuming the rest of the input is constantly False): ˙Ountil <<False False True True False True ...>> = <| <<False False True False False False False False False False ...>> << --- False True False False False False False False False ...>> << --- --- True False False False False False False False ...>> << --- --- --- True False False False False False False ...>> << --- --- --- --- False True False False False False ...>> << --- --- --- --- --- True False False False False ...>> << --- --- --- --- --- --- False False False False ...>> ... |>UIt is observationally equivalent to the following expression (which would hold onto s forever): vuntil s = do step <- transfer False (const (||)) s dstep <- delay False step memo (liftA2 (/=) step dstep)Example: şdo smp <- start $ do accum <- stateful 0 (+) tick <- until ((>=10) <$> accum) return $ liftA2 (,) accum tick res <- forM [4,1,3,5,2,8,6] smp print resOutput: I[(0,False),(4,False),(5,False),(8,False),(13,True),(15,False),(23,False)] FThe common input signal that is fed through the function returned by , unless we are in an !<ded generator. It is equivalent to the following function: input t_start s_input = s_inputExample: vdo smp <- start $ do sig <- input return (sig*2) res <- forM [4,1,3,5,2,8,6] smp print resOutput: [8,2,6,10,4,16,12]!`Embed a generator with an overridden input signal. It is equivalent to the following function: 'embed s g t_start s_input = g t_start sExample: Ždo smp <- start $ do sig <- input embed (sig*2) $ do sig <- input return (sig+1) res <- forM [4,1,3,5,2,8,6] smp print resOutput: [9,3,7,11,5,17,13]"˙'A signal that can be directly fed through the sink function returned. This can be used to attach the network to the outer world. Note that this is optional, as all the input of the network can be fed in through the global parameter, although that is not really convenient for many signals.#˙>An event-like signal that can be fed through the sink function returned. The signal carries a list of values fed in since the last sampling, i.e. it is constantly [] if the sink is never invoked. The order of elements is reversed, so the last value passed to the sink is the head of the list. Note that unlike "— this function only returns a generator to be used within the expression constructing the top-level stream, and this generator can only be used once.$äA direct stateful transformation of the input. The initial state is the first output, and every following output is calculated from the previous one and the value of the global parameter (which might have been overridden by !).Example: Pdo smp <- start (stateful "" (:)) res <- forM "olleh~" smp print resOutput: "["","o","lo","llo","ello","hello"]%˙PA stateful transfer function. The current input affects the current output, i.e. the initial state given in the first argument is considered to appear before the first output, and can never be observed. Every output is derived from the current value of the input signal, the global parameter (which might have been overridden by !J) and the previous output. It is equivalent to the following expression:QExample (assuming a delta time is passed to the sampling function in each step): /integral x0 s = transfer x0 (\dt v x -> x+dt*v)Example for using the above: Ydo smp <- start (integral 3 (pure 2)) res <- replicateM 7 (smp 0.1) print resOutput: [3.2,3.4,3.6,3.8,4.0,4.2,4.4]&A variation of % with two input signals.'A variation of % with three input signals.(A variation of % with four input signals.)An IO action executed in the  monad. Can be used as _.*@A signal that executes a given IO action once at every sampling.˙7In essence, this combinator provides cooperative multitasking capabilities, and its primary purpose is to assist library writers in wrapping effectful APIs as conceptually pure signals. If there are several effectful signals in the system, their order of execution is undefined and should not be relied on.Example: ˙*do act <- start $ do ref <- execute $ newIORef 0 let accum n = do x <- readIORef ref putStrLn $ "Accumulator: " ++ show x writeIORef ref $! x+n return () effectful1 accum =<< input forM_ [4,9,2,1,5] actOutput: MAccumulator: 0 Accumulator: 4 Accumulator: 13 Accumulator: 15 Accumulator: 16+Another example (requires mersenne-random): ddo smp <- start $ effectful randomIO :: IO (IO Double) res <- replicateM 5 smp print resOutput: a[0.12067753390401374,0.8658877349182655,0.7159264443196786,0.1756941896012891,0.9513646060896676]+ŒA signal that executes a parametric IO action once at every sampling. The parameter is supplied by another signal at every sampling step.,Like +!, but with two parameter signals.-Like +#, but with three parameter signals..Like +", but with four parameter signals.|3Error message for unimplemented instance functions.}Equality test is impossible.~The Show* instance is only defined for the sake of ...2w€‚ƒx„%the generator of the top-level signal$the computation to sample the signalyzsampling functionaging function&the mutable variable behind the signalthe pool of update actionsinitial outputthe signal to delay{the signal of generators to run"the signal of generated structuresthe signal to cache3a signal observationally equivalent to the argumentthe boolean input signal<a one-shot signal true only the first time the input is true !" initial value(the signal and an IO function to feed it#8a generator for the event signal and the associated sink$ initial statestate transformation%initial internal statestate updater function input signal&initial internal statestate updater functioninput signal 1input signal 2'initial internal statestate updater functioninput signal 1input signal 2input signal 3(initial internal statestate updater functioninput signal 1input signal 2input signal 3input signal 4)*$the action to be executed repeatedly+$the action to be executed repeatedlyparameter signal,$the action to be executed repeatedlyparameter signal 1parameter signal 2-$the action to be executed repeatedlyparameter signal 1parameter signal 2parameter signal 3.$the action to be executed repeatedlyparameter signal 1parameter signal 2parameter signal 3parameter signal 4|…†‡ˆ‰Š‹Œ}~Ž‘’ !"#$%&'()*+,-."# !$%&'()*+,-.-w€‚ƒx„yz{ !"#$%&'()*+,-.|…†‡ˆ‰Š‹Œ}~Ž‘’ Safe-Inferred/0123456789:;</0123456789:;<0/123465789:;</0123456789:;<None6B“8The phases every signal goes through during a superstep.=hA signal generator is the only source of stateful signals. It can be thought of as a function of type Nat -> aŤ, where the result is an arbitrary data structure that can potentially contain new signals, and the argument is the creation time of these new signals. It exposes the S˙ interface, which makes it possible to define signals in terms of each other. The denotation of signal generators happens to be the same as that of signals, but this partly accidental (it does not hold in the other variants), so we will use a separate notation for generators: g = <|g0 g1 g2 ...|>:Just like signals, generators behave as functions of time: %g t_start = [g0,g1,g2,...] !! t_startĺThe conceptual difference between the two notions is that signals are passed a sampling time, while generators expect a start time that will be the creation time of all the freshly generated signals in the resulting structure.”KA dynamic set of actions to update a network without breaking consistency.>]A signal represents a value changing over time. It can be thought of as a function of type Nat -> a4, where the argument is the sampling time, and the Yą instance agrees with the intuition (bind corresponds to extracting the current sample). Signals and the values they carry are denoted the following way in the documentation: s = <<s0 s1 s2 ...>>This says that s is a signal that reads s0 during the first sampling, s16 during the second and so on. You can also think of s as the following function: 's t_sample = [s0,s1,s2,...] !! t_sample‚Signals are constrained to be sampled sequentially, there is no random access. The only way to observe their output is through ?.?Embedding a signal into an Z˙S environment. Repeated calls to the computation returned cause the whole network to be updated, and the current sample of the top-level signal is produced as a result. This is the only way to extract a signal generator outside the network, and it is equivalent to passing zero to the function representing the generator. In general: NreplicateM n =<< start <|<<x0 x1 x2 x3 ...>> ...|> == take n [x0,x1,x2,x3,...]Example: Odo smp <- start (stateful 3 (+2)) res <- replicateM 5 smp print resOutput:  [3,5,7,9,11]•#Performing the two-phase superstep.–NAuxiliary function used by all the primitives that create a mutable variable.@The @ß combinator is the elementary building block for adding state to the signal network by constructing delayed versions of a signal that emit a given value at creation time and the previous output of the signal afterwards (-- is undefined): żdelay x0 s = <| <<x0 s0 s1 s2 s3 ...>> <<-- x0 s1 s2 s3 ...>> <<-- -- x0 s2 s3 ...>> <<-- -- -- x0 s3 ...>> ... |>iIt can be thought of as the following function (which should also make it clear why the return value is =): —delay x0 s t_start t_sample | t_start == t_sample = x0 | t_start < t_sample = s (t_sample-1) | otherwise = error \"Premature sample!\"+The way signal generators are extracted by B* ensures that the error can never happen.Example (requires the DoRec extension): Ădo smp <- start $ do rec let fib'' = liftA2 (+) fib' fib fib' <- delay 1 fib'' fib <- delay 1 fib' return fib res <- replicateM 7 smp print resOutput: [1,1,2,3,5,8,13]A˙QA formal conversion from signals to signal generators, which effectively allows for retrieving the current value of a previously created signal within a generator. This includes both signals defined in an external scope as well as those created earlier in the same generator. In the model, it corresponds to the identity function.—Auxiliary function.B˙A reactive signal that takes the value to output from a signal generator carried by its input with the sampling time provided as the start time for the generated structure. It is possible to create new signals in the monad, which is the key to defining dynamic data-flow networks. ˙ generator << <|x00 x01 x02 ...|> <|x10 x11 x12 ...|> <|x20 x21 x22 ...|> ... >> = <| <<x00 x11 x22 ...>> <<x00 x11 x22 ...>> <<x00 x11 x22 ...>> ... |>/It can be thought of as the following function: 2generator g t_start t_sample = g t_sample t_sampleIt has to live in the =ä monad, because it needs to maintain an internal state to be able to cache the current sample for efficiency reasons. However, this state is not carried between samples, therefore start time doesn't matter and can be ignored.ERefer to the longer example at the bottom to see how it can be used.CĄMemoising combinator. It can be used to cache results of applicative combinators in case they are used in several places. It is observationally equivalent to ^ in the = monad. memo s = <|s s s s ...|>For instance, if  s = f <$> s', then f1 will be recalculated once for each sampling of s". This can be avoided by writing s <- memo (f <$> s') instead. However, CC incurs a small overhead, therefore it should not be used blindly.AAll the functions defined in this module return memoised signals.DŕA signal that is true exactly once: the first time the input signal is true. Afterwards, it is constantly false, and it holds no reference to the input signal. For instance (assuming the rest of the input is constantly False): ˙Ountil <<False False True True False True ...>> = <| <<False False True False False False False False False False ...>> << --- False True False False False False False False False ...>> << --- --- True False False False False False False False ...>> << --- --- --- True False False False False False False ...>> << --- --- --- --- False True False False False False ...>> << --- --- --- --- --- True False False False False ...>> << --- --- --- --- --- --- False False False False ...>> ... |>UIt is observationally equivalent to the following expression (which would hold onto s forever): nuntil s = do step <- transfer False (||) s dstep <- delay False step memo (liftA2 (/=) step dstep)Example: Źdo smp <- start $ do cnt <- stateful 0 (+1) tick <- until ((>=3) <$> cnt) return $ liftA2 (,) cnt tick res <- replicateM 6 smp print resOutput: <[(0,False),(1,False),(2,False),(3,True),(4,False),(5,False)]E˙şA signal that can be directly fed through the sink function returned. This can be used to attach the network to the outer world. The signal always yields the value last written to the sink. In other words, if the sink is written less frequently than the network sampled, the output remains the same during several samples. If values are pushed in the sink more frequently, only the last one before sampling is visible on the output.Example: Şdo (sig,snk) <- external 4 smp <- start (return sig) r1 <- smp r2 <- smp snk 7 r3 <- smp snk 9 snk 2 r4 <- smp print [r1,r2,r3,r4]Output:  [4,4,7,2]FŚAn event-like signal that can be fed through the sink function returned. The signal carries a list of values fed in since the last sampling, i.e. it is constantly []– if the sink is never invoked. The order of elements is reversed, so the last value passed to the sink is the head of the list. Note that unlike E— this function only returns a generator to be used within the expression constructing the top-level stream, and this generator can only be used once.Example: ¤do (gen,snk) <- externalMulti smp <- start gen r1 <- smp snk 7 r2 <- smp r3 <- smp snk 9 snk 2 r4 <- smp print [r1,r2,r3,r4]Output: [[],[7],[],[2,9]]GĄA pure stateful signal. The initial state is the first output, and every subsequent state is derived from the preceding one by applying a pure transformation.Example: Sdo smp <- start (stateful "x" ('x':)) res <- replicateM 5 smp print resOutput: ["x","xx","xxx","xxxx","xxxxx"]H˙_A stateful transfer function. The current input affects the current output, i.e. the initial state given in the first argument is considered to appear before the first output, and can never be observed, and subsequent states are determined by combining the preceding state with the current output of the input signal using the function supplied.Example: }do smp <- start $ do cnt <- stateful 1 (+1) transfer 10 (+) cnt res <- replicateM 5 smp print resOutput: [11,13,16,20,25]IA variation of H with two input signals.JA variation of H with three input signals.KA variation of H with four input signals.LAn IO action executed in the = monad. Can be used as _.M@A signal that executes a given IO action once at every sampling.˙7In essence, this combinator provides cooperative multitasking capabilities, and its primary purpose is to assist library writers in wrapping effectful APIs as conceptually pure signals. If there are several effectful signals in the system, their order of execution is undefined and should not be relied on.Example: ëdo smp <- start $ do ref <- execute $ newIORef 0 effectful $ do x <- readIORef ref putStrLn $ "Count: " ++ show x writeIORef ref $! x+1 return () replicateM_ 5 smpOutput: ,Count: 0 Count: 1 Count: 2 Count: 3 Count: 4+Another example (requires mersenne-random): ddo smp <- start $ effectful randomIO :: IO (IO Double) res <- replicateM 5 smp print resOutput: a[0.12067753390401374,0.8658877349182655,0.7159264443196786,0.1756941896012891,0.9513646060896676]NŒA signal that executes a parametric IO action once at every sampling. The parameter is supplied by another signal at every sampling step.OLike N!, but with two parameter signals.PLike N#, but with three parameter signals.QLike N", but with four parameter signals.˜3Error message for unimplemented instance functions.™Equality test is impossible.š8The Show instance is only defined for the sake of Num...0“›œ=ž”>Ÿ?%the generator of the top-level signal$the computation to sample the signal•–sampling functionaging function&the mutable variable behind the signalthe pool of update actionsthe signal created@initial output at creation timethe signal to delaythe delayed signalA—Bthe signal of generators to run"the signal of generated structuresCthe signal to cache3a signal observationally equivalent to the argumentDthe boolean input signal<a one-shot signal true only the first time the input is trueE initial value(the signal and an IO function to feed itF8a generator for the event signal and the associated sinkG initial statestate transformationHinitial internal statestate updater function input signalIinitial internal statestate updater functioninput signal 1input signal 2Jinitial internal statestate updater functioninput signal 1input signal 2input signal 3Kinitial internal statestate updater functioninput signal 1input signal 2input signal 3input signal 4LM$the action to be executed repeatedlyN$the action to be executed repeatedlyparameter signalO$the action to be executed repeatedlyparameter signal 1parameter signal 2P$the action to be executed repeatedlyparameter signal 1parameter signal 2parameter signal 3Q$the action to be executed repeatedlyparameter signal 1parameter signal 2parameter signal 3parameter signal 4˜ Ą˘Ł¤ĽŚ§™š¨ŠŞŤŹ­=>?@ABCDEFGHIJKLMNOPQ>=?EF@ABCDGHIJKLMNOPQ+“œ›=ž”>Ÿ?•–@A—BCDEFGHIJKLMNOPQ˜ Ą˘Ł¤ĽŚ§™š¨ŠŞŤŹ­ Safe-InferredŽ             !"        #$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL#&/016EFMN789:;=>?@ABCDGHIJKL#&/016EF789:;=>?@ABCDGHIJKLO elerea-2.8.0FRP.Elerea.Simple.PureFRP.Elerea.ClockedFRP.Elerea.ParamFRP.Elerea.Simple FRP.ElereabaseGHC.Baseuntil SignalGenSignalstartdelaysnapshot generatormemo withClockglobalexternal externalMultistatefultransfer transfer2 transfer3 transfer4execute effectful effectful1 effectful2 effectful3 effectful4inputembedfromListtoListPhaseControl.Monad.FixMonadFix UpdatePoolUpdateUClkUSig UpdateActionMonadghc-prim GHC.TypesIO superstep addSignalmemoisereturntransformers-0.3.0.0Control.Monad.IO.ClassliftIOunimpUpdatedReadySGunSGS getUpdate$fFloatingSignal$fFractionalSignal$fIntegralSignal $fRealSignal $fNumSignal$fBoundedSignal $fEnumSignal $fOrdSignal $fEqSignal $fShowSignal$fMonadBaseSignalGenSignalGen$fMonadIOSignalGen$fMonadFixSignalGen$fMonadSignalGen$fApplicativeSignalGen$fFunctorSignalGenGHC.NumNum