FRP.Rhine.Clock

Clocks are the central new notion in Rhine. There are clock types (instances of the Clock type class) and their values.

This module provides the Clock type class, several utilities, and certain general constructions of Clocks, such as clocks lifted along monad morphisms or time rescalings.

Documentation

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

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

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

initClock

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

MonadIO m => Clock m Busy

Defined in FRP.Rhine.Clock.Realtime.Busy

Associated Types

type Time Busy

type Tag Busy

Methods

initClock :: Busy -> RunningClockInit m (Time Busy) (Tag Busy)

MonadIO m => Clock m Never

Defined in FRP.Rhine.Clock.Realtime.Never

Associated Types

type Time Never

type Tag Never

Methods

initClock :: Never -> RunningClockInit m (Time Never) (Tag Never)

MonadIO m => Clock m StdinClock

Defined in FRP.Rhine.Clock.Realtime.Stdin

Associated Types

type Time StdinClock

type Tag StdinClock

Methods

initClock :: StdinClock -> RunningClockInit m (Time StdinClock) (Tag StdinClock)

Monad m => Clock m Trivial

Defined in FRP.Rhine.Clock.Trivial

Associated Types

type Time Trivial

type Tag Trivial

Methods

initClock :: Trivial -> RunningClockInit m (Time Trivial) (Tag Trivial)

Clock IO (Millisecond n)

Defined in FRP.Rhine.Clock.Realtime.Millisecond

Associated Types

type Time (Millisecond n)

type Tag (Millisecond n)

Methods

initClock :: Millisecond n -> RunningClockInit IO (Time (Millisecond n)) (Tag (Millisecond n))

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

Defined in FRP.Rhine.Clock.Realtime.Audio

Associated Types

type Time (PureAudioClock rate)

type Tag (PureAudioClock rate)

Methods

initClock :: PureAudioClock rate -> RunningClockInit m (Time (PureAudioClock rate)) (Tag (PureAudioClock rate))

(Exception e, Clock IO cl, MonadIO eio, MonadError e eio) => Clock eio (ExceptClock cl e)

Defined in FRP.Rhine.Clock.Except

Associated Types

type Time (ExceptClock cl e)

type Tag (ExceptClock cl e)

Methods

initClock :: ExceptClock cl e -> RunningClockInit eio (Time (ExceptClock cl e)) (Tag (ExceptClock cl e))

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

Defined in FRP.Rhine.Clock

Associated Types

type Time (RescaledClock cl time)

type Tag (RescaledClock cl time)

Methods

initClock :: RescaledClock cl time -> RunningClockInit m (Time (RescaledClock cl time)) (Tag (RescaledClock cl time))

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

Defined in FRP.Rhine.Clock.Realtime.Audio

Associated Types

type Time (AudioClock rate bufferSize)

type Tag (AudioClock rate bufferSize)

Methods

initClock :: AudioClock rate bufferSize -> RunningClockInit m (Time (AudioClock rate bufferSize)) (Tag (AudioClock rate bufferSize))

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

Defined in FRP.Rhine.Clock.Select

Associated Types

type Time (SelectClock cl a)

type Tag (SelectClock cl a)

Methods

initClock :: SelectClock cl a -> RunningClockInit m (Time (SelectClock cl a)) (Tag (SelectClock cl a))

(TimeDomain (Time cl), Clock (ScheduleT (Diff (Time cl)) m) cl, Monad m) => Clock m (UnscheduleClock m cl)

Defined in FRP.Rhine.Clock.Unschedule

Associated Types

type Time (UnscheduleClock m cl)

type Tag (UnscheduleClock m cl)

Methods

initClock :: UnscheduleClock m cl -> RunningClockInit m (Time (UnscheduleClock m cl)) (Tag (UnscheduleClock m cl))

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

Defined in FRP.Rhine.Schedule

Associated Types

type Time (ParallelClock cl1 cl2)

type Tag (ParallelClock cl1 cl2)

Methods

