Looper

Documentation

data LooperDef m

A looper definition

Constructors

LooperDef

Fields

• looperDefName :: Text

  The name of the looper, can be useful for logging

• looperDefEnabled :: Bool

  Whether this looper is enabled

• looperDefPeriod :: NominalDiffTime

  The time between the start of each run

• looperDefPhase :: NominalDiffTime

  The time before the first run

• looperDefFunc :: m ()

  The function to run

Instances

Generic (LooperDef m)

Defined in Looper

Associated Types

type Rep (LooperDef m) :: Type -> Type

Methods

from :: LooperDef m -> Rep (LooperDef m) x

to :: Rep (LooperDef m) x -> LooperDef m

type Rep (LooperDef m)

Defined in Looper

type Rep (LooperDef m) = D1 ('MetaData "LooperDef" "Looper" "looper-0.3.0.1-3kRKxaZEpiJ19X8DpfMDXP" 'False) (C1 ('MetaCons "LooperDef" 'PrefixI 'True) ((S1 ('MetaSel ('Just "looperDefName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text) :*: S1 ('MetaSel ('Just "looperDefEnabled") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)) :*: (S1 ('MetaSel ('Just "looperDefPeriod") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NominalDiffTime) :*: (S1 ('MetaSel ('Just "looperDefPhase") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NominalDiffTime) :*: S1 ('MetaSel ('Just "looperDefFunc") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m ()))))))

milliseconds :: Double -> NominalDiffTime

Construct a NominalDiffTime from a number of milliseconds

Note that scheduling can easily get in the way of accuracy at this level of granularity.

seconds :: Double -> NominalDiffTime

Construct a NominalDiffTime from a number of seconds

minutes :: Double -> NominalDiffTime

Construct a NominalDiffTime from a number of minutes

hours :: Double -> NominalDiffTime

Construct a NominalDiffTime from a number of hours

data LooperSettings

Settings that you might want to pass into a looper using mkLooperDef

Constructors

LooperSettings

Fields

• looperSetEnabled :: Bool
• looperSetPhase :: NominalDiffTime
• looperSetPeriod :: NominalDiffTime

Instances

Generic LooperSettings

Defined in Looper

Associated Types

type Rep LooperSettings :: Type -> Type

Methods

from :: LooperSettings -> Rep LooperSettings x

to :: Rep LooperSettings x -> LooperSettings

Show LooperSettings

Defined in Looper

Methods

showsPrec :: Int -> LooperSettings -> ShowS

show :: LooperSettings -> String

showList :: [LooperSettings] -> ShowS

Eq LooperSettings

Defined in Looper

Methods

(==) :: LooperSettings -> LooperSettings -> Bool

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

type Rep LooperSettings

Defined in Looper

type Rep LooperSettings = D1 ('MetaData "LooperSettings" "Looper" "looper-0.3.0.1-3kRKxaZEpiJ19X8DpfMDXP" 'False) (C1 ('MetaCons "LooperSettings" 'PrefixI 'True) (S1 ('MetaSel ('Just "looperSetEnabled") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: (S1 ('MetaSel ('Just "looperSetPhase") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NominalDiffTime) :*: S1 ('MetaSel ('Just "looperSetPeriod") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NominalDiffTime))))

parseLooperSettings :: String -> NominalDiffTime -> NominalDiffTime -> Parser LooperSettings

mkLooperDef

Arguments

:: Text

Name

-> LooperSettings

-> m ()

The function to loop

-> LooperDef m

runLoopers :: MonadUnliftIO m => [LooperDef m] -> m ()

Simply run loopers

runLoopers = runLoopersIgnoreOverrun looperDefFunc

see runLoopersIgnoreOverrun

Note that this function will loop forever, you need to wrap it using async yourself.

runLoopersIgnoreOverrun

Arguments

:: MonadUnliftIO n

=> (LooperDef m -> n ())

Custom runner

-> [LooperDef m]

Loopers

-> n ()

Run loopers with a custom runner, ignoring any overruns

runLoopersIgnoreOverrun = runLoopersRaw (pure ())

see runLoopersRaw

Note that this function will loop forever, you need to wrap it using async yourself.

runLoopersRaw

Arguments

:: MonadUnliftIO n

=> (LooperDef m -> n ())

Overrun handler

-> (LooperDef m -> n ())

Runner

-> [LooperDef m]

Loopers

-> n ()

Run loopers, with a custom runner and overrun handler

• The overrun handler is run when the looper function takes longer than its period. You can use this to log a warning, for example.
• The runner function is used to run the looper function You can use looperDefFunc :: LooperDef m -> m () to run a LooperDef, and you can wrap this function in some custom logic before you pass it into runLoopersRaw In this manner you can add logging or metrics, for example.

Note that this function will loop forever, you need to wrap it using async yourself.

runLooperDef

Arguments

:: MonadUnliftIO n

=> (LooperDef m -> n ())

Overrun handler

-> (LooperDef m -> n ())

Runner

-> LooperDef m

Loopers

-> Maybe (n void)

waitNominalDiffTime :: MonadIO m => NominalDiffTime -> m ()

Wait for a given NominalDiffTime

This takes care of the conversion to microseconds to pass to threadDelay for you.

waitNominalDiffTime ndt = liftIO $ threadDelay $ round (toRational ndt * (1000 * 1000))