Safe Haskell  Safe 

Language  Haskell2010 
Monadic Stream Functions are synchronized stream functions with side effects.
MSF
s are defined by a function
unMSF :: MSF m a b > a > m (b, MSF m a b)
that executes one step of a simulation, and produces an output in a
monadic context, and a continuation to be used for future steps.
MSF
s are a generalisation of the implementation mechanism used by Yampa,
Wormholes and other FRP and reactive implementations.
When combined with different monads, they produce interesting effects. For
example, when combined with the Maybe
monad, they become transformations
that may stop producing outputs (and continuations). The Either
monad
gives rise to MSF
s that end with a result (akin to Tasks in Yampa, and
Monadic FRP).
Flattening, that is, going from some structure MSF (t m) a b
to MSF m a b
for a specific transformer t
often gives rise to known FRP constructs.
For instance, flattening with EitherT
gives rise to switching, and
flattening with ListT
gives rise to parallelism with broadcasting.
MSF
s can be used to implement many FRP variants, including Arrowized FRP,
Classic FRP, and plain reactive programming. Arrowized and applicative
syntax are both supported.
For a very detailed introduction to MSF
s, see:
http://dl.acm.org/citation.cfm?id=2976010
(mirror: http://www.cs.nott.ac.uk/~psxip1/#FRPRefactored).
Synopsis
 data MSF m a b = MSF {}
 arrM :: Monad m => (a > m b) > MSF m a b
 liftS :: (Monad m2, MonadBase m1 m2) => (a > m1 b) > MSF m2 a b
 liftMSFTrans :: (MonadTrans t, Monad m, Monad (t m)) => MSF m a b > MSF (t m) a b
 liftMSFBase :: (Monad m2, MonadBase m1 m2) => MSF m1 a b > MSF m2 a b
 liftMSFPurer :: (Monad m2, Monad m1) => (forall c. m1 c > m2 c) > MSF m1 a b > MSF m2 a b
 iPre :: Monad m => a > MSF m a a
 delay :: Monad m => a > MSF m a a
 switch :: Monad m => MSF m a (b, Maybe c) > (c > MSF m a b) > MSF m a b
 feedback :: Monad m => c > MSF m (a, c) (b, c) > MSF m a b
 embed :: Monad m => MSF m a b > [a] > m [b]
 reactimate :: Monad m => MSF m () () > m ()
Definitions
Stepwise, sideeffectful MSF
s without implicit knowledge of time.
MSF
s should be applied to streams or executed indefinitely or until they
terminate. See reactimate
and reactimateB
for details. In general,
calling the value constructor MSF
or the function unMSF
is discouraged.
Instances
Monad m => Arrow (MSF m) Source #  
(Monad m, MonadPlus m) => ArrowZero (MSF m) #  Instance of 
(Monad m, MonadPlus m) => ArrowPlus (MSF m) #  Instance of 
Monad m => ArrowChoice (MSF m) # 

MonadFix m => ArrowLoop (MSF m) # 

Monad m => Category (MSF m :: * > * > *) Source #  
Functor m => Functor (MSF m a) Source #  
Monad m => Applicative (MSF m a) Source # 

(Monad m, MonadPlus m) => Alternative (MSF m a) #  
(Monad m, Floating b) => Floating (MSF m a b) #  
Defined in Data.MonadicStreamFunction.Instances.Num exp :: MSF m a b > MSF m a b # log :: MSF m a b > MSF m a b # sqrt :: MSF m a b > MSF m a b # (**) :: MSF m a b > MSF m a b > MSF m a b # logBase :: MSF m a b > MSF m a b > MSF m a b # sin :: MSF m a b > MSF m a b # cos :: MSF m a b > MSF m a b # tan :: MSF m a b > MSF m a b # asin :: MSF m a b > MSF m a b # acos :: MSF m a b > MSF m a b # atan :: MSF m a b > MSF m a b # sinh :: MSF m a b > MSF m a b # cosh :: MSF m a b > MSF m a b # tanh :: MSF m a b > MSF m a b # asinh :: MSF m a b > MSF m a b # acosh :: MSF m a b > MSF m a b # atanh :: MSF m a b > MSF m a b # log1p :: MSF m a b > MSF m a b # expm1 :: MSF m a b > MSF m a b #  
(Monad m, Fractional b) => Fractional (MSF m a b) # 

(Monad m, Num b) => Num (MSF m a b) #  
Defined in Data.MonadicStreamFunction.Instances.Num  
(Monad m, VectorSpace v) => VectorSpace (MSF m a v) Source #  Vectorspace instance for 
(Monad m, RModule v) => RModule (MSF m a v) Source #  Rmodule instance for 
Defined in Data.MonadicStreamFunction.Instances.VectorSpace type Groundring (MSF m a v) :: * Source #  
type Groundring (MSF m a v) Source #  
Monadic computations and
MSF
s
Lifting pointwise computations
liftS :: (Monad m2, MonadBase m1 m2) => (a > m1 b) > MSF m2 a b Source #
Monadic lifting from one monad into another
Lifting
MSF
s
Lifting across monad stacks
liftMSFTrans :: (MonadTrans t, Monad m, Monad (t m)) => MSF m a b > MSF (t m) a b Source #
Lift inner monadic actions in monad stacks.
liftMSFBase :: (Monad m2, MonadBase m1 m2) => MSF m1 a b > MSF m2 a b Source #
Lift innermost monadic actions in a monad stacks (generalisation of
liftIO
).
Generic
MSF
Lifting
liftMSFPurer :: (Monad m2, Monad m1) => (forall c. m1 c > m2 c) > MSF m1 a b > MSF m2 a b Source #
Lifting purer monadic actions (in an arbitrary way)
Delays
Switching
Feedback loops
feedback :: Monad m => c > MSF m (a, c) (b, c) > MSF m a b Source #
Wellformed looped connection of an output component as a future input.
Execution/simulation
embed :: Monad m => MSF m a b > [a] > m [b] Source #
Apply a monadic stream function to a list.
Because the result is in a monad, it may be necessary to
traverse the whole list to evaluate the value in the results to WHNF.
For example, if the monad is the maybe monad, this may not produce anything
if the MSF
produces Nothing
at any point, so the output stream cannot
consumed progressively.
To explore the output progressively, use liftMSF
and '(>>>)'', together
with some action that consumes/actuates on the output.
This is called runSF
in Liu, Cheng, Hudak, "Causal Commutative Arrows and
Their Optimization"