Control.TimeWarp.Timed.MonadTimed

This module defines typeclass MonadTimed with basic functions to manipulate time and threads.

Typeclass with basic functions

class MonadThrow m => MonadTimed m where

Allows time management. Time is specified in microseconds passed from launch point (origin), this time is further called virtual time.

Instance of MonadTimed should satisfy the following law:

• when defining instance of MonadTrans for a monad, information stored inside the transformer should be tied to thread, and get cloned on forks.

For example, instance MonadTimed m => MonadTimed (StateT s m) is declared such that:

example :: (MonadTimed m, MonadIO m) => StateT Int m ()
example = do
    put 1
    fork $ put 10     -- main thread won't be touched
    wait $ for 1 sec  -- wait for forked thread to execute
    liftIO . print =<< get

>>> runTimedT $ runStateT undefined example
1

When implement instance of this typeclass, don't forget to define ThreadId first.

Minimal complete definition

virtualTime, currentTime, wait, fork, myThreadId, throwTo, timeout, forkSlave

Methods

virtualTime :: m Microsecond

Acquires virtual time.

currentTime :: m Microsecond

Acquires (pseudo-)real time.

wait :: RelativeToNow -> m ()

Waits for specified amount of time.

Use for to specify relative virtual time (counting from now), and till for absolute one.

>>> runTimedT $ wait (for 1 sec) >> wait (for 5 sec) >> timestamp "now"
[6000000µs] now
>>> runTimedT $ wait (for 1 sec) >> wait (till 5 sec) >> timestamp "now"
[5000000µs] now
>>> runTimedT $ wait (for 10 minute 34 sec 52 ms) >> timestamp "now"
[634052000µs] now

fork :: m () -> m (ThreadId m)

Creates another thread of execution, with same point of origin.

myThreadId :: m (ThreadId m)

Acquires current thread id.

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

Arises specified exception in specified thread.

timeout :: TimeUnit t => t -> m a -> m a

Throws a MTTimeoutError exception if running action exceeds specified time.

forkSlave :: m () -> m (ThreadId m)

From `slave-thread` library.

Instances

MonadTimed TimedIO

Methods

virtualTime :: TimedIO Microsecond

currentTime :: TimedIO Microsecond

wait :: RelativeToNow -> TimedIO ()

fork :: TimedIO () -> TimedIO (ThreadId TimedIO)

myThreadId :: TimedIO (ThreadId TimedIO)

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

timeout :: TimeUnit t => t -> TimedIO a -> TimedIO a

forkSlave :: TimedIO () -> TimedIO (ThreadId TimedIO)

MonadTimed m => MonadTimed (LoggerNameBox m)

Methods

virtualTime :: LoggerNameBox m Microsecond

currentTime :: LoggerNameBox m Microsecond

wait :: RelativeToNow -> LoggerNameBox m ()

fork :: LoggerNameBox m () -> LoggerNameBox m (ThreadId (LoggerNameBox m))

myThreadId :: LoggerNameBox m (ThreadId (LoggerNameBox m))

throwTo :: Exception e => ThreadId (LoggerNameBox m) -> e -> LoggerNameBox m ()

timeout :: TimeUnit t => t -> LoggerNameBox m a -> LoggerNameBox m a

forkSlave :: LoggerNameBox m () -> LoggerNameBox m (ThreadId (LoggerNameBox m))

(CanLog m, MonadIO m, MonadThrow m, MonadCatch m) => MonadTimed (TimedT m)

Methods

virtualTime :: TimedT m Microsecond

currentTime :: TimedT m Microsecond

wait :: RelativeToNow -> TimedT m ()

fork :: TimedT m () -> TimedT m (ThreadId (TimedT m))

myThreadId :: TimedT m (ThreadId (TimedT m))

throwTo :: Exception e => ThreadId (TimedT m) -> e -> TimedT m ()

timeout :: TimeUnit t => t -> TimedT m a -> TimedT m a

forkSlave :: TimedT m () -> TimedT m (ThreadId (TimedT m))

MonadTimed (Transfer s)

Methods

virtualTime :: Transfer s Microsecond

currentTime :: Transfer s Microsecond

wait :: RelativeToNow -> Transfer s ()

fork :: Transfer s () -> Transfer s (ThreadId (Transfer s))

myThreadId :: Transfer s (ThreadId (Transfer s))

throwTo :: Exception e => ThreadId (Transfer s) -> e -> Transfer s ()

