Control.Monad.Class.MonadTimer.SI

Type classes

class (MonadDelay m, MonadMonotonicTime m) => MonadDelay m where

Methods

threadDelay :: DiffTime -> m ()

Instances

MonadDelay IO

Thread delay. This implementation will not over- or underflow.

For delay larger than what Int can represent (see diffTimeToMicrosecondsAsInt), it will recursively call threadDelay.

For delays smaller than `minBound :: Int` seconds, `minBound :: Int` will be used instead.

Defined in Control.Monad.Class.MonadTimer.SI

Methods

threadDelay :: DiffTime -> IO ()

MonadDelay m => MonadDelay (ReaderT r m)

Defined in Control.Monad.Class.MonadTimer.SI

Methods

threadDelay :: DiffTime -> ReaderT r m ()

class (MonadTimer m, MonadMonotonicTime m) => MonadTimer m where

Methods

registerDelay :: DiffTime -> m (TVar m Bool)

A register delay function which safe on 32-bit systems.

registerDelayCancellable :: DiffTime -> m (STM m TimeoutState, m ())

A cancellable register delay which is safe on 32-bit systems and efficient for delays smaller than what Int can represent (especially on systems which support native timer manager).

timeout :: DiffTime -> m a -> m (Maybe a)

A timeout function.

TODO: IO instance is not safe on 32-bit systems.

Instances

MonadTimer IO

Like registerDelay but safe on 32-bit systems. When the delay is larger than what Int can represent it will fork a thread which will write to the returned TVar once the delay has passed. When the delay is small enough it will use the MonadTimer's registerDelay (e.g. for IO monad it will use the GHC's registerDelay).

TODO: timeout not safe on 32-bit systems.

Defined in Control.Monad.Class.MonadTimer.SI

Methods

registerDelay :: DiffTime -> IO (TVar IO Bool)

registerDelayCancellable :: DiffTime -> IO (STM IO TimeoutState, IO ())

timeout :: DiffTime -> IO a -> IO (Maybe a)

MonadTimer m => MonadTimer (ReaderT r m)

Defined in Control.Monad.Class.MonadTimer.SI

Methods

registerDelay :: DiffTime -> ReaderT r m (TVar (ReaderT r m) Bool)

registerDelayCancellable :: DiffTime -> ReaderT r m (STM (ReaderT r m) TimeoutState, ReaderT r m ())

timeout :: DiffTime -> ReaderT r m a -> ReaderT r m (Maybe a)

Auxiliary functions

diffTimeToMicrosecondsAsInt :: DiffTime -> Int

Convert DiffTime in seconds to microseconds represented by an Int.

Note that on 32bit systems it can only represent `2^31-1` seconds, which is only ~35 minutes.

It doesn't prevent under- or overflows; when assertions are on it will thrown an assertion exception.

microsecondsAsIntToDiffTime :: Int -> DiffTime

Convert time in microseconds in DiffTime (measured in seconds).

Re-exports

data DiffTime

This is a length of time, as measured by a clock. Conversion functions such as fromInteger and realToFrac will treat it as seconds. For example, (0.010 :: DiffTime) corresponds to 10 milliseconds.

It has a precision of one picosecond (= 10^-12 s). Enumeration functions will treat it as picoseconds.

Instances

Data DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DiffTime -> c DiffTime

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DiffTime

toConstr :: DiffTime -> Constr

dataTypeOf :: DiffTime -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DiffTime)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DiffTime)

gmapT :: (forall b. Data b => b -> b) -> DiffTime -> DiffTime

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r

gmapQ :: (forall d. Data d => d -> u) -> DiffTime -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DiffTime -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime

Enum DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

succ :: DiffTime -> DiffTime

pred :: DiffTime -> DiffTime

toEnum :: Int -> DiffTime

fromEnum :: DiffTime -> Int

enumFrom :: DiffTime -> [DiffTime]

enumFromThen :: DiffTime -> DiffTime -> [DiffTime]

enumFromTo :: DiffTime -> DiffTime -> [DiffTime]

enumFromThenTo :: DiffTime -> DiffTime -> DiffTime -> [DiffTime]

Num DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

(+) :: DiffTime -> DiffTime -> DiffTime

(-) :: DiffTime -> DiffTime -> DiffTime

(*) :: DiffTime -> DiffTime -> DiffTime

negate :: DiffTime -> DiffTime

abs :: DiffTime -> DiffTime

signum :: DiffTime -> DiffTime

fromInteger :: Integer -> DiffTime

Read DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

readsPrec :: Int -> ReadS DiffTime

readList :: ReadS [DiffTime]

readPrec :: ReadPrec DiffTime

readListPrec :: ReadPrec [DiffTime]

Fractional DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

(/) :: DiffTime -> DiffTime -> DiffTime

recip :: DiffTime -> DiffTime

fromRational :: Rational -> DiffTime

Real DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

toRational :: DiffTime -> Rational

RealFrac DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

properFraction :: Integral b => DiffTime -> (b, DiffTime)

truncate :: Integral b => DiffTime -> b

round :: Integral b => DiffTime -> b

ceiling :: Integral b => DiffTime -> b

floor :: Integral b => DiffTime -> b

Show DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

showsPrec :: Int -> DiffTime -> ShowS

