-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Configure and run recurring jobs indefinitely
@package looper
@version 0.2.0.1

module Looper

-- | A looper definition
data LooperDef m
LooperDef :: Text -> Bool -> NominalDiffTime -> NominalDiffTime -> m () -> LooperDef m

-- | The name of the looper, can be useful for logging
[looperDefName] :: LooperDef m -> Text

-- | Whether this looper is enabled
[looperDefEnabled] :: LooperDef m -> Bool

-- | The time between the start of each run
[looperDefPeriod] :: LooperDef m -> NominalDiffTime

-- | The time before the first run
[looperDefPhase] :: LooperDef m -> NominalDiffTime

-- | The function to run
[looperDefFunc] :: LooperDef m -> m ()

-- | Construct a <a>NominalDiffTime</a> from a number of seconds
seconds :: Double -> NominalDiffTime

-- | Construct a <a>NominalDiffTime</a> from a number of minutes
minutes :: Double -> NominalDiffTime

-- | Construct a <a>NominalDiffTime</a> from a number of hours
hours :: Double -> NominalDiffTime

-- | A structure to parse command-line flags for a looper into
data LooperFlags
LooperFlags :: Maybe Bool -> Maybe Word -> Maybe Word -> LooperFlags
[looperFlagEnabled] :: LooperFlags -> Maybe Bool
[looperFlagPhase] :: LooperFlags -> Maybe Word
[looperFlagPeriod] :: LooperFlags -> Maybe Word

-- | An optparse applicative parser for <a>LooperFlags</a>
getLooperFlags :: String -> Parser LooperFlags

-- | A structure to parse environment variables for a looper into
data LooperEnvironment
LooperEnvironment :: Maybe Bool -> Maybe Word -> Maybe Word -> LooperEnvironment
[looperEnvEnabled] :: LooperEnvironment -> Maybe Bool
[looperEnvPhase] :: LooperEnvironment -> Maybe Word
[looperEnvPeriod] :: LooperEnvironment -> Maybe Word

-- | Get a <a>LooperEnvironment</a> from the environment
getLooperEnvironment :: String -> String -> IO LooperEnvironment

-- | Get a <a>LooperEnvironment</a> from a pure environment
readLooperEnvironment :: String -> String -> [(String, String)] -> LooperEnvironment

-- | An <tt>envparse</tt> parser for a <a>LooperEnvironment</a>
looperEnvironmentParser :: String -> Parser Error LooperEnvironment

-- | A structure to configuration for a looper into
data LooperConfiguration
LooperConfiguration :: Maybe Bool -> Maybe Word -> Maybe Word -> LooperConfiguration
[looperConfEnabled] :: LooperConfiguration -> Maybe Bool
[looperConfPhase] :: LooperConfiguration -> Maybe Word
[looperConfPeriod] :: LooperConfiguration -> Maybe Word

-- | Settings that you might want to pass into a looper using
--   <a>mkLooperDef</a>
data LooperSettings
LooperSettings :: Bool -> NominalDiffTime -> NominalDiffTime -> LooperSettings
[looperSetEnabled] :: LooperSettings -> Bool
[looperSetPhase] :: LooperSettings -> NominalDiffTime
[looperSetPeriod] :: LooperSettings -> NominalDiffTime
deriveLooperSettings :: NominalDiffTime -> NominalDiffTime -> LooperFlags -> LooperEnvironment -> Maybe LooperConfiguration -> LooperSettings
mkLooperDef :: Text -> LooperSettings -> m () -> LooperDef m

-- | Simply run loopers
--   
--   <pre>
--   runLoopers = runLoopersIgnoreOverrun looperDefFunc
--   </pre>
--   
--   see <a>runLoopersIgnoreOverrun</a>
--   
--   Note that this function will loop forever, you need to wrap it using
--   <a>async</a> yourself.
runLoopers :: MonadUnliftIO m => [LooperDef m] -> m ()

-- | Run loopers with a custom runner, ignoring any overruns
--   
--   <pre>
--   runLoopersIgnoreOverrun = runLoopersRaw (pure ())
--   </pre>
--   
--   see <a>runLoopersRaw</a>
--   
--   Note that this function will loop forever, you need to wrap it using
--   <a>async</a> yourself.
runLoopersIgnoreOverrun :: (MonadUnliftIO m, MonadUnliftIO n) => (LooperDef m -> n ()) -> [LooperDef m] -> n ()

-- | Run loopers, with a custom runner and overrun handler
--   
--   <ul>
--   <li>The overrun handler is run when the looper function takes longer
--   than its period. You can use this to log a warning, for example.</li>
--   <li>The runner function is used to run the looper function You can use
--   <a>looperDefFunc</a> <tt> :: LooperDef m -&gt; m ()</tt> to run a
--   <a>LooperDef</a>, and you can wrap this function in some custom logic
--   before you pass it into <a>runLoopersRaw</a> In this manner you can
--   add logging or metrics, for example.</li>
--   </ul>
--   
--   Note that this function will loop forever, you need to wrap it using
--   <a>async</a> yourself.
runLoopersRaw :: (MonadUnliftIO m, MonadUnliftIO n) => (LooperDef m -> n ()) -> (LooperDef m -> n ()) -> [LooperDef m] -> n ()

-- | Wait for a given <a>NominalDiffTime</a>
--   
--   This takes care of the conversion to microseconds to pass to
--   <a>threadDelay</a> for you.
--   
--   <pre>
--   waitNominalDiffTime ndt = liftIO $ threadDelay $ round (toRational ndt * (1000 * 1000))
--   </pre>
waitNominalDiffTime :: MonadIO m => NominalDiffTime -> m ()
instance GHC.Generics.Generic (Looper.LooperDef m)
instance GHC.Generics.Generic Looper.LooperFlags
instance GHC.Classes.Eq Looper.LooperFlags
instance GHC.Show.Show Looper.LooperFlags
instance GHC.Generics.Generic Looper.LooperEnvironment
instance GHC.Classes.Eq Looper.LooperEnvironment
instance GHC.Show.Show Looper.LooperEnvironment
instance Data.Aeson.Types.ToJSON.ToJSON Looper.LooperConfiguration
instance Data.Aeson.Types.FromJSON.FromJSON Looper.LooperConfiguration
instance GHC.Generics.Generic Looper.LooperConfiguration
instance GHC.Classes.Eq Looper.LooperConfiguration
instance GHC.Show.Show Looper.LooperConfiguration
instance GHC.Generics.Generic Looper.LooperSettings
instance GHC.Classes.Eq Looper.LooperSettings
instance GHC.Show.Show Looper.LooperSettings
instance Autodocodec.Class.HasCodec Looper.LooperConfiguration