timeout :: TimeUnit t => t -> Transfer s a -> Transfer s a

forkSlave :: Transfer s () -> Transfer s (ThreadId (Transfer s))

MonadTimed m => MonadTimed (StateT s m)

Methods

virtualTime :: StateT s m Microsecond

currentTime :: StateT s m Microsecond

wait :: RelativeToNow -> StateT s m ()

fork :: StateT s m () -> StateT s m (ThreadId (StateT s m))

myThreadId :: StateT s m (ThreadId (StateT s m))

throwTo :: Exception e => ThreadId (StateT s m) -> e -> StateT s m ()

timeout :: TimeUnit t => t -> StateT s m a -> StateT s m a

forkSlave :: StateT s m () -> StateT s m (ThreadId (StateT s m))

MonadTimed m => MonadTimed (ResponseT s m)

Methods

virtualTime :: ResponseT s m Microsecond

currentTime :: ResponseT s m Microsecond

wait :: RelativeToNow -> ResponseT s m ()

fork :: ResponseT s m () -> ResponseT s m (ThreadId (ResponseT s m))

myThreadId :: ResponseT s m (ThreadId (ResponseT s m))

throwTo :: Exception e => ThreadId (ResponseT s m) -> e -> ResponseT s m ()

timeout :: TimeUnit t => t -> ResponseT s m a -> ResponseT s m a

forkSlave :: ResponseT s m () -> ResponseT s m (ThreadId (ResponseT s m))

MonadTimed m => MonadTimed (Dialog p m)

Methods

virtualTime :: Dialog p m Microsecond

currentTime :: Dialog p m Microsecond

wait :: RelativeToNow -> Dialog p m ()

fork :: Dialog p m () -> Dialog p m (ThreadId (Dialog p m))

myThreadId :: Dialog p m (ThreadId (Dialog p m))

throwTo :: Exception e => ThreadId (Dialog p m) -> e -> Dialog p m ()

timeout :: TimeUnit t => t -> Dialog p m a -> Dialog p m a

forkSlave :: Dialog p m () -> Dialog p m (ThreadId (Dialog p m))

MonadTimed m => MonadTimed (ReaderT * r m)

Methods

virtualTime :: ReaderT * r m Microsecond

currentTime :: ReaderT * r m Microsecond

wait :: RelativeToNow -> ReaderT * r m ()

fork :: ReaderT * r m () -> ReaderT * r m (ThreadId (ReaderT * r m))

myThreadId :: ReaderT * r m (ThreadId (ReaderT * r m))

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

timeout :: TimeUnit t => t -> ReaderT * r m a -> ReaderT * r m a

forkSlave :: ReaderT * r m () -> ReaderT * r m (ThreadId (ReaderT * r m))

type family ThreadId (m :: * -> *) :: *

Type of thread identifier.

Instances

type ThreadId TimedIO

type ThreadId TimedIO = ThreadId

type ThreadId (LoggerNameBox m)

type ThreadId (LoggerNameBox m) = ThreadId m

type ThreadId (TimedT m)

type ThreadId (TimedT m) = PureThreadId

type ThreadId (Transfer s)

type ThreadId (Transfer s) = ThreadId

type ThreadId (StateT s m)

type ThreadId (StateT s m) = ThreadId m

type ThreadId (ResponseT s m)

type ThreadId (ResponseT s m) = ThreadId m

type ThreadId (Dialog p m)

type ThreadId (Dialog p m) = ThreadId m

type ThreadId (ReaderT * r m)

type ThreadId (ReaderT * r m) = ThreadId m

type RelativeToNow = Microsecond -> Microsecond

Defines some time point basing on current virtual time.

Helper functions

schedule :: MonadTimed m => RelativeToNow -> m () -> m ()

Executes an action somewhere in future in another thread. Use after to specify relative virtual time (counting from now), and at for absolute one.

schedule time action ≡ fork_ $ wait time >> action

example :: (MonadTimed m, MonadIO m) => m ()
example = do
    wait (for 10 sec)
    schedule (after 3 sec) $ timestamp "This would happen at 13 sec"
    schedule (at 15 sec)   $ timestamp "This would happen at 15 sec"
    timestamp "And this happens immediately after start"

invoke :: MonadTimed m => RelativeToNow -> m a -> m a

Executes an action at specified time in current thread. Use after to specify relative virtual time (counting from now), and at for absolute one.