show :: DiffTime -> String

showList :: [DiffTime] -> ShowS

NFData DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

rnf :: DiffTime -> ()

Eq DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

(==) :: DiffTime -> DiffTime -> Bool

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

Ord DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

compare :: DiffTime -> DiffTime -> Ordering

(<) :: DiffTime -> DiffTime -> Bool

(<=) :: DiffTime -> DiffTime -> Bool

(>) :: DiffTime -> DiffTime -> Bool

(>=) :: DiffTime -> DiffTime -> Bool

max :: DiffTime -> DiffTime -> DiffTime

min :: DiffTime -> DiffTime -> DiffTime

NoThunks DiffTime

Defined in NoThunks.Class

Methods

noThunks :: Context -> DiffTime -> IO (Maybe ThunkInfo)

wNoThunks :: Context -> DiffTime -> IO (Maybe ThunkInfo)

showTypeOf :: Proxy DiffTime -> String

class MonadThread m => MonadFork (m :: Type -> Type)

Minimal complete definition

forkIO, forkOn, forkIOWithUnmask, forkFinally, throwTo, yield

Instances

MonadFork IO

Defined in Control.Monad.Class.MonadFork

Methods

forkIO :: IO () -> IO (ThreadId IO)

forkOn :: Int -> IO () -> IO (ThreadId IO)

forkIOWithUnmask :: ((forall a. IO a -> IO a) -> IO ()) -> IO (ThreadId IO)

forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO (ThreadId IO)

throwTo :: Exception e => ThreadId IO -> e -> IO ()

killThread :: ThreadId IO -> IO ()

yield :: IO ()

MonadFork m => MonadFork (ReaderT e m)

Defined in Control.Monad.Class.MonadFork

Methods

forkIO :: ReaderT e m () -> ReaderT e m (ThreadId (ReaderT e m))

forkOn :: Int -> ReaderT e m () -> ReaderT e m (ThreadId (ReaderT e m))

forkIOWithUnmask :: ((forall a. ReaderT e m a -> ReaderT e m a) -> ReaderT e m ()) -> ReaderT e m (ThreadId (ReaderT e m))

forkFinally :: ReaderT e m a -> (Either SomeException a -> ReaderT e m ()) -> ReaderT e m (ThreadId (ReaderT e m))

throwTo :: Exception e0 => ThreadId (ReaderT e m) -> e0 -> ReaderT e m ()

killThread :: ThreadId (ReaderT e m) -> ReaderT e m ()

yield :: ReaderT e m ()

class MonadMonotonicTimeNSec m => MonadMonotonicTime m

Instances

MonadMonotonicTime IO

Defined in Control.Monad.Class.MonadTime.SI

Methods

getMonotonicTime :: IO Time

MonadMonotonicTime m => MonadMonotonicTime (ReaderT r m)

Defined in Control.Monad.Class.MonadTime.SI

Methods

getMonotonicTime :: ReaderT r m Time

class Monad m => MonadTime (m :: Type -> Type)

Minimal complete definition

getCurrentTime

Instances

MonadTime IO

Defined in Control.Monad.Class.MonadTime

Methods

getCurrentTime :: IO UTCTime

MonadTime m => MonadTime (ReaderT r m)

Defined in Control.Monad.Class.MonadTime

Methods

getCurrentTime :: ReaderT r m UTCTime

data TimeoutState

State of a timeout: pending, fired or cancelled.

Constructors

TimeoutPending

TimeoutFired

TimeoutCancelled

Instances

Show TimeoutState

Defined in Control.Monad.Class.MonadTimer.NonStandard

Methods

showsPrec :: Int -> TimeoutState -> ShowS

show :: TimeoutState -> String

showList :: [TimeoutState] -> ShowS

Eq TimeoutState

Defined in Control.Monad.Class.MonadTimer.NonStandard

Methods

(==) :: TimeoutState -> TimeoutState -> Bool

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

Ord TimeoutState

Defined in Control.Monad.Class.MonadTimer.NonStandard

Methods

compare :: TimeoutState -> TimeoutState -> Ordering

(<) :: TimeoutState -> TimeoutState -> Bool

(<=) :: TimeoutState -> TimeoutState -> Bool

(>) :: TimeoutState -> TimeoutState -> Bool

(>=) :: TimeoutState -> TimeoutState -> Bool

max :: TimeoutState -> TimeoutState -> TimeoutState

min :: TimeoutState -> TimeoutState -> TimeoutState

Default implementations

defaultRegisterDelay :: forall m timeout. (MonadFork m, MonadMonotonicTime m, MonadSTM m) => NewTimeout m timeout -> AwaitTimeout m timeout -> DiffTime -> m (TVar m Bool)

A default implementation of registerDelay which supports delays longer then Int; this is especially important on 32-bit systems where maximum delay expressed in microseconds is around 35 minutes.

defaultRegisterDelayCancellable :: forall m timeout. (MonadFork m, MonadMonotonicTime m, MonadSTM m) => NewTimeout m timeout -> ReadTimeout m timeout -> CancelTimeout m timeout -> AwaitTimeout m timeout -> DiffTime -> m (STM m TimeoutState, m ())

A cancellable register delay which is safe on 32-bit systems and efficient for delays smaller than what Int can represent (especially on systems which support native timer manager).