FRP.Rhine.Clock

The Clock type class

class TimeDomain (TimeDomainOf cl) => Clock m cl where

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

Since we want to leverage Haskell's type system to annotate signal functions 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.

Minimal complete definition

startClock

Associated Types

type TimeDomainOf cl

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

type Tag cl

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

startClock :: cl -> m (MSF m () (TimeDomainOf cl, Tag cl), TimeDomainOf cl)

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

Associated Types

type TimeDomainOf Busy :: *

type Tag Busy :: *

Methods

startClock :: Busy -> IO (MSF IO () (TimeDomainOf Busy, Tag Busy), TimeDomainOf Busy)

Monad m => Clock m Count

Associated Types

type TimeDomainOf Count :: *

type Tag Count :: *

Methods

startClock :: Count -> m (MSF m () (TimeDomainOf Count, Tag Count), TimeDomainOf Count)

Monad m => Clock m FixedRate

Associated Types

type TimeDomainOf FixedRate :: *

type Tag FixedRate :: *

Methods

startClock :: FixedRate -> m (MSF m () (TimeDomainOf FixedRate, Tag FixedRate), TimeDomainOf FixedRate)

MonadIO m => Clock m StdinClock

Associated Types

type TimeDomainOf StdinClock :: *

type Tag StdinClock :: *

Methods

startClock :: StdinClock -> m (MSF m () (TimeDomainOf StdinClock, Tag StdinClock), TimeDomainOf StdinClock)

(Monad m, PureAudioClockRate rate) => Clock m (PureAudioClock rate)

Associated Types

type TimeDomainOf (PureAudioClock rate) :: *

type Tag (PureAudioClock rate) :: *

Methods

startClock :: PureAudioClock rate -> m (MSF m () (TimeDomainOf (PureAudioClock rate), Tag (PureAudioClock rate)), TimeDomainOf (PureAudioClock rate))

Monad m => Clock m (Step n)

Associated Types

type TimeDomainOf (Step n) :: *

type Tag (Step n) :: *

Methods

startClock :: Step n -> m (MSF m () (TimeDomainOf (Step n), Tag (Step n)), TimeDomainOf (Step n))

(Monad m, TimeDomain td, Clock m cl) => Clock m (RescaledClock cl td)

Associated Types

type TimeDomainOf (RescaledClock cl td) :: *

type Tag (RescaledClock cl td) :: *

Methods

startClock :: RescaledClock cl td -> m (MSF m () (TimeDomainOf (RescaledClock cl td), Tag (RescaledClock cl td)), TimeDomainOf (RescaledClock cl td))

(MonadIO m, KnownNat bufferSize, AudioClockRate rate) => Clock m (AudioClock rate bufferSize)

Associated Types

type TimeDomainOf (AudioClock rate bufferSize) :: *

type Tag (AudioClock rate bufferSize) :: *

Methods

startClock :: AudioClock rate bufferSize -> m (MSF m () (TimeDomainOf (AudioClock rate bufferSize), Tag (AudioClock rate bufferSize)), TimeDomainOf (AudioClock rate bufferSize))

(Monad m, Clock m cl) => Clock m (SelectClock cl a)

Associated Types

type TimeDomainOf (SelectClock cl a) :: *

type Tag (SelectClock cl a) :: *

Methods

startClock :: SelectClock cl a -> m (MSF m () (TimeDomainOf (SelectClock cl a), Tag (SelectClock cl a)), TimeDomainOf (SelectClock cl a))

(Monad m1, Monad m2, Clock m1 a) => Clock m2 (HoistClock m1 m2 a)

Associated Types

type TimeDomainOf (HoistClock m1 m2 a) :: *

type Tag (HoistClock m1 m2 a) :: *

Methods

startClock :: HoistClock m1 m2 a -> m2 (MSF m2 () (TimeDomainOf (HoistClock m1 m2 a), Tag (HoistClock m1 m2 a)), TimeDomainOf (HoistClock m1 m2 a))

(Monad m, Clock m cl1, Clock m cl2) => Clock m (ParallelClock m cl1 cl2)

Associated Types

type TimeDomainOf (ParallelClock m cl1 cl2) :: *

type Tag (ParallelClock m cl1 cl2) :: *

Methods

startClock :: ParallelClock m cl1 cl2 -> m (MSF m () (TimeDomainOf (ParallelClock m cl1 cl2), Tag (ParallelClock m cl1 cl2)), TimeDomainOf (ParallelClock m cl1 cl2))

(Monad m, Clock m cl1, Clock m cl2) => Clock m (SequentialClock m cl1 cl2)

Associated Types