invoke time action ≡ wait time >> action

example :: (MonadTimed m, MonadIO m) => m ()
example = do
    wait (for 10 sec)
    invoke (after 3 sec) $ timestamp "This would happen at 13 sec"
    invoke (after 3 sec) $ timestamp "This would happen at 16 sec"
    invoke (at 20 sec)   $ timestamp "This would happen at 20 sec"
    timestamp "This also happens at 20 sec"

timestamp :: (MonadTimed m, MonadIO m) => String -> m ()

Prints current virtual time. For debug purposes.

>>> runTimedT $ wait (for 1 mcs) >> timestamp "Look current time here"
[1µs] Look current time here

fork_ :: MonadTimed m => m () -> m ()

Similar to fork, but doesn't return a result.

work :: MonadTimed m => RelativeToNow -> m () -> m ()

Creates a thread, which works for specified amount of time, and then gets killThreaded. Use for to specify relative virtual time (counting from now), and till for absolute one.

killThread :: MonadTimed m => ThreadId m -> m ()

Arises ThreadKilled exception in specified thread

startTimer :: MonadTimed m => m (m Microsecond)

Counts time since outer monad layer was unwrapped.

example :: (MonadTimed m, MonadIO m) => m ()
example = do
    wait (for 10 sec)
    timer <- startTimer
    wait (for 5 ms)
    passedTime <- timer
    liftIO . print $ passedTime

>>> runTimedT example
5000µs

Time measures

hour :: Int -> Microsecond

Converts a specified time to Microsecond.

minute :: Int -> Microsecond

Converts a specified time to Microsecond.

sec :: Int -> Microsecond

Converts a specified time to Microsecond.

ms :: Int -> Microsecond

Converts a specified time to Microsecond.

mcs :: Int -> Microsecond

Converts a specified time to Microsecond.

hour' :: Double -> Microsecond

Converts a specified fractional time to Microsecond.

minute' :: Double -> Microsecond

Converts a specified fractional time to Microsecond.

sec' :: Double -> Microsecond

Converts a specified fractional time to Microsecond.

ms' :: Double -> Microsecond

Converts a specified fractional time to Microsecond.

mcs' :: Double -> Microsecond

Converts a specified fractional time to Microsecond.

Time specifiers

Following functions are used together with time-controlling functions (wait, invoke and others) and serve for two reasons:

1. Defines, whether time is counted from origin point or current time point.
2. Allow different ways to specify time (see Time accumulators)

for :: TimeAccR t => t

Defines RelativeToNow, which refers to time point in specified time after current time point. Supposed to be used with wait and work.

after :: TimeAccR t => t

Synonym to for. Supposed to be used with invoke and schedule.

till :: TimeAccR t => t

Defines RelativeToNow, which refers to time point determined by specified virtual time. Supposed to be used with wait and work.

at :: TimeAccR t => t

Synonym to till. Supposed to be used with invoke and schedule.

now :: RelativeToNow

Refers to current time point.

>>> runTimedT $ invoke now $ timestamp ""
[0µs]

interval :: TimeAccM t => t

Returns a time in microseconds.

>>> print $ interval 1 sec
1000000µs

timepoint :: TimeAccM t => t

Synonym to interval. May be more preferable in some situations.

Time types

Re-export of Data.Time.Units.Microsecond

data Microsecond :: *

Instances

Enum Microsecond

Methods

succ :: Microsecond -> Microsecond

pred :: Microsecond -> Microsecond

toEnum :: Int -> Microsecond

fromEnum :: Microsecond -> Int

enumFrom :: Microsecond -> [Microsecond]

enumFromThen :: Microsecond -> Microsecond -> [Microsecond]

enumFromTo :: Microsecond -> Microsecond -> [Microsecond]

enumFromThenTo :: Microsecond -> Microsecond -> Microsecond -> [Microsecond]

Eq Microsecond

Methods

(==) :: Microsecond -> Microsecond -> Bool

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

Integral Microsecond

Methods

quot :: Microsecond -> Microsecond -> Microsecond

rem :: Microsecond -> Microsecond -> Microsecond

div :: Microsecond -> Microsecond -> Microsecond

mod :: Microsecond -> Microsecond -> Microsecond

quotRem :: Microsecond -> Microsecond -> (Microsecond, Microsecond)

divMod :: Microsecond -> Microsecond -> (Microsecond, Microsecond)

