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.0.0.2-BjOKUISjKlOE4oO2B9h0mR" 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 ()))))))

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 LooperFlags

A structure to parse command-line flags for a looper into

Constructors

LooperFlags

Fields

• looperFlagEnabled :: Maybe Bool
• looperFlagPhase :: Maybe Int
• looperFlagPeriod :: Maybe Int

Instances

Eq LooperFlags

Defined in Looper

Methods

(==) :: LooperFlags -> LooperFlags -> Bool

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

Show LooperFlags

Defined in Looper

Methods

showsPrec :: Int -> LooperFlags -> ShowS

show :: LooperFlags -> String

showList :: [LooperFlags] -> ShowS

Generic LooperFlags

Defined in Looper

Associated Types

type Rep LooperFlags :: Type -> Type

Methods

from :: LooperFlags -> Rep LooperFlags x

to :: Rep LooperFlags x -> LooperFlags

type Rep LooperFlags

Defined in Looper

type Rep LooperFlags = D1 (MetaData "LooperFlags" "Looper" "looper-0.0.0.2-BjOKUISjKlOE4oO2B9h0mR" False) (C1 (MetaCons "LooperFlags" PrefixI True) (S1 (MetaSel (Just "looperFlagEnabled") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Bool)) :*: (S1 (MetaSel (Just "looperFlagPhase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Int)) :*: S1 (MetaSel (Just "looperFlagPeriod") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Int)))))

getLooperFlags

Arguments

:: String

The name of the looper (best to make this all-lowercase)

-> Parser LooperFlags

An optparse applicative parser for LooperFlags

data LooperEnvironment

A structure to parse environment variables for a looper into

Constructors

LooperEnvironment

Fields

• looperEnvEnabled :: Maybe Bool
• looperEnvPhase :: Maybe Int
• looperEnvPeriod :: Maybe Int

Instances

Eq LooperEnvironment

Defined in Looper

Methods

(==) :: LooperEnvironment -> LooperEnvironment -> Bool

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

Show LooperEnvironment

Defined in Looper

Methods

showsPrec :: Int -> LooperEnvironment -> ShowS

show :: LooperEnvironment -> String

showList :: [LooperEnvironment] -> ShowS

Generic LooperEnvironment

Defined in Looper

Associated Types

type Rep LooperEnvironment :: Type -> Type

Methods

from :: LooperEnvironment -> Rep LooperEnvironment x

to :: Rep LooperEnvironment x -> LooperEnvironment

type Rep LooperEnvironment

Defined in Looper

type Rep LooperEnvironment = D1 (MetaData "LooperEnvironment" "Looper" "looper-0.0.0.2-BjOKUISjKlOE4oO2B9h0mR" False) (C1 (MetaCons "LooperEnvironment" PrefixI True) (S1 (MetaSel (Just "looperEnvEnabled") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Bool)) :*: (S1 (MetaSel (Just "looperEnvPhase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Int)) :*: S1 (MetaSel (Just "looperEnvPeriod") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Int)))))

getLooperEnvironment

Arguments

:: String

Prefix for each variable (best to make this all-caps)

-> String

Name of the looper (best to make this all-caps too)

-> IO LooperEnvironment

Get a LooperEnvironment from the environment

readLooperEnvironment

Arguments

:: String

Prefix for each variable (best to make this all-caps)

-> String

Name of the looper (best to make this all-caps too)

-> [(String, String)]

-> LooperEnvironment

Get a LooperEnvironment from a pure environment

data LooperConfiguration

A structure to configuration for a looper into

Constructors

LooperConfiguration

Fields

• looperConfEnabled :: Maybe Bool
• looperConfPhase :: Maybe Int
• looperConfPeriod :: Maybe Int

Instances

Eq LooperConfiguration

Defined in Looper

Methods

(==) :: LooperConfiguration -> LooperConfiguration -> Bool

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

Show LooperConfiguration

Defined in Looper

Methods

showsPrec :: Int -> LooperConfiguration -> ShowS

show :: LooperConfiguration -> String

showList :: [LooperConfiguration] -> ShowS

Generic LooperConfiguration

Defined in Looper

Associated Types

type Rep LooperConfiguration :: Type -> Type

Methods

from :: LooperConfiguration -> Rep LooperConfiguration x

to :: Rep LooperConfiguration x -> LooperConfiguration

FromJSON LooperConfiguration

You can parse Data.Aeson's JSON or Data.Yaml's YAML to parse a LooperConfiguration. You can also use Data.Yaml.Config.

Defined in Looper

Methods

parseJSON :: Value -> Parser LooperConfiguration

parseJSONList :: Value -> Parser [LooperConfiguration]

type Rep LooperConfiguration

Defined in Looper

type Rep LooperConfiguration = D1 (MetaData "LooperConfiguration" "Looper" "looper-0.0.0.2-BjOKUISjKlOE4oO2B9h0mR" False) (C1 (MetaCons "LooperConfiguration" PrefixI True) (S1 (MetaSel (Just "looperConfEnabled") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Bool)) :*: (S1 (MetaSel (Just "looperConfPhase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Int)) :*: S1 (MetaSel (Just "looperConfPeriod") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Int)))))

data LooperSettings

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

Constructors

LooperSettings

Fields

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

Instances

Eq LooperSettings

Defined in Looper

Methods

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

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

Show LooperSettings

Defined in Looper

Methods

showsPrec :: Int -> LooperSettings -> ShowS

show :: LooperSettings -> String

showList :: [LooperSettings] -> ShowS

Generic LooperSettings

Defined in Looper

Associated Types

type Rep LooperSettings :: Type -> Type

Methods

from :: LooperSettings -> Rep LooperSettings x

to :: Rep LooperSettings x -> LooperSettings

type Rep LooperSettings

Defined in Looper

type Rep LooperSettings = D1 (MetaData "LooperSettings" "Looper" "looper-0.0.0.2-BjOKUISjKlOE4oO2B9h0mR" 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))))

deriveLooperSettings

Arguments

:: NominalDiffTime

Default phase

-> NominalDiffTime

Default period

-> LooperFlags

-> LooperEnvironment

-> Maybe LooperConfiguration

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

=> (LooperDef m -> m ())

Custom runner

-> [LooperDef m]

Loopers

-> m ()

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 m

=> m ()

Overrun handler

-> (LooperDef m -> m ())

Runner

-> [LooperDef m]

Loopers

-> m ()

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.

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