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

type IOClock m cl = HoistClock IO m cl

Lift a clock type into MonadIO.

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

Lift a clock type into a monad transformer.

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

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

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

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.

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

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

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

A pure morphism of time domains is just a function.

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

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

Clock IO Busy

Defined in FRP.Rhine.Clock.Realtime.Busy

Associated Types

type Time Busy

type Tag Busy

Methods

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

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)

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 => Clock m (FixedStep n)

Defined in FRP.Rhine.Clock.FixedStep

Associated Types

type Time (FixedStep n)

type Tag (FixedStep n)

Methods

initClock :: FixedStep n -> RunningClockInit m (Time (FixedStep n)) (Tag (FixedStep 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))

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

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

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

Defined in FRP.Rhine.Schedule

Associated Types

type Time (ParallelClock m cl1 cl2)

type Tag (ParallelClock m cl1 cl2)

Methods

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

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

Defined in FRP.Rhine.Schedule

Associated Types

type Time (SequentialClock m cl1 cl2)

type Tag (SequentialClock m cl1 cl2)

Methods

initClock :: SequentialClock m cl1 cl2 -> RunningClockInit m (Time (SequentialClock m cl1 cl2)) (Tag (SequentialClock m cl1 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))

(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 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 RunningClock m time tag = MSF 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.

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

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

Kleisli arrows of a monad.

Constructors

Kleisli

Fields

• runKleisli :: a -> m b

Instances

Monad m => Category (Kleisli m :: Type -> Type -> TYPE LiftedRep)

Since: base-3.0

Defined in Control.Arrow

Methods

id :: forall (a :: k). Kleisli m a a

(.) :: forall (b :: k) (c :: k) (a :: k). Kleisli m b c -> Kleisli m a b -> Kleisli m a c

Generic1 (Kleisli m a :: Type -> TYPE LiftedRep)

Defined in Control.Arrow

Associated Types

type Rep1 (Kleisli m a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Kleisli m a a0 -> Rep1 (Kleisli m a) a0

to1 :: forall (a0 :: k). Rep1 (Kleisli m a) a0 -> Kleisli m a a0

Monad m => Arrow (Kleisli m)

Since: base-2.1

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

Monad m => ArrowApply (Kleisli m)

Since: base-2.1

Defined in Control.Arrow

Methods

app :: Kleisli m (Kleisli m b c, b) c

Monad m => ArrowChoice (Kleisli m)

Since: base-2.1

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

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

Defined in Control.Arrow

Methods

loop :: Kleisli m (b, d) (c, d) -> Kleisli m b c

MonadPlus m => ArrowPlus (Kleisli m)

Since: base-2.1

Defined in Control.Arrow

Methods

(<+>) :: Kleisli m b c -> Kleisli m b c -> Kleisli m b c

MonadPlus m => ArrowZero (Kleisli m)

Since: base-2.1

Defined in Control.Arrow

Methods

zeroArrow :: Kleisli m b c

Alternative m => Alternative (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

empty :: Kleisli m a a0

(<|>) :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0

some :: Kleisli m a a0 -> Kleisli m a [a0]

many :: Kleisli m a a0 -> Kleisli m a [a0]

Applicative m => Applicative (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

pure :: a0 -> Kleisli m a a0

(<*>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b

liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c

(*>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b

(<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0

Functor m => Functor (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

fmap :: (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b

(<$) :: a0 -> Kleisli m a b -> Kleisli m a a0

Monad m => Monad (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

(>>=) :: Kleisli m a a0 -> (a0 -> Kleisli m a b) -> Kleisli m a b

(>>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b

return :: a0 -> Kleisli m a a0

MonadPlus m => MonadPlus (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

mzero :: Kleisli m a a0

mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0

Generic (Kleisli m a b)

Defined in Control.Arrow

Associated Types

type Rep (Kleisli m a b) :: Type -> Type

Methods

from :: Kleisli m a b -> Rep (Kleisli m a b) x

to :: Rep (Kleisli m a b) x -> Kleisli m a b

type Rep1 (Kleisli m a :: Type -> TYPE LiftedRep)

Since: base-4.14.0.0

Defined in Control.Arrow

type Rep1 (Kleisli m a :: Type -> TYPE LiftedRep) = D1 ('MetaData "Kleisli" "Control.Arrow" "base" 'True) (C1 ('MetaCons "Kleisli" 'PrefixI 'True) (S1 ('MetaSel ('Just "runKleisli") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ((FUN 'Many a :: TYPE LiftedRep -> Type) :.: Rec1 m)))

type Rep (Kleisli m a b)

Since: base-4.14.0.0

Defined in Control.Arrow

type Rep (Kleisli m a b) = D1 ('MetaData "Kleisli" "Control.Arrow" "base" 'True) (C1 ('MetaCons "Kleisli" 'PrefixI 'True) (S1 ('MetaSel ('Just "runKleisli") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a -> m b))))

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

Methods

zeroArrow :: a b c

Instances

MonadPlus m => ArrowZero (Kleisli m)

Since: base-2.1

Defined in Control.Arrow

Methods

zeroArrow :: Kleisli m b c

(ArrowZero p, ArrowZero q) => ArrowZero (Product p q)

Defined in Data.Bifunctor.Product

Methods

zeroArrow :: Product p q b c

(Applicative f, ArrowZero p) => ArrowZero (Tannen f p)

Defined in Data.Bifunctor.Tannen

Methods

zeroArrow :: Tannen f p b c

class ArrowZero a => ArrowPlus (a :: TYPE LiftedRep -> TYPE LiftedRep -> 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

Defined in Control.Arrow

Methods

(<+>) :: Kleisli m b c -> Kleisli m b c -> Kleisli m b c

(ArrowPlus p, ArrowPlus q) => ArrowPlus (Product p q)

Defined in Data.Bifunctor.Product

Methods

(<+>) :: Product p q b c -> Product p q b c -> Product p q b c

(Applicative f, ArrowPlus p) => ArrowPlus (Tannen f p)

Defined in Data.Bifunctor.Tannen

Methods

(<+>) :: Tannen f p b c -> Tannen f p b c -> Tannen f p 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

ArrowPlus a => Alternative (ArrowMonad a)

Since: base-4.6.0.0

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]

Arrow a => Applicative (ArrowMonad a)

Since: base-4.6.0.0

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

Arrow a => Functor (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b

(<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0

ArrowApply a => Monad (ArrowMonad a)

Since: base-2.1

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

(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

mzero :: ArrowMonad a a0

mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0

class Arrow a => ArrowLoop (a :: TYPE LiftedRep -> TYPE LiftedRep -> 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

Defined in Control.Arrow

Methods

loop :: Kleisli m (b, d) (c, d) -> Kleisli m b c

ArrowLoop (->)

Since: base-2.1

Defined in Control.Arrow

Methods

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

(ArrowLoop p, ArrowLoop q) => ArrowLoop (Product p q)

Defined in Data.Bifunctor.Product

Methods

loop :: Product p q (b, d) (c, d) -> Product p q b c

(Applicative f, ArrowLoop p) => ArrowLoop (Tannen f p)

Defined in Data.Bifunctor.Tannen

Methods

loop :: Tannen f p (b, d) (c, d) -> Tannen f p b c

class Arrow a => ArrowChoice (a :: TYPE LiftedRep -> TYPE LiftedRep -> 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

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

Since: base-2.1

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

(ArrowChoice p, ArrowChoice q) => ArrowChoice (Product p q)

Defined in Data.Bifunctor.Product

Methods

left :: Product p q b c -> Product p q (Either b d) (Either c d)

right :: Product p q b c -> Product p q (Either d b) (Either d c)

(+++) :: Product p q b c -> Product p q b' c' -> Product p q (Either b b') (Either c c')

(|||) :: Product p q b d -> Product p q c d -> Product p q (Either b c) d

(Applicative f, ArrowChoice p) => ArrowChoice (Tannen f p)

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 LiftedRep -> TYPE LiftedRep -> 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

Defined in Control.Arrow

Methods

app :: Kleisli m (Kleisli m b c, b) c

ArrowApply (->)

Since: base-2.1

Defined in Control.Arrow

Methods

app :: (b -> c, b) -> c

class Category a => Arrow (a :: TYPE LiftedRep -> TYPE LiftedRep -> 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

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

Since: base-2.1

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

(Arrow p, Arrow q) => Arrow (Product p q)

Defined in Data.Bifunctor.Product

Methods

arr :: (b -> c) -> Product p q b c

first :: Product p q b c -> Product p q (b, d) (c, d)

second :: Product p q b c -> Product p q (d, b) (d, c)

(***) :: Product p q b c -> Product p q b' c' -> Product p q (b, b') (c, c')

(&&&) :: Product p q b c -> Product p q b c' -> Product p q b (c, c')

(Applicative f, Arrow p) => Arrow (Tannen f p)

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

returnA :: Arrow a => a b b

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

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 => (b -> c) -> a c d -> a b d infixr 1

Precomposition with a pure function.

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

Postcomposition 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 => a c d -> (b -> c) -> a b d infixr 1

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

(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c infixr 1

Left-to-right composition

(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). 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 :: forall (m :: Type -> Type) a. 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 :: forall (m :: Type -> Type) a b. Monad m => (a -> (b, a)) -> a -> MSF m () b

Generate outputs using a step-wise 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.

iPre

Arguments

:: forall (m :: Type -> Type) a. 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 :: forall (m :: Type -> Type) a b. 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 :: 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.

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

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

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

Defined in Data.MonadicStreamFunction.InternalCore

Methods

id :: forall (a :: k). MSF m a a

(.) :: forall (b :: k) (c :: k) (a :: k). MSF m b c -> MSF m a b -> MSF m a c

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

Data UTCTime

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 :: forall r r'. (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

NFData UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

rnf :: UTCTime -> ()

Eq UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

(==) :: UTCTime -> UTCTime -> Bool

(/=) :: UTCTime -> UTCTime -> Bool

Ord UTCTime

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

TimeDomain UTCTime

Differences between UTCTimes are measured in seconds.

Defined in Data.TimeDomain

Associated Types

type Diff UTCTime

Methods

diffTime :: UTCTime -> UTCTime -> Diff UTCTime

addTime :: UTCTime -> Diff UTCTime -> UTCTime

type Diff UTCTime

Defined in Data.TimeDomain

type Diff UTCTime = Double

type family Diff time

The type of differences or durations between two timestamps

Instances

type Diff UTCTime

Defined in Data.TimeDomain

type Diff UTCTime = Double

type Diff Integer

Defined in Data.TimeDomain

type Diff Integer = Integer

type Diff ()

Defined in Data.TimeDomain

type Diff () = ()

type Diff Double

Defined in Data.TimeDomain

type Diff Double = Double

type Diff Float

Defined in Data.TimeDomain

type Diff Float = Float

type Diff (NumTimeDomain a)

Defined in Data.TimeDomain

type Diff (NumTimeDomain a) = NumTimeDomain a

class TimeDifference (Diff time) => TimeDomain time where

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

Expected laws:

• (t1 diffTime t3) difference (t1 diffTime t2) = t2 diffTime t3

• (t addTime dt) diffTime t = dt

• (t addTime dt1) addTime dt2 = t addTime (dt1 add dt2)

Associated Types

type Diff time

The type of differences or durations between two timestamps

Methods

diffTime :: time -> time -> Diff time

Compute the difference between two timestamps.

Mnemonic: diffTime behaves like the (-) operator:

diffTime earlier later = later `diffTime` earlier is the duration it takes from earlier to later.

addTime :: time -> Diff time -> time

Add a time difference to a timestamp.

Instances

TimeDomain UTCTime

Differences between UTCTimes are measured in seconds.

Defined in Data.TimeDomain

Associated Types

type Diff UTCTime

Methods

diffTime :: UTCTime -> UTCTime -> Diff UTCTime

addTime :: UTCTime -> Diff UTCTime -> UTCTime

TimeDomain Integer

Defined in Data.TimeDomain

Associated Types

type Diff Integer

Methods

diffTime :: Integer -> Integer -> Diff Integer

addTime :: Integer -> Diff Integer -> Integer

TimeDomain ()

Defined in Data.TimeDomain

Associated Types

type Diff ()

Methods

diffTime :: () -> () -> Diff ()

addTime :: () -> Diff () -> ()

TimeDomain Double

Defined in Data.TimeDomain

Associated Types

type Diff Double

Methods

diffTime :: Double -> Double -> Diff Double

addTime :: Double -> Diff Double -> Double

TimeDomain Float

Defined in Data.TimeDomain

Associated Types

type Diff Float

Methods

diffTime :: Float -> Float -> Diff Float

addTime :: Float -> Diff Float -> Float

Num a => TimeDomain (NumTimeDomain a)

Defined in Data.TimeDomain

Associated Types

type Diff (NumTimeDomain a)

Methods

diffTime :: NumTimeDomain a -> NumTimeDomain a -> Diff (NumTimeDomain a)

addTime :: NumTimeDomain a -> Diff (NumTimeDomain a) -> NumTimeDomain a

class TimeDifference d where

A type of durations, or differences betweens time stamps.

Expected laws:

• add is commutative and associative

• (dt1 difference dt2) add dt2 = dt1

Methods

difference :: d -> d -> d

Calculate the difference between two durations, compatibly with diffTime.

add :: d -> d -> d

Add two time differences.

Instances

TimeDifference Integer

Defined in Data.TimeDomain

Methods

difference :: Integer -> Integer -> Integer

add :: Integer -> Integer -> Integer

TimeDifference ()

Defined in Data.TimeDomain

Methods

difference :: () -> () -> ()

add :: () -> () -> ()

TimeDifference Double

Defined in Data.TimeDomain

Methods

difference :: Double -> Double -> Double

add :: Double -> Double -> Double

TimeDifference Float

Defined in Data.TimeDomain

Methods

difference :: Float -> Float -> Float

add :: Float -> Float -> Float

Num a => TimeDifference (NumTimeDomain a)

Defined in Data.TimeDomain

Methods

difference :: NumTimeDomain a -> NumTimeDomain a -> NumTimeDomain a

add :: NumTimeDomain a -> NumTimeDomain a -> NumTimeDomain a

newtype NumTimeDomain a

Any Num can be wrapped to form a TimeDomain.

Constructors

NumTimeDomain

Fields

• fromNumTimeDomain :: a

Instances

Num a => Num (NumTimeDomain a)

Defined in Data.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 => TimeDifference (NumTimeDomain a)

Defined in Data.TimeDomain

Methods

difference :: NumTimeDomain a -> NumTimeDomain a -> NumTimeDomain a

add :: NumTimeDomain a -> NumTimeDomain a -> NumTimeDomain a

Num a => TimeDomain (NumTimeDomain a)

Defined in Data.TimeDomain

Associated Types

type Diff (NumTimeDomain a)

Methods

diffTime :: NumTimeDomain a -> NumTimeDomain a -> Diff (NumTimeDomain a)

addTime :: NumTimeDomain a -> Diff (NumTimeDomain a) -> NumTimeDomain a

type Diff (NumTimeDomain a)

Defined in Data.TimeDomain

type Diff (NumTimeDomain a) = NumTimeDomain a