toInteger :: Microsecond -> Integer

Data Microsecond

Methods

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

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

toConstr :: Microsecond -> Constr

dataTypeOf :: Microsecond -> DataType

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

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

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

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

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

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

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

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

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

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

Num Microsecond

Methods

(+) :: Microsecond -> Microsecond -> Microsecond

(-) :: Microsecond -> Microsecond -> Microsecond

(*) :: Microsecond -> Microsecond -> Microsecond

negate :: Microsecond -> Microsecond

abs :: Microsecond -> Microsecond

signum :: Microsecond -> Microsecond

fromInteger :: Integer -> Microsecond

Ord Microsecond

Methods

compare :: Microsecond -> Microsecond -> Ordering

(<) :: Microsecond -> Microsecond -> Bool

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

(>) :: Microsecond -> Microsecond -> Bool

(>=) :: Microsecond -> Microsecond -> Bool

max :: Microsecond -> Microsecond -> Microsecond

min :: Microsecond -> Microsecond -> Microsecond

Read Microsecond

Methods

readsPrec :: Int -> ReadS Microsecond

readList :: ReadS [Microsecond]

readPrec :: ReadPrec Microsecond

readListPrec :: ReadPrec [Microsecond]

Real Microsecond

Methods

toRational :: Microsecond -> Rational

Show Microsecond

Methods

showsPrec :: Int -> Microsecond -> ShowS

show :: Microsecond -> String

showList :: [Microsecond] -> ShowS

Ix Microsecond

Methods

range :: (Microsecond, Microsecond) -> [Microsecond]

index :: (Microsecond, Microsecond) -> Microsecond -> Int

unsafeIndex :: (Microsecond, Microsecond) -> Microsecond -> Int

inRange :: (Microsecond, Microsecond) -> Microsecond -> Bool

rangeSize :: (Microsecond, Microsecond) -> Int

unsafeRangeSize :: (Microsecond, Microsecond) -> Int

TimeUnit Microsecond

Methods

toMicroseconds :: Microsecond -> Integer

fromMicroseconds :: Integer -> Microsecond

TimeAccM Microsecond

Methods

interval' :: Microsecond -> Microsecond

TimeAccR RelativeToNow

Methods

till' :: Microsecond -> RelativeToNow

for' :: Microsecond -> RelativeToNow

((~) * a b, TimeAccM t) => TimeAccM (a -> (b -> Microsecond) -> t)

Methods

interval' :: Microsecond -> a -> (b -> Microsecond) -> t

TimeUnit t => TimeAccR (t -> RelativeToNow)

Methods

till' :: Microsecond -> t -> RelativeToNow

for' :: Microsecond -> t -> RelativeToNow

((~) * a b, TimeAccR t) => TimeAccR (a -> (b -> Microsecond) -> t)

Methods

till' :: Microsecond -> a -> (b -> Microsecond) -> t

for' :: Microsecond -> a -> (b -> Microsecond) -> t

Re-export of Data.Time.Units.Millisecond

data Millisecond :: *

Instances

Enum Millisecond

Methods

succ :: Millisecond -> Millisecond

pred :: Millisecond -> Millisecond

toEnum :: Int -> Millisecond

fromEnum :: Millisecond -> Int

enumFrom :: Millisecond -> [Millisecond]

enumFromThen :: Millisecond -> Millisecond -> [Millisecond]

enumFromTo :: Millisecond -> Millisecond -> [Millisecond]

enumFromThenTo :: Millisecond -> Millisecond -> Millisecond -> [Millisecond]

Eq Millisecond

Methods

(==) :: Millisecond -> Millisecond -> Bool

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

Integral Millisecond

Methods

quot :: Millisecond -> Millisecond -> Millisecond

rem :: Millisecond -> Millisecond -> Millisecond

div :: Millisecond -> Millisecond -> Millisecond

mod :: Millisecond -> Millisecond -> Millisecond

quotRem :: Millisecond -> Millisecond -> (Millisecond, Millisecond)

divMod :: Millisecond -> Millisecond -> (Millisecond, Millisecond)

toInteger :: Millisecond -> Integer

Data Millisecond

Methods

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

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

toConstr :: Millisecond -> Constr

dataTypeOf :: Millisecond -> DataType

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

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

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

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

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

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

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

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

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

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

Num Millisecond

Methods

(+) :: Millisecond -> Millisecond -> Millisecond

