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


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

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 milliseconds
--   
--   Note that scheduling can easily get in the way of accuracy at this
--   level of granularity.
milliseconds :: Double -> NominalDiffTime

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

-- | 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
parseLooperSettings :: String -> NominalDiffTime -> NominalDiffTime -> Parser LooperSettings
mkLooperDef :: Text -> LooperSettings -> m () -> LooperDef m

-- | Like <a>runLoopers</a> but runs the loopers as background jobs.
withLoopers :: MonadUnliftIO m => [LooperDef m] -> m a -> m a

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

-- | Like <a>runLoopersIgnoreOverrun</a> but runs the loopers as background
--   jobs.
withLoopersIgnoreOverrun :: MonadUnliftIO n => (LooperDef m -> n ()) -> [LooperDef m] -> n a -> n a

-- | 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 n => (LooperDef m -> n ()) -> [LooperDef m] -> n ()

-- | Like <a>runLoopersRaw</a> but runs the loopers as background jobs.
withLoopersRaw :: forall m n a. MonadUnliftIO n => (LooperDef m -> n ()) -> (LooperDef m -> n ()) -> [LooperDef m] -> n a -> n a

-- | 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 n => (LooperDef m -> n ()) -> (LooperDef m -> n ()) -> [LooperDef m] -> n ()
runLooperDef :: MonadUnliftIO n => (LooperDef m -> n ()) -> (LooperDef m -> n ()) -> LooperDef m -> Maybe (n void)

-- | 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.LooperSettings
instance GHC.Classes.Eq Looper.LooperSettings
instance GHC.Show.Show Looper.LooperSettings