Safe Haskell  SafeInferred 

Language  Haskell2010 
Synopsis
 data Event a
 type ClockInfo m = ReaderT DTime m
 type SF m = MSF (ClockInfo m)
 type DTime = Double
 type Time = Double
 arrPrim :: Monad m => (a > b) > SF m a b
 arrEPrim :: Monad m => (Event a > b) > SF m (Event a) b
 identity :: Monad m => SF m a a
 constant :: Monad m => b > SF m a b
 localTime :: Monad m => SF m a Time
 time :: Monad m => SF m a Time
 (>) :: Monad m => b > SF m a b > SF m a b
 (:>) :: Monad m => b > SF m a b > SF m a b
 (>) :: Monad m => a > SF m a b > SF m a b
 (>=) :: Monad m => (a > a) > SF m a b > SF m a b
 initially :: Monad m => a > SF m a a
 sscan :: Monad m => (b > a > b) > b > SF m a b
 sscanPrim :: Monad m => (c > a > Maybe (c, b)) > c > b > SF m a b
 never :: Monad m => SF m a (Event b)
 now :: Monad m => b > SF m a (Event b)
 after :: Monad m => Time > b > SF m a (Event b)
 repeatedly :: Monad m => Time > b > SF m a (Event b)
 afterEach :: Monad m => [(Time, b)] > SF m a (Event b)
 afterEachCat :: Monad m => [(Time, b)] > SF m a (Event [b])
 mapEventS :: Monad m => MSF m a b > MSF m (Event a) (Event b)
 eventToMaybe :: Event a > Maybe a
 boolToEvent :: Bool > Event ()
 edge :: Monad m => SF m Bool (Event ())
 iEdge :: Monad m => Bool > SF m Bool (Event ())
 edgeTag :: Monad m => a > SF m Bool (Event a)
 edgeJust :: Monad m => SF m (Maybe a) (Event a)
 edgeBy :: Monad m => (a > a > Maybe b) > a > SF m a (Event b)
 maybeToEvent :: Maybe a > Event a
 edgeFrom :: Monad m => Bool > SF m Bool (Event ())
 notYet :: Monad m => SF m (Event a) (Event a)
 once :: Monad m => SF m (Event a) (Event a)
 takeEvents :: Monad m => Int > SF m (Event a) (Event a)
 dropEvents :: Monad m => Int > SF m (Event a) (Event a)
 noEvent :: Event a
 noEventFst :: (Event a, b) > (Event c, b)
 noEventSnd :: (a, Event b) > (a, Event c)
 event :: a > (b > a) > Event b > a
 fromEvent :: Event p > p
 isEvent :: Event a > Bool
 isNoEvent :: Event a > Bool
 tag :: Event a > b > Event b
 tagWith :: b > Event a > Event b
 attach :: Event a > b > Event (a, b)
 lMerge :: Event a > Event a > Event a
 rMerge :: Event a > Event a > Event a
 merge :: Event a > Event a > Event a
 mergeBy :: (a > a > a) > Event a > Event a > Event a
 mapMerge :: (a > c) > (b > c) > (a > b > c) > Event a > Event b > Event c
 mergeEvents :: [Event a] > Event a
 catEvents :: [Event a] > Event [a]
 joinE :: Event a > Event b > Event (a, b)
 splitE :: Event (a, b) > (Event a, Event b)
 filterE :: (a > Bool) > Event a > Event a
 mapFilterE :: (a > Maybe b) > Event a > Event b
 gate :: Event a > Bool > Event a
 switch :: Monad m => SF m a (b, Event c) > (c > SF m a b) > SF m a b
 dSwitch :: Monad m => SF m a (b, Event c) > (c > SF m a b) > SF m a b
 parB :: Monad m => [SF m a b] > SF m a [b]
 dpSwitchB :: (Monad m, Traversable col) => col (SF m a b) > SF m (a, col b) (Event c) > (col (SF m a b) > c > SF m a (col b)) > SF m a (col b)
 parC :: Monad m => SF m a b > SF m [a] [b]
 hold :: Monad m => a > SF m (Event a) a
 accumBy :: Monad m => (b > a > b) > b > SF m (Event a) (Event b)
 accumHoldBy :: Monad m => (b > a > b) > b > SF m (Event a) b
 loopPre :: Monad m => c > SF m (a, c) (b, c) > SF m a b
 integral :: (Monad m, VectorSpace a s) => SF m a a
 integralFrom :: (Monad m, VectorSpace a s) => a > SF m a a
 derivative :: (Monad m, VectorSpace a s) => SF m a a
 derivativeFrom :: (Monad m, VectorSpace a s) => a > SF m a a
 iterFrom :: Monad m => (a > a > DTime > b > b) > b > SF m a b
 occasionally :: MonadRandom m => Time > b > SF m a (Event b)
 reactimate :: Monad m => m a > (Bool > m (DTime, Maybe a)) > (Bool > b > m Bool) > SF Identity a b > m ()
 evalAtZero :: SF Identity a b > a > (b, SF Identity a b)
 evalAt :: SF Identity a b > DTime > a > (b, SF Identity a b)
 evalFuture :: SF Identity a b > a > DTime > (b, SF Identity a b)
 replaceOnce :: Monad m => a > SF m a a
 dup :: b > (b, b)
 leftApp :: ArrowApply a => a b c > a (Either b d) (Either c d)
 (^<<) :: Arrow a => (c > d) > a b c > a b d
 (<<^) :: Arrow a => a c d > (b > c) > a b d
 (>>^) :: Arrow a => a b c > (c > d) > a b d
 (^>>) :: Arrow a => (b > c) > a c d > a b d
 returnA :: Arrow a => a b b
 class Category a => Arrow (a :: Type > Type > Type) where
 newtype Kleisli (m :: Type > Type) a b = Kleisli {
 runKleisli :: a > m b
 class Arrow a => ArrowZero (a :: Type > Type > Type) where
 zeroArrow :: a b c
 class ArrowZero a => ArrowPlus (a :: Type > Type > Type) where
 (<+>) :: a b c > a b c > a b c
 class Arrow a => ArrowChoice (a :: Type > Type > Type) where
 class Arrow a => ArrowApply (a :: Type > Type > Type) where
 app :: a (a b c, b) c
 newtype ArrowMonad (a :: Type > Type > Type) b = ArrowMonad (a () b)
 class Arrow a => ArrowLoop (a :: Type > Type > Type) where
 loop :: a (b, d) (c, d) > a b c
 (>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b > cat b c > cat a c
 (<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c > cat a b > cat a c
 pauseOn :: Show a => (a > Bool) > String > MSF IO a a
 traceWhen :: (Monad m, Show a) => (a > Bool) > (String > m ()) > String > MSF m a a
 traceWith :: (Monad m, Show a) => (String > m ()) > String > MSF m a a
 unfold :: forall (m :: Type > Type) a b. Monad m => (a > (b, a)) > a > MSF m () b
 mealy :: forall (m :: Type > Type) a s b. Monad m => (a > s > (b, s)) > s > MSF m a b
 accumulateWith :: forall (m :: Type > Type) a s. Monad m => (a > s > s) > s > MSF m a s
 mappendFrom :: forall n (m :: Type > Type). (Monoid n, Monad m) => n > MSF m n n
 mappendS :: forall n (m :: Type > Type). (Monoid n, Monad m) => MSF m n n
 sumFrom :: forall v s (m :: Type > Type). (VectorSpace v s, Monad m) => v > MSF m v v
 sumS :: forall v s (m :: Type > Type). (VectorSpace v s, Monad m) => MSF m v v
 count :: forall n (m :: Type > Type) a. (Num n, Monad m) => MSF m a n
 fifo :: forall (m :: Type > Type) a. Monad m => MSF m [a] (Maybe a)
 next :: forall (m :: Type > Type) b a. Monad m => b > MSF m a b > MSF m a b
 iPost :: forall (m :: Type > Type) b a. Monad m => b > MSF m a b > MSF m a b
 iPre :: forall (m :: Type > Type) a. Monad m => a > MSF m a a
 withSideEffect_ :: Monad m => m b > MSF m a a
 withSideEffect :: Monad m => (a > m b) > MSF m a a
 mapMaybeS :: forall (m :: Type > Type) a b. Monad m => MSF m a b > MSF m (Maybe a) (Maybe b)
 type MStream (m :: Type > Type) a = MSF m () a
 type MSink (m :: Type > Type) a = MSF m a ()
 morphS :: (Monad m2, Monad m1) => (forall c. m1 c > m2 c) > MSF m1 a b > MSF m2 a b
 liftTransS :: forall (t :: (Type > Type) > Type > Type) (m :: Type > Type) a b. (MonadTrans t, Monad m, Monad (t m)) => MSF m a b > MSF (t m) a b
 (>>>^) :: forall (m1 :: Type > Type) (m2 :: Type > Type) a b c. MonadBase m1 m2 => MSF m2 a b > MSF m1 b c > MSF m2 a c
 (^>>>) :: forall (m1 :: Type > Type) (m2 :: Type > Type) a b c. MonadBase m1 m2 => MSF m1 a b > MSF m2 b c > MSF m2 a c
 liftBaseS :: forall (m2 :: Type > Type) (m1 :: Type > Type) a b. (Monad m2, MonadBase m1 m2) => MSF m1 a b > MSF m2 a b
 liftBaseM :: forall (m2 :: Type > Type) m1 a b. (Monad m2, MonadBase m1 m2) => (a > m1 b) > MSF m2 a b
 arrM :: Monad m => (a > m b) > MSF m a b
 constM :: Monad m => m b > MSF m a b
 embed :: Monad m => MSF m a b > [a] > m [b]
 feedback :: forall (m :: Type > Type) c a b. Monad m => c > MSF m (a, c) (b, c) > MSF m a b
 morphGS :: Monad m2 => (forall c. (a1 > m1 (b1, c)) > a2 > m2 (b2, c)) > MSF m1 a1 b1 > MSF m2 a2 b2
 data MSF (m :: Type > Type) a b
 class (Eq a, Floating a) => VectorSpace v a  v > a where
 zeroVector :: v
 (*^) :: a > v > v
 (^/) :: v > a > v
 (^+^) :: v > v > v
 (^^) :: v > v > v
 negateVector :: v > v
 dot :: v > v > a
 norm :: v > a
 normalize :: v > v
Documentation
Instances
Monad Event Source #  The type 
Functor Event Source #  The type 
Applicative Event Source #  The type 
Eq a => Eq (Event a) Source #  
Show a => Show (Event a) Source #  
(>) :: Monad m => b > SF m a b > SF m a b infixr 0 Source #
Initialization operator (cf. Lustre/Lucid Synchrone).
The output at time zero is the first argument, and from that point on it behaves like the signal function passed as second argument.
(:>) :: Monad m => b > SF m a b > SF m a b infixr 0 Source #
Output preinsert operator.
Insert a sample in the output, and from that point on, behave like the given sf.
(>) :: Monad m => a > SF m a b > SF m a b infixr 0 Source #
Input initialization operator.
The input at time zero is the first argument, and from that point on it behaves like the signal function passed as second argument.
now :: Monad m => b > SF m a (Event b) Source #
Event source with a single occurrence at time 0. The value of the event is given by the function argument.
afterEach :: Monad m => [(Time, b)] > SF m a (Event b) Source #
Event source with consecutive occurrences at the given intervals. Should more than one event be scheduled to occur in any sampling interval, only the first will in fact occur to avoid an event backlog.
afterEachCat :: Monad m => [(Time, b)] > SF m a (Event [b]) Source #
Event source with consecutive occurrences at the given intervals. Should more than one event be scheduled to occur in any sampling interval, the output list will contain all events produced during that interval.
eventToMaybe :: Event a > Maybe a Source #
boolToEvent :: Bool > Event () Source #
edgeTag :: Monad m => a > SF m Bool (Event a) Source #
Like edge
, but parameterized on the tag value.
From Yampa
maybeToEvent :: Maybe a > Event a Source #
notYet :: Monad m => SF m (Event a) (Event a) Source #
Suppression of initial (at local time 0) event.
takeEvents :: Monad m => Int > SF m (Event a) (Event a) Source #
Suppress all but the first n events.
noEventFst :: (Event a, b) > (Event c, b) Source #
Suppress any event in the first component of a pair.
noEventSnd :: (a, Event b) > (a, Event c) Source #
Suppress any event in the second component of a pair.
tagWith :: b > Event a > Event b Source #
Tags an (occurring) event with a value ("replacing" the old value). Same
as tag
with the arguments swapped.
Applicativebased definition: tagWith = (<$)
attach :: Event a > b > Event (a, b) Source #
Attaches an extra value to the value of an occurring event.
lMerge :: Event a > Event a > Event a Source #
Leftbiased event merge (always prefer left event, if present).
rMerge :: Event a > Event a > Event a Source #
Rightbiased event merge (always prefer right event, if present).
mapMerge :: (a > c) > (b > c) > (a > b > c) > Event a > Event b > Event c Source #
A generic event mergemap utility that maps event occurrences,
merging the results. The first three arguments are mapping functions,
the third of which will only be used when both events are present.
Therefore, mergeBy
= mapMerge
id
id
Applicativebased definition: mapMerge lf rf lrf le re = (f $ le * re)  (lf $ le)  (rf $ re)
mergeEvents :: [Event a] > Event a Source #
Merge a list of events; foremost event has priority.
Foldablebased definition: mergeEvents :: Foldable t => t (Event a) > Event a mergeEvents = asum
catEvents :: [Event a] > Event [a] Source #
Collect simultaneous event occurrences; no event if none.
Traverablebased definition: catEvents :: Foldable t => t (Event a) > Event (t a) carEvents e = if (null e) then NoEvent else (sequenceA e)
joinE :: Event a > Event b > Event (a, b) Source #
Join (conjunction) of two events. Only produces an event if both events exist.
Applicativebased definition: joinE = liftA2 (,)
filterE :: (a > Bool) > Event a > Event a Source #
Filter out events that don't satisfy some predicate.
gate :: Event a > Bool > Event a Source #
Enable/disable event occurences based on an external condition.
dpSwitchB :: (Monad m, Traversable col) => col (SF m a b) > SF m (a, col b) (Event c) > (col (SF m a b) > c > SF m a (col b)) > SF m a (col b) Source #
accumBy :: Monad m => (b > a > b) > b > SF m (Event a) (Event b) Source #
Accumulator parameterized by the accumulation function.
integralFrom :: (Monad m, VectorSpace a s) => a > SF m a a Source #
derivative :: (Monad m, VectorSpace a s) => SF m a a Source #
derivativeFrom :: (Monad m, VectorSpace a s) => a > SF m a a Source #
:: MonadRandom m  
=> Time  The time q after which the event should be produced on average 
> b  Value to produce at time of event 
> SF m a (Event b) 
reactimate :: Monad m => m a > (Bool > m (DTime, Maybe a)) > (Bool > b > m Bool) > SF Identity a b > m () Source #
evalAtZero :: SF Identity a b > a > (b, SF Identity a b) Source #
Evaluate an SF, and return an output and an initialized SF.
WARN: Do not use this function for standard simulation. This function is intended only for debugging/testing. Apart from being potentially slower and consuming more memory, it also breaks the FRP abstraction by making samples discrete and step based.
evalAt :: SF Identity a b > DTime > a > (b, SF Identity a b) Source #
Evaluate an initialized SF, and return an output and a continuation.
WARN: Do not use this function for standard simulation. This function is intended only for debugging/testing. Apart from being potentially slower and consuming more memory, it also breaks the FRP abstraction by making samples discrete and step based.
evalFuture :: SF Identity a b > a > DTime > (b, SF Identity a b) Source #
Given a signal function and time delta, it moves the signal function into the future, returning a new uninitialized SF and the initial output.
While the input sample refers to the present, the time delta refers to the future (or to the time between the current sample and the next sample).
WARN: Do not use this function for standard simulation. This function is intended only for debugging/testing. Apart from being potentially slower and consuming more memory, it also breaks the FRP abstraction by making samples discrete and step based.
replaceOnce :: Monad m => a > SF m a a Source #
leftApp :: ArrowApply a => a b c > a (Either b d) (Either c d) #
Any instance of ArrowApply
can be made into an instance of
ArrowChoice
by defining left
= leftApp
.
(^<<) :: Arrow a => (c > d) > a b c > a b d infixr 1 #
Postcomposition with a pure function (righttoleft variant).
(<<^) :: Arrow a => a c d > (b > c) > a b d infixr 1 #
Precomposition with a pure function (righttoleft variant).
class Category a => Arrow (a :: Type > Type > Type) where #
The basic arrow class.
Instances should satisfy the following laws:
arr
id =id
arr
(f >>> g) =arr
f >>>arr
gfirst
(arr
f) =arr
(first
f)first
(f >>> g) =first
f >>>first
gfirst
f >>>arr
fst
=arr
fst
>>> ffirst
f >>>arr
(id
*** g) =arr
(id
*** g) >>>first
ffirst
(first
f) >>>arr
assoc =arr
assoc >>>first
f
where
assoc ((a,b),c) = (a,(b,c))
The other combinators have sensible default definitions, which may be overridden for efficiency.
Lift a function to an arrow.
first :: a b c > a (b, d) (c, d) #
Send the first component of the input through the argument arrow, and copy the rest unchanged to the output.
second :: a b c > a (d, b) (d, c) #
A mirror image of first
.
The default definition may be overridden with a more efficient version if desired.
(***) :: a b c > a b' c' > a (b, b') (c, c') infixr 3 #
Split the input between the two argument arrows and combine their output. Note that this is in general not a functor.
The default definition may be overridden with a more efficient version if desired.
(&&&) :: a b c > a b c' > a b (c, c') infixr 3 #
Fanout: send the input to both argument arrows and combine their output.
The default definition may be overridden with a more efficient version if desired.
newtype Kleisli (m :: Type > Type) a b #
Kleisli arrows of a monad.
Kleisli  

Instances
Monad m => Arrow (Kleisli m)  Since: base2.1 
MonadPlus m => ArrowZero (Kleisli m)  Since: base2.1 
Defined in Control.Arrow  
MonadPlus m => ArrowPlus (Kleisli m)  Since: base2.1 
Monad m => ArrowChoice (Kleisli m)  Since: base2.1 
Defined in Control.Arrow  
Monad m => ArrowApply (Kleisli m)  Since: base2.1 
Defined in Control.Arrow  
MonadFix m => ArrowLoop (Kleisli m)  Beware that for many monads (those for which the Since: base2.1 
Defined in Control.Arrow  
Monad m => Category (Kleisli m :: Type > Type > Type)  Since: base3.0 
Generic1 (Kleisli m a :: Type > Type)  Since: base4.14.0.0 
Monad m => Monad (Kleisli m a)  Since: base4.14.0.0 
Functor m => Functor (Kleisli m a)  Since: base4.14.0.0 
Applicative m => Applicative (Kleisli m a)  Since: base4.14.0.0 
Defined in Control.Arrow  
MonadPlus m => MonadPlus (Kleisli m a)  Since: base4.14.0.0 
Alternative m => Alternative (Kleisli m a)  Since: base4.14.0.0 
Generic (Kleisli m a b)  Since: base4.14.0.0 
type Rep1 (Kleisli m a :: Type > Type)  
type Rep (Kleisli m a b)  
Defined in Control.Arrow 
class Arrow a => ArrowChoice (a :: Type > Type > Type) where #
Choice, for arrows that support it. This class underlies the
if
and case
constructs in arrow notation.
Instances should satisfy the following laws:
left
(arr
f) =arr
(left
f)left
(f >>> g) =left
f >>>left
gf >>>
arr
Left
=arr
Left
>>>left
fleft
f >>>arr
(id
+++ g) =arr
(id
+++ g) >>>left
fleft
(left
f) >>>arr
assocsum =arr
assocsum >>>left
f
where
assocsum (Left (Left x)) = Left x assocsum (Left (Right y)) = Right (Left y) assocsum (Right z) = Right (Right z)
The other combinators have sensible default definitions, which may be overridden for efficiency.
left :: a b c > a (Either b d) (Either c d) #
Feed marked inputs through the argument arrow, passing the rest through unchanged to the output.
right :: a b c > a (Either d b) (Either d c) #
A mirror image of left
.
The default definition may be overridden with a more efficient version if desired.
(+++) :: a b c > a b' c' > a (Either b b') (Either c c') infixr 2 #
Split the input between the two argument arrows, retagging and merging their outputs. Note that this is in general not a functor.
The default definition may be overridden with a more efficient version if desired.
() :: a b d > a c d > a (Either b c) d infixr 2 #
Fanin: Split the input between the two argument arrows and merge their outputs.
The default definition may be overridden with a more efficient version if desired.
Instances
Monad m => ArrowChoice (Kleisli m)  Since: base2.1 
Defined in Control.Arrow  
ArrowChoice ((>) :: Type > Type > Type)  Since: base2.1 
class Arrow a => ArrowApply (a :: Type > Type > Type) where #
Some arrows allow application of arrow inputs to other inputs. Instances should satisfy the following laws:
first
(arr
(\x >arr
(\y > (x,y)))) >>>app
=id
first
(arr
(g >>>)) >>>app
=second
g >>>app
first
(arr
(>>> h)) >>>app
=app
>>> h
Such arrows are equivalent to monads (see ArrowMonad
).
Instances
Monad m => ArrowApply (Kleisli m)  Since: base2.1 
Defined in Control.Arrow  
ArrowApply ((>) :: Type > Type > Type)  Since: base2.1 
Defined in Control.Arrow 
newtype ArrowMonad (a :: Type > Type > Type) b #
The ArrowApply
class is equivalent to Monad
: any monad gives rise
to a Kleisli
arrow, and any instance of ArrowApply
defines a monad.
ArrowMonad (a () b) 
Instances
class Arrow a => ArrowLoop (a :: Type > Type > Type) where #
The loop
operator expresses computations in which an output value
is fed back as input, although the computation occurs only once.
It underlies the rec
value recursion construct in arrow notation.
loop
should satisfy the following laws:
 extension
loop
(arr
f) =arr
(\ b >fst
(fix
(\ (c,d) > f (b,d)))) left tightening
loop
(first
h >>> f) = h >>>loop
f right tightening
loop
(f >>>first
h) =loop
f >>> h sliding
loop
(f >>>arr
(id
*** k)) =loop
(arr
(id
*** k) >>> f) vanishing
loop
(loop
f) =loop
(arr
unassoc >>> f >>>arr
assoc) superposing
second
(loop
f) =loop
(arr
assoc >>>second
f >>>arr
unassoc)
where
assoc ((a,b),c) = (a,(b,c)) unassoc (a,(b,c)) = ((a,b),c)
Instances
MonadFix m => ArrowLoop (Kleisli m)  Beware that for many monads (those for which the Since: base2.1 
Defined in Control.Arrow  
ArrowLoop ((>) :: Type > Type > Type)  Since: base2.1 
Defined in Control.Arrow 
(>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b > cat b c > cat a c infixr 1 #
Lefttoright composition
(<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c > cat a b > cat a c infixr 1 #
Righttoleft composition
pauseOn :: Show a => (a > Bool) > String > MSF IO a a #
Outputs every input sample, with a given message prefix, when a condition is met, and waits for some input / enter to continue.
traceWhen :: (Monad m, Show a) => (a > Bool) > (String > m ()) > String > MSF m a a #
Outputs every input sample, with a given message prefix, using an auxiliary printing function, when a condition is met.
traceWith :: (Monad m, Show a) => (String > m ()) > String > MSF m a a #
Outputs every input sample, with a given message prefix, using an auxiliary printing function.
unfold :: forall (m :: Type > Type) a b. Monad m => (a > (b, a)) > a > MSF m () b #
Generate outputs using a stepwise generation function and an initial value.
mealy :: forall (m :: Type > Type) a s b. Monad m => (a > s > (b, s)) > s > MSF m a b #
Applies a transfer function to the input and an accumulator, returning the updated accumulator and output.
accumulateWith :: forall (m :: Type > Type) a s. Monad m => (a > s > s) > s > MSF m a s #
Applies a function to the input and an accumulator,
outputting the updated accumulator.
Equal to f s0 > feedback s0 $ arr (uncurry f >>> dup)
.
mappendFrom :: forall n (m :: Type > Type). (Monoid n, Monad m) => n > MSF m n n #
Accumulate the inputs, starting from an initial monoid value.
mappendS :: forall n (m :: Type > Type). (Monoid n, Monad m) => MSF m n n #
Accumulate the inputs, starting from mempty
.
sumFrom :: forall v s (m :: Type > Type). (VectorSpace v s, Monad m) => v > MSF m v v #
Sums the inputs, starting from an initial vector.
sumS :: forall v s (m :: Type > Type). (VectorSpace v s, Monad m) => MSF m v v #
Sums the inputs, starting from zero.
count :: forall n (m :: Type > Type) a. (Num n, Monad m) => MSF m a n #
Count the number of simulation steps. Produces 1, 2, 3,...
fifo :: forall (m :: Type > Type) a. Monad m => MSF m [a] (Maybe a) #
Buffers and returns the elements in FIFO order,
returning Nothing
whenever the buffer is empty.
next :: forall (m :: Type > Type) b a. Monad m => b > MSF m a b > MSF m a b #
Preprends a fixed output to an MSF
, shifting the output.
iPost :: forall (m :: Type > Type) b a. Monad m => b > MSF m a b > MSF m a b #
Preprends a fixed output to an MSF
. The first input is completely
ignored.
Delay a signal by one sample.
withSideEffect_ :: Monad m => m b > MSF m a a #
Produces an additional side effect and passes the input unchanged.
withSideEffect :: Monad m => (a > m b) > MSF m a a #
Applies a function to produce an additional side effect and passes the input unchanged.
type MStream (m :: Type > Type) a = MSF m () a #
A stream is an MSF
that produces outputs, while ignoring the input.
It can obtain the values from a monadic context.
type MSink (m :: Type > Type) a = MSF m a () #
A sink is an MSF
that consumes inputs, while producing no output.
It can consume the values with side effects.
morphS :: (Monad m2, Monad m1) => (forall c. m1 c > m2 c) > MSF m1 a b > MSF m2 a b #
Apply transmonadic actions (in an arbitrary way).
This is just a convenience function when you have a function to move across
monads, because the signature of morphGS
is a bit complex.
liftTransS :: forall (t :: (Type > Type) > Type > Type) (m :: Type > Type) a b. (MonadTrans t, Monad m, Monad (t m)) => MSF m a b > MSF (t m) a b #
Lift inner monadic actions in monad stacks.
(>>>^) :: forall (m1 :: Type > Type) (m2 :: Type > Type) a b c. MonadBase m1 m2 => MSF m2 a b > MSF m1 b c > MSF m2 a c #
Lift the second MSF
into the monad of the first.
(^>>>) :: forall (m1 :: Type > Type) (m2 :: Type > Type) a b c. MonadBase m1 m2 => MSF m1 a b > MSF m2 b c > MSF m2 a c #
Lift the first MSF
into the monad of the second.
liftBaseS :: forall (m2 :: Type > Type) (m1 :: Type > Type) a b. (Monad m2, MonadBase m1 m2) => MSF m1 a b > MSF m2 a b #
Lift innermost monadic actions in monad stack (generalisation of
liftIO
).
liftBaseM :: forall (m2 :: Type > Type) m1 a b. (Monad m2, MonadBase m1 m2) => (a > m1 b) > MSF m2 a b #
Monadic lifting from one monad into another
embed :: Monad m => MSF m a b > [a] > m [b] #
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 arrM
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"
feedback :: forall (m :: Type > Type) c a b. Monad m => c > MSF m (a, c) (b, c) > MSF m a b #
Wellformed looped connection of an output component as a future input.
:: Monad m2  
=> (forall c. (a1 > m1 (b1, c)) > a2 > m2 (b2, c))  The natural transformation. 
> MSF m1 a1 b1  
> MSF m2 a2 b2 
Generic lifting of a morphism to the level of MSF
s.
Natural transformation to the level of MSF
s.
Mathematical background: The type a > m (b, c)
is a functor in c
,
and MSF m a b
is its greatest fixpoint, i.e. it is isomorphic to the type
a > m (b, MSF m a b)
, by definition.
The types m
, a
and b
are parameters of the functor.
Taking a fixpoint is functorial itself, meaning that a morphism
(a natural transformation) of two such functors gives a morphism
(an ordinary function) of their fixpoints.
This is in a sense the most general "abstract" lifting function,
i.e. the most general one that only changes input, output and side effect
types, and doesn't influence control flow.
Other handling functions like exception handling or ListT
broadcasting
necessarily change control flow.
data MSF (m :: Type > Type) a b #
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.
class (Eq a, Floating a) => VectorSpace v a  v > a where #
Vector space type relation.
A vector space is a set (type) closed under addition and multiplication by
a scalar. The type of the scalar is the field of the vector space, and
it is said that v
is a vector space over a
.
The encoding uses a type class VectorSpace v a
, where v
represents
the type of the vectors and a
represents the types of the scalars.
zeroVector, (*^), (^+^), dot
zeroVector :: v #
Vector with no magnitude (unit for addition).
(*^) :: a > v > v infixr 9 #
Multiplication by a scalar.
(^/) :: v > a > v infixl 9 #
Division by a scalar.
(^+^) :: v > v > v infixl 6 #
Vector addition
(^^) :: v > v > v infixl 6 #
Vector subtraction
negateVector :: v > v #
Vector negation. Addition with a negated vector should be same as subtraction.
Dot product (also known as scalar or inner product).
For two vectors, mathematically represented as a = a1,a2,...,an
and b
= b1,b2,...,bn
, the dot product is a . b = a1*b1 + a2*b2 + ... +
an*bn
.
Some properties are derived from this. The dot product of a vector with
itself is the square of its magnitude (norm
), and the dot product of
two orthogonal vectors is zero.
Vector's norm (also known as magnitude).
For a vector represented mathematically as a = a1,a2,...,an
, the norm
is the square root of a1^2 + a2^2 + ... + an^2
.
Return a vector with the same origin and orientation (angle), but such that the norm is one (the unit for multiplication by a scalar).
Instances
VectorSpace Double Double  
Defined in Data.VectorSpace  
VectorSpace Float Float  
Defined in Data.VectorSpace  
(Eq a, Floating a) => VectorSpace (a, a) a  Vector space instance for pairs of 
Defined in Data.VectorSpace  
(Eq a, Floating a) => VectorSpace (a, a, a) a  Vector space instance for triplets of 
Defined in Data.VectorSpace  
(Eq a, Floating a) => VectorSpace (a, a, a, a) a  Vector space instance for tuples with four 
Defined in Data.VectorSpace zeroVector :: (a, a, a, a) # (*^) :: a > (a, a, a, a) > (a, a, a, a) # (^/) :: (a, a, a, a) > a > (a, a, a, a) # (^+^) :: (a, a, a, a) > (a, a, a, a) > (a, a, a, a) # (^^) :: (a, a, a, a) > (a, a, a, a) > (a, a, a, a) # negateVector :: (a, a, a, a) > (a, a, a, a) #  
(Eq a, Floating a) => VectorSpace (a, a, a, a, a) a  Vector space instance for tuples with five 
Defined in Data.VectorSpace zeroVector :: (a, a, a, a, a) # (*^) :: a > (a, a, a, a, a) > (a, a, a, a, a) # (^/) :: (a, a, a, a, a) > a > (a, a, a, a, a) # (^+^) :: (a, a, a, a, a) > (a, a, a, a, a) > (a, a, a, a, a) # (^^) :: (a, a, a, a, a) > (a, a, a, a, a) > (a, a, a, a, a) # negateVector :: (a, a, a, a, a) > (a, a, a, a, a) # dot :: (a, a, a, a, a) > (a, a, a, a, a) > a # 