(-) :: Millisecond -> Millisecond -> Millisecond

(*) :: Millisecond -> Millisecond -> Millisecond

negate :: Millisecond -> Millisecond

abs :: Millisecond -> Millisecond

signum :: Millisecond -> Millisecond

fromInteger :: Integer -> Millisecond

Ord Millisecond

Methods

compare :: Millisecond -> Millisecond -> Ordering

(<) :: Millisecond -> Millisecond -> Bool

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

(>) :: Millisecond -> Millisecond -> Bool

(>=) :: Millisecond -> Millisecond -> Bool

max :: Millisecond -> Millisecond -> Millisecond

min :: Millisecond -> Millisecond -> Millisecond

Read Millisecond

Methods

readsPrec :: Int -> ReadS Millisecond

readList :: ReadS [Millisecond]

readPrec :: ReadPrec Millisecond

readListPrec :: ReadPrec [Millisecond]

Real Millisecond

Methods

toRational :: Millisecond -> Rational

Show Millisecond

Methods

showsPrec :: Int -> Millisecond -> ShowS

show :: Millisecond -> String

showList :: [Millisecond] -> ShowS

Ix Millisecond

Methods

range :: (Millisecond, Millisecond) -> [Millisecond]

index :: (Millisecond, Millisecond) -> Millisecond -> Int

unsafeIndex :: (Millisecond, Millisecond) -> Millisecond -> Int

inRange :: (Millisecond, Millisecond) -> Millisecond -> Bool

rangeSize :: (Millisecond, Millisecond) -> Int

unsafeRangeSize :: (Millisecond, Millisecond) -> Int

TimeUnit Millisecond

Methods

toMicroseconds :: Millisecond -> Integer

fromMicroseconds :: Integer -> Millisecond

Re-export of Data.Time.Units.Second

data Second :: *

Instances

Enum Second

Methods

succ :: Second -> Second

pred :: Second -> Second

toEnum :: Int -> Second

fromEnum :: Second -> Int

enumFrom :: Second -> [Second]

enumFromThen :: Second -> Second -> [Second]

enumFromTo :: Second -> Second -> [Second]

enumFromThenTo :: Second -> Second -> Second -> [Second]

Eq Second

Methods

(==) :: Second -> Second -> Bool

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

Integral Second

Methods

quot :: Second -> Second -> Second

rem :: Second -> Second -> Second

div :: Second -> Second -> Second

mod :: Second -> Second -> Second

quotRem :: Second -> Second -> (Second, Second)

divMod :: Second -> Second -> (Second, Second)

toInteger :: Second -> Integer

Data Second

Methods

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

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

toConstr :: Second -> Constr

dataTypeOf :: Second -> DataType

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

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

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

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

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

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

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

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

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

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

Num Second

Methods

(+) :: Second -> Second -> Second

(-) :: Second -> Second -> Second

(*) :: Second -> Second -> Second

negate :: Second -> Second

abs :: Second -> Second

signum :: Second -> Second

fromInteger :: Integer -> Second

Ord Second

Methods

compare :: Second -> Second -> Ordering

(<) :: Second -> Second -> Bool

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

(>) :: Second -> Second -> Bool

(>=) :: Second -> Second -> Bool

max :: Second -> Second -> Second

min :: Second -> Second -> Second

Read Second

Methods

readsPrec :: Int -> ReadS Second

readList :: ReadS [Second]

readPrec :: ReadPrec Second

readListPrec :: ReadPrec [Second]

Real Second

Methods

toRational :: Second -> Rational

Show Second

Methods

showsPrec :: Int -> Second -> ShowS

show :: Second -> String

showList :: [Second] -> ShowS

Ix Second

Methods

range :: (Second, Second) -> [Second]

index :: (Second, Second) -> Second -> Int

unsafeIndex :: (Second, Second) -> Second -> Int

inRange :: (Second, Second) -> Second -> Bool

rangeSize :: (Second, Second) -> Int

unsafeRangeSize :: (Second, Second) -> Int

TimeUnit Second

Methods

toMicroseconds :: Second -> Integer

fromMicroseconds :: Integer -> Second

Re-export of Data.Time.Units.Minute

data Minute :: *

Instances

Enum Minute

Methods

succ :: Minute -> Minute

pred :: Minute -> Minute

toEnum :: Int -> Minute

fromEnum :: Minute -> Int

enumFrom :: Minute -> [Minute]