type TimeDomainOf (SequentialClock m cl1 cl2) :: *

type Tag (SequentialClock m cl1 cl2) :: *

Methods

startClock :: SequentialClock m cl1 cl2 -> m (MSF m () (TimeDomainOf (SequentialClock m cl1 cl2), Tag (SequentialClock m cl1 cl2)), TimeDomainOf (SequentialClock m cl1 cl2))

(Monad m, TimeDomain td, Clock m cl) => Clock m (RescaledClockS m cl td tag)

Associated Types

type TimeDomainOf (RescaledClockS m cl td tag) :: *

type Tag (RescaledClockS m cl td tag) :: *

Methods

startClock :: RescaledClockS m cl td tag -> m (MSF m () (TimeDomainOf (RescaledClockS m cl td tag), Tag (RescaledClockS m cl td tag)), TimeDomainOf (RescaledClockS m cl td tag))

Auxiliary definitions and utilities

data TimeInfo cl

An annotated, rich time stamp.

Constructors

TimeInfo

Fields

• sinceTick :: Diff (TimeDomainOf cl)

  Time passed since the last tick

• sinceStart :: Diff (TimeDomainOf cl)

  Time passed since the initialisation of the clock

• absolute :: TimeDomainOf cl

  The absolute time of the current tick

• tag :: Tag cl

  The tag annotation of the current tick

retag :: TimeDomainOf cl1 ~ TimeDomainOf cl2 => (Tag cl1 -> Tag cl2) -> TimeInfo cl1 -> TimeInfo cl2

A utility that changes the tag of a TimeInfo.

genTimeInfo :: (Monad m, Clock m cl) => cl -> TimeDomainOf cl -> MSF m (TimeDomainOf cl, Tag cl) (TimeInfo cl)

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

Certain universal building blocks to produce new clocks from given ones

data RescaledClock cl td

Applying a morphism of time domains yields a new clock.

Constructors

RescaledClock

Fields

• unscaledClock :: cl
• rescale :: TimeDomainOf cl -> td

Instances

(Monad m, TimeDomain td, Clock m cl) => Clock m (RescaledClock cl td)

Associated Types

type TimeDomainOf (RescaledClock cl td) :: *

type Tag (RescaledClock cl td) :: *

Methods

startClock :: RescaledClock cl td -> m (MSF m () (TimeDomainOf (RescaledClock cl td), Tag (RescaledClock cl td)), TimeDomainOf (RescaledClock cl td))

type TimeDomainOf (RescaledClock cl td)

type TimeDomainOf (RescaledClock cl td) = td

type Tag (RescaledClock cl td)

type Tag (RescaledClock cl td) = Tag cl

data RescaledClockS m cl td tag

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 :: TimeDomainOf cl -> m (MSF m (TimeDomainOf cl, Tag cl) (td, tag), td)

  The rescaling stream function, and rescaled initial time, depending on the initial time before rescaling

Instances

(Monad m, TimeDomain td, Clock m cl) => Clock m (RescaledClockS m cl td tag)

Associated Types

type TimeDomainOf (RescaledClockS m cl td tag) :: *

type Tag (RescaledClockS m cl td tag) :: *

Methods

startClock :: RescaledClockS m cl td tag -> m (MSF m () (TimeDomainOf (RescaledClockS m cl td tag), Tag (RescaledClockS m cl td tag)), TimeDomainOf (RescaledClockS m cl td tag))

type TimeDomainOf (RescaledClockS m cl td tag)

type TimeDomainOf (RescaledClockS m cl td tag) = td

type Tag (RescaledClockS m cl td tag)

type Tag (RescaledClockS m cl td tag) = tag

data HoistClock m1 m2 cl

Applying a monad morphism yields a new clock.

Constructors

HoistClock

Fields

• hoistedClock :: cl
• monadMorphism :: forall a. m1 a -> m2 a

Instances

(Monad m1, Monad m2, Clock m1 a) => Clock m2 (HoistClock m1 m2 a)

Associated Types

type TimeDomainOf (HoistClock m1 m2 a) :: *

type Tag (HoistClock m1 m2 a) :: *

Methods

startClock :: HoistClock m1 m2 a -> m2 (MSF m2 () (TimeDomainOf (HoistClock m1 m2 a), Tag (HoistClock m1 m2 a)), TimeDomainOf (HoistClock m1 m2 a))

type TimeDomainOf (HoistClock m1 m2 cl)

type TimeDomainOf (HoistClock m1 m2 cl) = TimeDomainOf cl

type Tag (HoistClock m1 m2 cl)

type Tag (HoistClock m1 m2 cl) = Tag cl

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

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