Safe Haskell	None
Language	Haskell2010

FRP.Rhine.ClSF.Core

Description

The core functionality of clocked signal functions, supplying the type of clocked signal functions itself (ClSF), behaviours (clock-independent/polymorphic signal functions), and basic constructions of ClSFs that may use awareness of time as an effect.

Synopsis

type BehaviorF m time a b = BehaviourF m time a b
type BehaviourF m time a b = forall cl. time ~ Time cl => ClSF m cl a b
type Behavior m time a = Behaviour m time a
type Behaviour m time a = forall cl. time ~ Time cl => ClSignal m cl a
type ClSignal m cl a = forall arbitrary. ClSF m cl arbitrary a
type ClSF m cl a b = MSF (ReaderT (TimeInfo cl) m) a b
hoistClSF :: (Monad m1, Monad m2) => (forall c. m1 c -> m2 c) -> ClSF m1 cl a b -> ClSF m2 cl a b
hoistClSFAndClock :: (Monad m1, Monad m2) => (forall c. m1 c -> m2 c) -> ClSF m1 cl a b -> ClSF m2 (HoistClock m1 m2 cl) a b
liftClSF :: (Monad m, MonadTrans t, Monad (t m)) => ClSF m cl a b -> ClSF (t m) cl a b
liftClSFAndClock :: (Monad m, MonadTrans t, Monad (t m)) => ClSF m cl a b -> ClSF (t m) (LiftClock m t cl) a b
timeless :: Monad m => MSF m a b -> ClSF m cl a b
arrMCl :: Monad m => (a -> m b) -> ClSF m cl a b
constMCl :: Monad m => m b -> ClSF m cl a b
mapMaybe :: Monad m => ClSF m cl a b -> ClSF m cl (Maybe a) (Maybe b)
module Control.Arrow
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
- arr :: (b -> c) -> a b c
- first :: a b c -> a (b, d) (c, d)
- second :: a b c -> a (d, b) (d, c)
- (***) :: a b c -> a b' c' -> a (b, b') (c, c')
- (&&&) :: a b c -> a b c' -> a b (c, c')
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
- left :: a b c -> a (Either b d) (Either c d)
- right :: a b c -> a (Either d b) (Either d c)
- (+++) :: a b c -> a b' c' -> a (Either b b') (Either c c')
- (|||) :: a b d -> a c d -> a (Either b c) d
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
(>>>) :: Category cat => cat a b -> cat b c -> cat a c
(<<<) :: 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
trace :: Show a => String -> MSF IO a a
repeatedly :: Monad m => (a -> a) -> a -> MSF m () a
unfold :: Monad m => (a -> (b, a)) -> a -> MSF m () b
mealy :: Monad m => (a -> s -> (b, s)) -> s -> MSF m a b
accumulateWith :: Monad m => (a -> s -> s) -> s -> MSF m a s
mappendFrom :: (Monoid n, Monad m) => n -> MSF m n n
mappendS :: (Monoid n, Monad m) => MSF m n n
sumFrom :: (RModule v, Monad m) => v -> MSF m v v
sumS :: (RModule v, Monad m) => MSF m v v
count :: (Num n, Monad m) => MSF m a n
fifo :: Monad m => MSF m [a] (Maybe a)
next :: Monad m => b -> MSF m a b -> MSF m a b
iPost :: Monad m => b -> MSF m a b -> MSF m a b
iPre :: 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 :: 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 :: (MonadTrans t, Monad m, Monad (t m)) => MSF m a b -> MSF (t m) a b
liftBaseS :: (Monad m2, MonadBase m1 m2) => MSF m1 a b -> MSF m2 a b
liftBaseM :: (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
reactimate :: Monad m => MSF m () () -> m ()
embed :: Monad m => MSF m a b -> [a] -> m [b]
feedback :: 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
data UTCTime
newtype NumTimeDomain a = NumTimeDomain {
- fromNumTimeDomain :: a
}
class TimeDomain time where
- type Diff time
- diffTime :: time -> time -> Diff time
type IOClock m cl = HoistClock IO m cl
type LiftClock m t cl = HoistClock m (t m) cl
data HoistClock m1 m2 cl = HoistClock {
- unhoistedClock :: cl
- monadMorphism :: forall a. m1 a -> m2 a
}
data RescaledClockS m cl time tag = RescaledClockS {
- unscaledClockS :: cl
- rescaleS :: RescalingSInit m cl time tag
}
data RescaledClockM m cl time = RescaledClockM {
- unscaledClockM :: cl
- rescaleM :: RescalingM m cl time
}
data RescaledClock cl time = RescaledClock {
- unscaledClock :: cl
- rescale :: Rescaling cl time
}
type RescalingSInit m cl time tag = Time cl -> m (RescalingS m cl time tag, time)
type RescalingS m cl time tag = MSF m (Time cl, Tag cl) (time, tag)
type RescalingM m cl time = Time cl -> m time
type Rescaling cl time = Time cl -> time
data TimeInfo cl = TimeInfo {
- sinceLast :: Diff (Time cl)
- sinceInit :: Diff (Time cl)
- absolute :: Time cl
- tag :: Tag cl
}
class TimeDomain (Time cl) => Clock m cl where
- type Time cl
- type Tag cl
- initClock :: cl -> RunningClockInit m (Time cl) (Tag cl)
type RunningClockInit m time tag = m (RunningClock m time tag, time)
type RunningClock m time tag = MSF m () (time, tag)
retag :: Time cl1 ~ Time cl2 => (Tag cl1 -> Tag cl2) -> TimeInfo cl1 -> TimeInfo cl2
genTimeInfo :: (Monad m, Clock m cl) => cl -> Time cl -> MSF m (Time cl, Tag cl) (TimeInfo cl)
rescaleMToSInit :: Monad m => (time1 -> m time2) -> time1 -> m (MSF m (time1, tag) (time2, tag), time2)
rescaledClockToM :: Monad m => RescaledClock cl time -> RescaledClockM m cl time
rescaledClockMToS :: Monad m => RescaledClockM m cl time -> RescaledClockS m cl time (Tag cl)
rescaledClockToS :: Monad m => RescaledClock cl time -> RescaledClockS m cl time (Tag cl)
liftClock :: (Monad m, MonadTrans t) => cl -> LiftClock m t cl
ioClock :: MonadIO m => cl -> IOClock m cl

Documentation

type BehaviorF m time a b = BehaviourF m time a b Source #

Compatibility to U.S. american spelling.

type BehaviourF m time a b = forall cl. time ~ Time cl => ClSF m cl a b Source #

A (side-effectful) behaviour function is a time-aware synchronous stream function that doesn't depend on a particular clock. time denotes the TimeDomain.

type Behavior m time a = Behaviour m time a Source #

Compatibility to U.S. american spelling.

type Behaviour m time a = forall cl. time ~ Time cl => ClSignal m cl a Source #

A (side-effectful) behaviour is a time-aware stream that doesn't depend on a particular clock. time denotes the TimeDomain.

type ClSignal m cl a = forall arbitrary. ClSF m cl arbitrary a Source #

A clocked signal is a ClSF with no input required. It produces its output on its own.

type ClSF m cl a b = MSF (ReaderT (TimeInfo cl) m) a b Source #

A (synchronous, clocked) monadic stream function with the additional side effect of being time-aware, that is, reading the current TimeInfo of the clock cl.

hoistClSF :: (Monad m1, Monad m2) => (forall c. m1 c -> m2 c) -> ClSF m1 cl a b -> ClSF m2 cl a b Source #

Hoist a ClSF along a monad morphism.

hoistClSFAndClock :: (Monad m1, Monad m2) => (forall c. m1 c -> m2 c) -> ClSF m1 cl a b -> ClSF m2 (HoistClock m1 m2 cl) a b Source #

Hoist a ClSF and its clock along a monad morphism.

liftClSF :: (Monad m, MonadTrans t, Monad (t m)) => ClSF m cl a b -> ClSF (t m) cl a b Source #

Lift a ClSF into a monad transformer.

liftClSFAndClock :: (Monad m, MonadTrans t, Monad (t m)) => ClSF m cl a b -> ClSF (t m) (LiftClock m t cl) a b Source #

Lift a ClSF and its clock into a monad transformer.

timeless :: Monad m => MSF m a b -> ClSF m cl a b Source #

A monadic stream function without dependency on time is a ClSF for any clock.

arrMCl :: Monad m => (a -> m b) -> ClSF m cl a b Source #

Utility to lift Kleisli arrows directly to ClSFs.

constMCl :: Monad m => m b -> ClSF m cl a b Source #

Version without input.

mapMaybe :: Monad m => ClSF m cl a b -> ClSF m cl (Maybe a) (Maybe b) Source #

Call a ClSF every time the input is 'Just a'.

Caution: This will not change the time differences since the last tick. For example, while integrate 1 is approximately the same as timeInfoOf sinceInit, mapMaybe $ integrate 1 is very different from mapMaybe $ timeInfoOf sinceInit. The former only integrates when the input is Just 1, whereas the latter always returns the correct time since initialisation.

module Control.Arrow

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 (right-to-left variant).

(<<^) :: Arrow a => a c d -> (b -> c) -> a b d infixr 1 #

Precomposition with a pure function (right-to-left variant).

(>>^) :: Arrow a => a b c -> (c -> d) -> a b d infixr 1 #

Postcomposition with a pure function.

(^>>) :: Arrow a => (b -> c) -> a c d -> a b d infixr 1 #

Precomposition with a pure function.

returnA :: Arrow a => a b b #

The identity arrow, which plays the role of return in arrow notation.

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 g
```
```
first (arr f) = arr (first f)
```
```
first (f >>> g) = first f >>> first g
```
```
first f >>> arr fst = arr fst >>> f
```

first f >>> arr (id *** g) = arr (id *** g) >>> first f

first (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.

Minimal complete definition

arr, (first | (***))

Methods

arr :: (b -> c) -> a b c #

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.

Instances

Monad m => Arrow (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods arr :: (b -> c) -> Kleisli m b c # first :: Kleisli m b c -> Kleisli m (b, d) (c, d) # second :: Kleisli m b c -> Kleisli m (d, b) (d, c) # (***) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (b, b') (c, c') # (&&&) :: Kleisli m b c -> Kleisli m b c' -> Kleisli m b (c, c') #
Arrow ((->) :: Type -> Type -> Type)	Since: base-2.1
Instance details Defined in Control.Arrow Methods arr :: (b -> c) -> b -> c # first :: (b -> c) -> (b, d) -> (c, d) # second :: (b -> c) -> (d, b) -> (d, c) # (***) :: (b -> c) -> (b' -> c') -> (b, b') -> (c, c') # (&&&) :: (b -> c) -> (b -> c') -> b -> (c, c') #
(Applicative f, Arrow p) => Arrow (Tannen f p)
Instance details Defined in Data.Bifunctor.Tannen Methods arr :: (b -> c) -> Tannen f p b c # first :: Tannen f p b c -> Tannen f p (b, d) (c, d) # second :: Tannen f p b c -> Tannen f p (d, b) (d, c) # (***) :: Tannen f p b c -> Tannen f p b' c' -> Tannen f p (b, b') (c, c') # (&&&) :: Tannen f p b c -> Tannen f p b c' -> Tannen f p b (c, c') #

newtype Kleisli (m :: Type -> Type) a b #

Kleisli arrows of a monad.

Constructors

Kleisli
Fields runKleisli :: a -> m b

Instances

Monad m => Arrow (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods arr :: (b -> c) -> Kleisli m b c # first :: Kleisli m b c -> Kleisli m (b, d) (c, d) # second :: Kleisli m b c -> Kleisli m (d, b) (d, c) # (***) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (b, b') (c, c') # (&&&) :: Kleisli m b c -> Kleisli m b c' -> Kleisli m b (c, c') #
MonadPlus m => ArrowZero (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods zeroArrow :: Kleisli m b c #
MonadPlus m => ArrowPlus (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods (<+>) :: Kleisli m b c -> Kleisli m b c -> Kleisli m b c #
Monad m => ArrowChoice (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods left :: Kleisli m b c -> Kleisli m (Either b d) (Either c d) # right :: Kleisli m b c -> Kleisli m (Either d b) (Either d c) # (+++) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (Either b b') (Either c c') # (\|\|\|) :: Kleisli m b d -> Kleisli m c d -> Kleisli m (Either b c) d #
Monad m => ArrowApply (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods app :: Kleisli m (Kleisli m b c, b) c #
MonadFix m => ArrowLoop (Kleisli m)	Beware that for many monads (those for which the `>>=` operation is strict) this instance will not satisfy the right-tightening law required by the `ArrowLoop` class. Since: base-2.1
Instance details Defined in Control.Arrow Methods loop :: Kleisli m (b, d) (c, d) -> Kleisli m b c #
Monad m => Category (Kleisli m :: Type -> Type -> Type)	Since: base-3.0
Instance details Defined in Control.Arrow Methods id :: Kleisli m a a # (.) :: Kleisli m b c -> Kleisli m a b -> Kleisli m a c #

class Arrow a => ArrowZero (a :: Type -> Type -> Type) where #

Methods

zeroArrow :: a b c #

Instances

MonadPlus m => ArrowZero (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods zeroArrow :: Kleisli m b c #
(Applicative f, ArrowZero p) => ArrowZero (Tannen f p)
Instance details Defined in Data.Bifunctor.Tannen Methods zeroArrow :: Tannen f p b c #

class ArrowZero a => ArrowPlus (a :: Type -> Type -> Type) where #

A monoid on arrows.

Methods

(<+>) :: a b c -> a b c -> a b c infixr 5 #

An associative operation with identity zeroArrow.

Instances

MonadPlus m => ArrowPlus (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods (<+>) :: Kleisli m b c -> Kleisli m b c -> Kleisli m b c #
(Applicative f, ArrowPlus p) => ArrowPlus (Tannen f p)
Instance details Defined in Data.Bifunctor.Tannen Methods (<+>) :: Tannen f p b c -> Tannen f p b c -> Tannen f p b c #

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 g
```
```
f >>> arr Left = arr Left >>> left f
```

left f >>> arr (id +++ g) = arr (id +++ g) >>> left f

left (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.

Minimal complete definition

(left | (+++))

Methods

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: base-2.1
Instance details Defined in Control.Arrow Methods left :: Kleisli m b c -> Kleisli m (Either b d) (Either c d) # right :: Kleisli m b c -> Kleisli m (Either d b) (Either d c) # (+++) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (Either b b') (Either c c') # (\|\|\|) :: Kleisli m b d -> Kleisli m c d -> Kleisli m (Either b c) d #
ArrowChoice ((->) :: Type -> Type -> Type)	Since: base-2.1
Instance details Defined in Control.Arrow Methods left :: (b -> c) -> Either b d -> Either c d # right :: (b -> c) -> Either d b -> Either d c # (+++) :: (b -> c) -> (b' -> c') -> Either b b' -> Either c c' # (\|\|\|) :: (b -> d) -> (c -> d) -> Either b c -> d #
(Applicative f, ArrowChoice p) => ArrowChoice (Tannen f p)
Instance details Defined in Data.Bifunctor.Tannen Methods left :: Tannen f p b c -> Tannen f p (Either b d) (Either c d) # right :: Tannen f p b c -> Tannen f p (Either d b) (Either d c) # (+++) :: Tannen f p b c -> Tannen f p b' c' -> Tannen f p (Either b b') (Either c c') # (\|\|\|) :: Tannen f p b d -> Tannen f p c d -> Tannen f p (Either b c) d #

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).

Methods

app :: a (a b c, b) c #

Instances

Monad m => ArrowApply (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods app :: Kleisli m (Kleisli m b c, b) c #
ArrowApply ((->) :: Type -> Type -> Type)	Since: base-2.1
Instance details Defined in Control.Arrow Methods app :: (b -> c, b) -> c #

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.

Constructors

ArrowMonad (a () b)

Instances

ArrowApply a => Monad (ArrowMonad a)	Since: base-2.1
Instance details Defined in Control.Arrow Methods (>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b # (>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # return :: a0 -> ArrowMonad a a0 # fail :: String -> ArrowMonad a a0 #
Arrow a => Functor (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 #
Arrow a => Applicative (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods mzero :: ArrowMonad a a0 # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 #
ArrowPlus a => Alternative (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods empty :: ArrowMonad a a0 # (<\|>) :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 # some :: ArrowMonad a a0 -> ArrowMonad a [a0] # many :: ArrowMonad a a0 -> ArrowMonad a [a0] #

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)

Methods

loop :: a (b, d) (c, d) -> a b c #

Instances

MonadFix m => ArrowLoop (Kleisli m)	Beware that for many monads (those for which the `>>=` operation is strict) this instance will not satisfy the right-tightening law required by the `ArrowLoop` class. Since: base-2.1
Instance details Defined in Control.Arrow Methods loop :: Kleisli m (b, d) (c, d) -> Kleisli m b c #
ArrowLoop ((->) :: Type -> Type -> Type)	Since: base-2.1
Instance details Defined in Control.Arrow Methods loop :: ((b, d) -> (c, d)) -> b -> c #
(Applicative f, ArrowLoop p) => ArrowLoop (Tannen f p)
Instance details Defined in Data.Bifunctor.Tannen Methods loop :: Tannen f p (b, d) (c, d) -> Tannen f p b c #

(>>>) :: Category cat => cat a b -> cat b c -> cat a c infixr 1 #

Left-to-right composition

(<<<) :: Category cat => cat b c -> cat a b -> cat a c infixr 1 #

Right-to-left 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.

trace :: Show a => String -> MSF IO a a #

Outputs every input sample, with a given message prefix.

repeatedly :: Monad m => (a -> a) -> a -> MSF m () a #

Generate outputs using a step-wise generation function and an initial value. Version of unfold in which the output and the new accumulator are the same. Should be equal to f a -> unfold (f >>> dup) a.

unfold :: Monad m => (a -> (b, a)) -> a -> MSF m () b #

Generate outputs using a step-wise generation function and an initial value.

mealy :: 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 :: 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 :: (Monoid n, Monad m) => n -> MSF m n n #

Accumulate the inputs, starting from an initial monoid value.

mappendS :: (Monoid n, Monad m) => MSF m n n #

Accumulate the inputs, starting from mempty.

sumFrom :: (RModule v, Monad m) => v -> MSF m v v #

Sums the inputs, starting from an initial vector.

sumS :: (RModule v, Monad m) => MSF m v v #

Sums the inputs, starting from zero.

count :: (Num n, Monad m) => MSF m a n #

Count the number of simulation steps. Produces 1, 2, 3,...

fifo :: Monad m => MSF m [a] (Maybe a) #

Buffers and returns the elements in FIFO order, returning Nothing whenever the buffer is empty.

next :: Monad m => b -> MSF m a b -> MSF m a b #

Preprends a fixed output to an MSF, shifting the output.

iPost :: Monad m => b -> MSF m a b -> MSF m a b #

Preprends a fixed output to an MSF. The first input is completely ignored.

iPre #

Arguments

:: Monad m
=> a	First output
-> MSF m a a

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.

mapMaybeS :: Monad m => MSF m a b -> MSF m (Maybe a) (Maybe b) #

Apply an MSF to every input. Freezes temporarily if the input is Nothing, and continues as soon as a Just is received.

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 trans-monadic 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 :: (MonadTrans t, Monad m, Monad (t m)) => MSF m a b -> MSF (t m) a b #

Lift inner monadic actions in monad stacks.

liftBaseS :: (Monad m2, MonadBase m1 m2) => MSF m1 a b -> MSF m2 a b #

Lift innermost monadic actions in monad stack (generalisation of liftIO).

liftBaseM :: (Monad m2, MonadBase m1 m2) => (a -> m1 b) -> MSF m2 a b #

Monadic lifting from one monad into another

arrM :: Monad m => (a -> m b) -> MSF m a b #

Apply a monadic transformation to every element of the input stream.

Generalisation of arr from Arrow to monadic functions.

constM :: Monad m => m b -> MSF m a b #

Lifts a monadic computation into a Stream.

reactimate :: Monad m => MSF m () () -> m () #

Run an MSF indefinitely passing a unit-carrying input stream.

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 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"

feedback :: Monad m => c -> MSF m (a, c) (b, c) -> MSF m a b #

Well-formed looped connection of an output component as a future input.

morphGS #

Arguments

:: Monad m2
=> (forall c. (a1 -> m1 (b1, c)) -> a2 -> m2 (b2, c))	The natural transformation. `mi`, `ai` and `bi` for `i = 1, 2` can be chosen freely, but `c` must be universally quantified
-> MSF m1 a1 b1
-> MSF m2 a2 b2

Generic lifting of a morphism to the level of MSFs.

Natural transformation to the level of MSFs.

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, side-effectful MSFs without implicit knowledge of time.

MSFs 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 => Category (MSF m :: Type -> Type -> Type)	Instance definition for `Category`. Defines `id` and `.`.
Instance details Defined in Data.MonadicStreamFunction.InternalCore Methods id :: MSF m a a # (.) :: MSF m b c -> MSF m a b -> MSF m a c #
type Groundring (MSF m a v)
Instance details Defined in Data.MonadicStreamFunction.Instances.VectorSpace type Groundring (MSF m a v) = Groundring v

data UTCTime #

This is the simplest representation of UTC. It consists of the day number, and a time offset from midnight. Note that if a day has a leap second added to it, it will have 86401 seconds.

Instances

Eq UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods (==) :: UTCTime -> UTCTime -> Bool # (/=) :: UTCTime -> UTCTime -> Bool #
Data UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTCTime -> c UTCTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UTCTime # toConstr :: UTCTime -> Constr # dataTypeOf :: UTCTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UTCTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UTCTime) # gmapT :: (forall b. Data b => b -> b) -> UTCTime -> UTCTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTCTime -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTCTime -> r # gmapQ :: (forall d. Data d => d -> u) -> UTCTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UTCTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime #
Ord UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods compare :: UTCTime -> UTCTime -> Ordering # (<) :: UTCTime -> UTCTime -> Bool # (<=) :: UTCTime -> UTCTime -> Bool # (>) :: UTCTime -> UTCTime -> Bool # (>=) :: UTCTime -> UTCTime -> Bool # max :: UTCTime -> UTCTime -> UTCTime # min :: UTCTime -> UTCTime -> UTCTime #
NFData UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods rnf :: UTCTime -> () #
ParseTime UTCTime
Instance details Defined in Data.Time.Format.Parse Methods buildTime :: TimeLocale -> [(Char, String)] -> Maybe UTCTime #
TimeDomain UTCTime Source #
Instance details Defined in FRP.Rhine.TimeDomain Associated Types type Diff UTCTime :: Type Source # Methods diffTime :: UTCTime -> UTCTime -> Diff UTCTime Source #
type Diff UTCTime Source #
Instance details Defined in FRP.Rhine.TimeDomain type Diff UTCTime = Double

newtype NumTimeDomain a Source #

Any Num can be wrapped to form a TimeDomain.

Constructors

NumTimeDomain
Fields fromNumTimeDomain :: a

Instances

Num a => Num (NumTimeDomain a) Source #
Instance details Defined in FRP.Rhine.TimeDomain Methods (+) :: NumTimeDomain a -> NumTimeDomain a -> NumTimeDomain a # (-) :: NumTimeDomain a -> NumTimeDomain a -> NumTimeDomain a # (*) :: NumTimeDomain a -> NumTimeDomain a -> NumTimeDomain a # negate :: NumTimeDomain a -> NumTimeDomain a # abs :: NumTimeDomain a -> NumTimeDomain a # signum :: NumTimeDomain a -> NumTimeDomain a # fromInteger :: Integer -> NumTimeDomain a #
Num a => TimeDomain (NumTimeDomain a) Source #
Instance details Defined in FRP.Rhine.TimeDomain Associated Types type Diff (NumTimeDomain a) :: Type Source # Methods diffTime :: NumTimeDomain a -> NumTimeDomain a -> Diff (NumTimeDomain a) Source #
type Diff (NumTimeDomain a) Source #
Instance details Defined in FRP.Rhine.TimeDomain type Diff (NumTimeDomain a) = NumTimeDomain a

class TimeDomain time where Source #

A time domain is an affine space representing a notion of time, such as real time, simulated time, steps, or a completely different notion.

Associated Types

type Diff time Source #

Methods

diffTime :: time -> time -> Diff time Source #

Instances

TimeDomain Double Source #
Instance details Defined in FRP.Rhine.TimeDomain Associated Types type Diff Double :: Type Source # Methods diffTime :: Double -> Double -> Diff Double Source #
TimeDomain Float Source #
Instance details Defined in FRP.Rhine.TimeDomain Associated Types type Diff Float :: Type Source # Methods diffTime :: Float -> Float -> Diff Float Source #
TimeDomain Integer Source #
Instance details Defined in FRP.Rhine.TimeDomain Associated Types type Diff Integer :: Type Source # Methods diffTime :: Integer -> Integer -> Diff Integer Source #
TimeDomain () Source #
Instance details Defined in FRP.Rhine.TimeDomain Associated Types type Diff () :: Type Source # Methods diffTime :: () -> () -> Diff () Source #
TimeDomain UTCTime Source #
Instance details Defined in FRP.Rhine.TimeDomain Associated Types type Diff UTCTime :: Type Source # Methods diffTime :: UTCTime -> UTCTime -> Diff UTCTime Source #
Num a => TimeDomain (NumTimeDomain a) Source #
Instance details Defined in FRP.Rhine.TimeDomain Associated Types type Diff (NumTimeDomain a) :: Type Source # Methods diffTime :: NumTimeDomain a -> NumTimeDomain a -> Diff (NumTimeDomain a) Source #

type IOClock m cl = HoistClock IO m cl Source #

Lift a clock type into MonadIO.

type LiftClock m t cl = HoistClock m (t m) cl Source #

Lift a clock type into a monad transformer.

data HoistClock m1 m2 cl Source #

Applying a monad morphism yields a new clock.

Constructors

HoistClock
Fields unhoistedClock :: cl monadMorphism :: forall a. m1 a -> m2 a

Instances

(Monad m1, Monad m2, Clock m1 cl) => Clock m2 (HoistClock m1 m2 cl) Source #
Instance details Defined in FRP.Rhine.Clock Associated Types type Time (HoistClock m1 m2 cl) :: Type Source # type Tag (HoistClock m1 m2 cl) :: Type Source # Methods initClock :: HoistClock m1 m2 cl -> RunningClockInit m2 (Time (HoistClock m1 m2 cl)) (Tag (HoistClock m1 m2 cl)) Source #
type Time (HoistClock m1 m2 cl) Source #
Instance details Defined in FRP.Rhine.Clock type Time (HoistClock m1 m2 cl) = Time cl
type Tag (HoistClock m1 m2 cl) Source #
Instance details Defined in FRP.Rhine.Clock type Tag (HoistClock m1 m2 cl) = Tag cl

data RescaledClockS m cl time tag Source #

Instead of a mere function as morphism of time domains, we can transform one time domain into the other with a monadic stream function.

Constructors

RescaledClockS
Fields unscaledClockS :: cl The clock before the rescaling rescaleS :: RescalingSInit m cl time tag The rescaling stream function, and rescaled initial time, depending on the initial time before rescaling

Instances

(Monad m, TimeDomain time, Clock m cl) => Clock m (RescaledClockS m cl time tag) Source #
Instance details Defined in FRP.Rhine.Clock Associated Types type Time (RescaledClockS m cl time tag) :: Type Source # type Tag (RescaledClockS m cl time tag) :: Type Source # Methods initClock :: RescaledClockS m cl time tag -> RunningClockInit m (Time (RescaledClockS m cl time tag)) (Tag (RescaledClockS m cl time tag)) Source #
type Time (RescaledClockS m cl time tag) Source #
Instance details Defined in FRP.Rhine.Clock type Time (RescaledClockS m cl time tag) = time
type Tag (RescaledClockS m cl time tag) Source #
Instance details Defined in FRP.Rhine.Clock type Tag (RescaledClockS m cl time tag) = tag

data RescaledClockM m cl time Source #

Instead of a mere function as morphism of time domains, we can transform one time domain into the other with an effectful morphism.

Constructors

RescaledClockM
Fields unscaledClockM :: cl The clock before the rescaling rescaleM :: RescalingM m cl time Computing the new time effectfully from the old time

Instances

(Monad m, TimeDomain time, Clock m cl) => Clock m (RescaledClockM m cl time) Source #
Instance details Defined in FRP.Rhine.Clock Associated Types type Time (RescaledClockM m cl time) :: Type Source # type Tag (RescaledClockM m cl time) :: Type Source # Methods initClock :: RescaledClockM m cl time -> RunningClockInit m (Time (RescaledClockM m cl time)) (Tag (RescaledClockM m cl time)) Source #
type Time (RescaledClockM m cl time) Source #
Instance details Defined in FRP.Rhine.Clock type Time (RescaledClockM m cl time) = time
type Tag (RescaledClockM m cl time) Source #
Instance details Defined in FRP.Rhine.Clock type Tag (RescaledClockM m cl time) = Tag cl

data RescaledClock cl time Source #

Applying a morphism of time domains yields a new clock.

Constructors

RescaledClock
Fields unscaledClock :: cl rescale :: Rescaling cl time

Instances

(Monad m, TimeDomain time, Clock m cl) => Clock m (RescaledClock cl time) Source #
Instance details Defined in FRP.Rhine.Clock Associated Types type Time (RescaledClock cl time) :: Type Source # type Tag (RescaledClock cl time) :: Type Source # Methods initClock :: RescaledClock cl time -> RunningClockInit m (Time (RescaledClock cl time)) (Tag (RescaledClock cl time)) Source #
type Time (RescaledClock cl time) Source #
Instance details Defined in FRP.Rhine.Clock type Time (RescaledClock cl time) = time
type Tag (RescaledClock cl time) Source #
Instance details Defined in FRP.Rhine.Clock type Tag (RescaledClock cl time) = Tag cl

type RescalingSInit m cl time tag = Time cl -> m (RescalingS m cl time tag, time) Source #

Like RescalingS, but allows for an initialisation of the rescaling morphism, together with the initial time.

type RescalingS m cl time tag = MSF m (Time cl, Tag cl) (time, tag) Source #

An effectful, stateful morphism of time domains is an MSF that uses side effects to rescale a point in one time domain into another one.

type RescalingM m cl time = Time cl -> m time Source #

An effectful morphism of time domains is a Kleisli arrow. It can use a side effect to rescale a point in one time domain into another one.

type Rescaling cl time = Time cl -> time Source #

A pure morphism of time domains is just a function.

data TimeInfo cl Source #

An annotated, rich time stamp.

Constructors

TimeInfo
Fields sinceLast :: Diff (Time cl) Time passed since the last tick sinceInit :: Diff (Time cl) Time passed since the initialisation of the clock absolute :: Time cl The absolute time of the current tick tag :: Tag cl The tag annotation of the current tick

class TimeDomain (Time cl) => Clock m cl where Source #

Since we want to leverage Haskell's type system to annotate signal networks by their clocks, each clock must be an own type, cl. Different values of the same clock type should tick at the same speed, and only differ in implementation details. Often, clocks are singletons.

Associated Types

type Time cl Source #

The time domain, i.e. type of the time stamps the clock creates.

type Tag cl Source #

Additional information that the clock may output at each tick, e.g. if a realtime promise was met, if an event occurred, if one of its subclocks (if any) ticked.

Methods

initClock Source #

Arguments

:: cl	The clock value, containing e.g. settings or device parameters
-> RunningClockInit m (Time cl) (Tag cl)	The stream of time stamps, and the initial time

The method that produces to a clock value a running clock, i.e. an effectful stream of tagged time stamps together with an initialisation time.

Instances

Clock IO Busy Source #
Instance details Defined in FRP.Rhine.Clock.Realtime.Busy Associated Types type Time Busy :: Type Source # type Tag Busy :: Type Source # Methods initClock :: Busy -> RunningClockInit IO (Time Busy) (Tag Busy) Source #
MonadIO m => Clock m StdinClock Source #
Instance details Defined in FRP.Rhine.Clock.Realtime.Stdin Associated Types type Time StdinClock :: Type Source # type Tag StdinClock :: Type Source # Methods initClock :: StdinClock -> RunningClockInit m (Time StdinClock) (Tag StdinClock) Source #
Clock IO (Millisecond n) Source #
Instance details Defined in FRP.Rhine.Clock.Realtime.Millisecond Associated Types type Time (Millisecond n) :: Type Source # type Tag (Millisecond n) :: Type Source # Methods initClock :: Millisecond n -> RunningClockInit IO (Time (Millisecond n)) (Tag (Millisecond n)) Source #
(Monad m, PureAudioClockRate rate) => Clock m (PureAudioClock rate) Source #
Instance details Defined in FRP.Rhine.Clock.Realtime.Audio Associated Types type Time (PureAudioClock rate) :: Type Source # type Tag (PureAudioClock rate) :: Type Source # Methods initClock :: PureAudioClock rate -> RunningClockInit m (Time (PureAudioClock rate)) (Tag (PureAudioClock rate)) Source #
Monad m => Clock m (FixedStep n) Source #
Instance details Defined in FRP.Rhine.Clock.FixedStep Associated Types type Time (FixedStep n) :: Type Source # type Tag (FixedStep n) :: Type Source # Methods initClock :: FixedStep n -> RunningClockInit m (Time (FixedStep n)) (Tag (FixedStep n)) Source #
(Monad m, TimeDomain time, Clock m cl) => Clock m (RescaledClock cl time) Source #
Instance details Defined in FRP.Rhine.Clock Associated Types type Time (RescaledClock cl time) :: Type Source # type Tag (RescaledClock cl time) :: Type Source # Methods initClock :: RescaledClock cl time -> RunningClockInit m (Time (RescaledClock cl time)) (Tag (RescaledClock cl time)) Source #
(Monad m, Clock m cl) => Clock m (SelectClock cl a) Source #
Instance details Defined in FRP.Rhine.Clock.Select Associated Types type Time (SelectClock cl a) :: Type Source # type Tag (SelectClock cl a) :: Type Source # Methods initClock :: SelectClock cl a -> RunningClockInit m (Time (SelectClock cl a)) (Tag (SelectClock cl a)) Source #
(MonadIO m, KnownNat bufferSize, AudioClockRate rate) => Clock m (AudioClock rate bufferSize) Source #
Instance details Defined in FRP.Rhine.Clock.Realtime.Audio Associated Types type Time (AudioClock rate bufferSize) :: Type Source # type Tag (AudioClock rate bufferSize) :: Type Source # Methods initClock :: AudioClock rate bufferSize -> RunningClockInit m (Time (AudioClock rate bufferSize)) (Tag (AudioClock rate bufferSize)) Source #
(Monad m1, Monad m2, Clock m1 cl) => Clock m2 (HoistClock m1 m2 cl) Source #
Instance details Defined in FRP.Rhine.Clock Associated Types type Time (HoistClock m1 m2 cl) :: Type Source # type Tag (HoistClock m1 m2 cl) :: Type Source # Methods initClock :: HoistClock m1 m2 cl -> RunningClockInit m2 (Time (HoistClock m1 m2 cl)) (Tag (HoistClock m1 m2 cl)) Source #
(Monad m, TimeDomain time, Clock m cl) => Clock m (RescaledClockM m cl time) Source #
Instance details Defined in FRP.Rhine.Clock Associated Types type Time (RescaledClockM m cl time) :: Type Source # type Tag (RescaledClockM m cl time) :: Type Source # Methods initClock :: RescaledClockM m cl time -> RunningClockInit m (Time (RescaledClockM m cl time)) (Tag (RescaledClockM m cl time)) Source #
(Monad m, Clock m cl1, Clock m cl2) => Clock m (ParallelClock m cl1 cl2) Source #
Instance details Defined in FRP.Rhine.Schedule Associated Types type Time (ParallelClock m cl1 cl2) :: Type Source # type Tag (ParallelClock m cl1 cl2) :: Type Source # Methods initClock :: ParallelClock m cl1 cl2 -> RunningClockInit m (Time (ParallelClock m cl1 cl2)) (Tag (ParallelClock m cl1 cl2)) Source #
(Monad m, Clock m cl1, Clock m cl2) => Clock m (SequentialClock m cl1 cl2) Source #
Instance details Defined in FRP.Rhine.Schedule Associated Types type Time (SequentialClock m cl1 cl2) :: Type Source # type Tag (SequentialClock m cl1 cl2) :: Type Source # Methods initClock :: SequentialClock m cl1 cl2 -> RunningClockInit m (Time (SequentialClock m cl1 cl2)) (Tag (SequentialClock m cl1 cl2)) Source #
(Monad m, TimeDomain time, Clock m cl) => Clock m (RescaledClockS m cl time tag) Source #
Instance details Defined in FRP.Rhine.Clock Associated Types type Time (RescaledClockS m cl time tag) :: Type Source # type Tag (RescaledClockS m cl time tag) :: Type Source # Methods initClock :: RescaledClockS m cl time tag -> RunningClockInit m (Time (RescaledClockS m cl time tag)) (Tag (RescaledClockS m cl time tag)) Source #
(Monad m, NonemptyNatList v) => Clock (ScheduleT Integer m) (Periodic v) Source #
Instance details Defined in FRP.Rhine.Clock.Periodic Associated Types type Time (Periodic v) :: Type Source # type Tag (Periodic v) :: Type Source # Methods initClock :: Periodic v -> RunningClockInit (ScheduleT Integer m) (Time (Periodic v)) (Tag (Periodic v)) Source #
MonadIO m => Clock (EventChanT event m) (EventClock event) Source #
Instance details Defined in FRP.Rhine.Clock.Realtime.Event Associated Types type Time (EventClock event) :: Type Source # type Tag (EventClock event) :: Type Source # Methods initClock :: EventClock event -> RunningClockInit (EventChanT event m) (Time (EventClock event)) (Tag (EventClock event)) Source #

type RunningClockInit m time tag = m (RunningClock m time tag, time) Source #

When initialising a clock, the initial time is measured (typically by means of a side effect), and a running clock is returned.

type RunningClock m time tag = MSF m () (time, tag) Source #

A clock creates a stream of time stamps and additional information, possibly together with side effects in a monad m that cause the environment to wait until the specified time is reached.

retag :: Time cl1 ~ Time cl2 => (Tag cl1 -> Tag cl2) -> TimeInfo cl1 -> TimeInfo cl2 Source #

A utility that changes the tag of a TimeInfo.

genTimeInfo :: (Monad m, Clock m cl) => cl -> Time cl -> MSF m (Time cl, Tag cl) (TimeInfo cl) Source #

Given a clock value and an initial time, generate a stream of time stamps.

rescaleMToSInit :: Monad m => (time1 -> m time2) -> time1 -> m (MSF m (time1, tag) (time2, tag), time2) Source #

Convert an effectful morphism of time domains into a stateful one with initialisation. Think of its type as RescalingM m cl time -> RescalingSInit m cl time tag, although this type is ambiguous.

rescaledClockToM :: Monad m => RescaledClock cl time -> RescaledClockM m cl time Source #

A RescaledClock is trivially a RescaledClockM.

rescaledClockMToS :: Monad m => RescaledClockM m cl time -> RescaledClockS m cl time (Tag cl) Source #

A RescaledClockM is trivially a RescaledClockS.

rescaledClockToS :: Monad m => RescaledClock cl time -> RescaledClockS m cl time (Tag cl) Source #

A RescaledClock is trivially a RescaledClockS.

liftClock :: (Monad m, MonadTrans t) => cl -> LiftClock m t cl Source #

Lift a clock value into a monad transformer.

ioClock :: MonadIO m => cl -> IOClock m cl Source #

Lift a clock value into MonadIO.