enumFromThen :: Minute -> Minute -> [Minute]

enumFromTo :: Minute -> Minute -> [Minute]

enumFromThenTo :: Minute -> Minute -> Minute -> [Minute]

Eq Minute

Methods

(==) :: Minute -> Minute -> Bool

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

Integral Minute

Methods

quot :: Minute -> Minute -> Minute

rem :: Minute -> Minute -> Minute

div :: Minute -> Minute -> Minute

mod :: Minute -> Minute -> Minute

quotRem :: Minute -> Minute -> (Minute, Minute)

divMod :: Minute -> Minute -> (Minute, Minute)

toInteger :: Minute -> Integer

Data Minute

Methods

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

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

toConstr :: Minute -> Constr

dataTypeOf :: Minute -> DataType

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

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

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

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

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

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

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

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

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

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

Num Minute

Methods

(+) :: Minute -> Minute -> Minute

(-) :: Minute -> Minute -> Minute

(*) :: Minute -> Minute -> Minute

negate :: Minute -> Minute

abs :: Minute -> Minute

signum :: Minute -> Minute

fromInteger :: Integer -> Minute

Ord Minute

Methods

compare :: Minute -> Minute -> Ordering

(<) :: Minute -> Minute -> Bool

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

(>) :: Minute -> Minute -> Bool

(>=) :: Minute -> Minute -> Bool

max :: Minute -> Minute -> Minute

min :: Minute -> Minute -> Minute

Read Minute

Methods

readsPrec :: Int -> ReadS Minute

readList :: ReadS [Minute]

readPrec :: ReadPrec Minute

readListPrec :: ReadPrec [Minute]

Real Minute

Methods

toRational :: Minute -> Rational

Show Minute

Methods

showsPrec :: Int -> Minute -> ShowS

show :: Minute -> String

showList :: [Minute] -> ShowS

Ix Minute

Methods

range :: (Minute, Minute) -> [Minute]

index :: (Minute, Minute) -> Minute -> Int

unsafeIndex :: (Minute, Minute) -> Minute -> Int

inRange :: (Minute, Minute) -> Minute -> Bool

rangeSize :: (Minute, Minute) -> Int

unsafeRangeSize :: (Minute, Minute) -> Int

TimeUnit Minute

Methods

toMicroseconds :: Minute -> Integer

fromMicroseconds :: Integer -> Minute

Time accumulators

Time accumulators allow to specify time in pretty complicated ways.

• Some of them can accept TimeUnit, which fully defines result.

for (5 :: Minute)

• They can accept several numbers with time measures, which would be sumarized.

for 1 minute 15 sec 10 mcs
for 1.2 minute'

class TimeAccR t

Time accumulator, which evaluates to RelativeToNow. It's implementation is intentionally not visible from this module.

Minimal complete definition

till', for'

Instances

TimeAccR RelativeToNow

Methods

till' :: Microsecond -> RelativeToNow

for' :: Microsecond -> RelativeToNow

TimeUnit t => TimeAccR (t -> RelativeToNow)

Methods

till' :: Microsecond -> t -> RelativeToNow

for' :: Microsecond -> t -> RelativeToNow

((~) * a b, TimeAccR t) => TimeAccR (a -> (b -> Microsecond) -> t)

Methods

till' :: Microsecond -> a -> (b -> Microsecond) -> t

for' :: Microsecond -> a -> (b -> Microsecond) -> t

class TimeAccM t

Time accumulator, which evaluates to Microsecond. It's implementation is intentionally not visible from this module.

Minimal complete definition

interval'

Instances

TimeAccM Microsecond

Methods

interval' :: Microsecond -> Microsecond

((~) * a b, TimeAccM t) => TimeAccM (a -> (b -> Microsecond) -> t)

Methods

interval' :: Microsecond -> a -> (b -> Microsecond) -> t

Exceptions

data MonadTimedError

Is arisen on call of timeout if action wasn't executed in time.

Constructors

MTTimeoutError Text

Instances

Show MonadTimedError

Methods

showsPrec :: Int -> MonadTimedError -> ShowS

show :: MonadTimedError -> String

showList :: [MonadTimedError] -> ShowS

Exception MonadTimedError

Methods

toException :: MonadTimedError -> SomeException

fromException :: SomeException -> Maybe MonadTimedError

displayException :: MonadTimedError -> String

Buildable MonadTimedError

Methods

build :: MonadTimedError -> Builder