initClock :: ParallelClock cl1 cl2 -> RunningClockInit m (Time (ParallelClock cl1 cl2)) (Tag (ParallelClock cl1 cl2))

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

Defined in FRP.Rhine.Schedule

Associated Types

type Time (SequentialClock cl1 cl2)

type Tag (SequentialClock cl1 cl2)

Methods

initClock :: SequentialClock cl1 cl2 -> RunningClockInit m (Time (SequentialClock cl1 cl2)) (Tag (SequentialClock cl1 cl2))

(Monad m, TimeDomain time, Clock m cl) => Clock m (RescaledClockM m cl time)

Defined in FRP.Rhine.Clock

Associated Types

type Time (RescaledClockM m cl time)

type Tag (RescaledClockM m cl time)

Methods

initClock :: RescaledClockM m cl time -> RunningClockInit m (Time (RescaledClockM m cl time)) (Tag (RescaledClockM m cl time))

(Time cl1 ~ Time cl2, Clock (ExceptT e m) cl1, Clock m cl2, Monad m) => Clock m (CatchClock cl1 e cl2)

Defined in FRP.Rhine.Clock.Except

Associated Types

type Time (CatchClock cl1 e cl2)

type Tag (CatchClock cl1 e cl2)

Methods

initClock :: CatchClock cl1 e cl2 -> RunningClockInit m (Time (CatchClock cl1 e cl2)) (Tag (CatchClock cl1 e cl2))

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

Defined in FRP.Rhine.Clock

Associated Types

type Time (HoistClock m1 m2 cl)

type Tag (HoistClock m1 m2 cl)

Methods

initClock :: HoistClock m1 m2 cl -> RunningClockInit m2 (Time (HoistClock m1 m2 cl)) (Tag (HoistClock m1 m2 cl))

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

Defined in FRP.Rhine.Clock

Associated Types

type Time (RescaledClockS m cl time tag)

type Tag (RescaledClockS m cl time tag)

Methods

initClock :: RescaledClockS m cl time tag -> RunningClockInit m (Time (RescaledClockS m cl time tag)) (Tag (RescaledClockS m cl time tag))

(TimeDomain time, MonadError e m) => Clock m (Single m time tag e)

Defined in FRP.Rhine.Clock.Except

Associated Types

type Time (Single m time tag e)

type Tag (Single m time tag e)

Methods

initClock :: Single m time tag e -> RunningClockInit m (Time (Single m time tag e)) (Tag (Single m time tag e))

(MonadSchedule m, Monad m) => Clock (ScheduleT Integer m) (FixedStep n)

Defined in FRP.Rhine.Clock.FixedStep

Associated Types

type Time (FixedStep n)

type Tag (FixedStep n)

Methods

initClock :: FixedStep n -> RunningClockInit (ScheduleT Integer m) (Time (FixedStep n)) (Tag (FixedStep n))

(Monad m, NonemptyNatList v) => Clock (ScheduleT Integer m) (Periodic v)

Defined in FRP.Rhine.Clock.Periodic

Associated Types

type Time (Periodic v)

type Tag (Periodic v)

Methods

initClock :: Periodic v -> RunningClockInit (ScheduleT Integer m) (Time (Periodic v)) (Tag (Periodic v))

MonadIO m => Clock (EventChanT event m) (EventClock event)

Defined in FRP.Rhine.Clock.Realtime.Event

Associated Types

type Time (EventClock event)

type Tag (EventClock event)

Methods

initClock :: EventClock event -> RunningClockInit (EventChanT event m) (Time (EventClock event)) (Tag (EventClock event))

type RunningClock m time tag = Automaton m () (time, tag)

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.

data HoistClock m1 m2 cl

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)

Defined in FRP.Rhine.Clock

Associated Types

type Time (HoistClock m1 m2 cl)

type Tag (HoistClock m1 m2 cl)

Methods

initClock :: HoistClock m1 m2 cl -> RunningClockInit m2 (Time (HoistClock m1 m2 cl)) (Tag (HoistClock m1 m2 cl))

GetClockProxy cl => GetClockProxy (HoistClock m1 m2 cl)

Defined in FRP.Rhine.Clock.Proxy

Methods

getClockProxy :: ClockProxy (HoistClock m1 m2 cl)

type Tag (HoistClock m1 m2 cl)

Defined in FRP.Rhine.Clock

type Tag (HoistClock m1 m2 cl) = Tag cl

type Time (HoistClock m1 m2 cl)

Defined in FRP.Rhine.Clock

type Time (HoistClock m1 m2 cl) = Time cl

data TimeInfo cl

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

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

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

type Rescaling cl time = Time cl -> time

A pure morphism of time domains is just a function.

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

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 RescalingS m cl time tag = Automaton m (Time cl, Tag cl) (time, tag)

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

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

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

data RescaledClock cl time

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)

Defined in FRP.Rhine.Clock

Associated Types

type Time (RescaledClock cl time)

type Tag (RescaledClock cl time)

Methods

initClock :: RescaledClock cl time -> RunningClockInit m (Time (RescaledClock cl time)) (Tag (RescaledClock cl time))

GetClockProxy cl => GetClockProxy (RescaledClock cl time)

Defined in FRP.Rhine.Clock.Proxy

Methods

getClockProxy :: ClockProxy (RescaledClock cl time)

type Tag (RescaledClock cl time)

Defined in FRP.Rhine.Clock

type Tag (RescaledClock cl time) = Tag cl

type Time (RescaledClock cl time)

Defined in FRP.Rhine.Clock

type Time (RescaledClock cl time) = time

data RescaledClockM m cl time

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)

Defined in FRP.Rhine.Clock

Associated Types

type Time (RescaledClockM m cl time)

type Tag (RescaledClockM m cl time)

Methods

initClock :: RescaledClockM m cl time -> RunningClockInit m (Time (RescaledClockM m cl time)) (Tag (RescaledClockM m cl time))

GetClockProxy cl => GetClockProxy (RescaledClockM m cl time)

Defined in FRP.Rhine.Clock.Proxy

Methods

getClockProxy :: ClockProxy (RescaledClockM m cl time)

type Tag (RescaledClockM m cl time)

Defined in FRP.Rhine.Clock

type Tag (RescaledClockM m cl time) = Tag cl

type Time (RescaledClockM m cl time)

Defined in FRP.Rhine.Clock

type Time (RescaledClockM m cl time) = time

data RescaledClockS m cl time tag

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

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)

Defined in FRP.Rhine.Clock

Associated Types

type Time (RescaledClockS m cl time tag)

type Tag (RescaledClockS m cl time tag)

Methods

initClock :: RescaledClockS m cl time tag -> RunningClockInit m (Time (RescaledClockS m cl time tag)) (Tag (RescaledClockS m cl time tag))

GetClockProxy cl => GetClockProxy (RescaledClockS m cl time tag)

Defined in FRP.Rhine.Clock.Proxy

Methods

getClockProxy :: ClockProxy (RescaledClockS m cl time tag)

type Tag (RescaledClockS m cl time tag)

Defined in FRP.Rhine.Clock

type Tag (RescaledClockS m cl time tag) = tag

type Time (RescaledClockS m cl time tag)

Defined in FRP.Rhine.Clock

type Time (RescaledClockS m cl time tag) = time

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

Lift a clock type into a monad transformer.

type IOClock m cl = HoistClock IO m cl

Lift a clock type into MonadIO.

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

A utility that changes the tag of a TimeInfo.

rescaleMToSInit :: Monad m => (time1 -> m time2) -> time1 -> m (Automaton m (time1, tag) (time2, tag), time2)

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

A RescaledClock is trivially a RescaledClockM.

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

A RescaledClockM is trivially a RescaledClockS.

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

A RescaledClock is trivially a RescaledClockS.

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

Lift a clock value into a monad transformer.

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

Lift a clock value into MonadIO.

module Data.TimeDomain