Data.EventList.Absolute.TimeTime

Event list with absolute times starting with a time and ending with a body

Documentation

data T time body

Instances

(Eq time, Eq body) => Eq (T time body)

(Ord time, Ord body) => Ord (T time body)

(Show time, Show body) => Show (T time body)

pause :: time -> T time body

isPause :: T time body -> Bool

viewL :: T time body -> (time, Maybe (body, T time body))

switchL :: (time -> a) -> ((time, body) -> T time body -> a) -> T time body -> a

cons :: time -> body -> T time body -> T time body

snoc :: T time body -> body -> time -> T time body

mapBody :: (body0 -> body1) -> T time body0 -> T time body1

mapTime :: (time0 -> time1) -> T time0 body -> T time1 body

concatMapMonoid :: Monoid m => (time -> m) -> (body -> m) -> T time body -> m

traverse :: Applicative m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

traverse_ :: Applicative m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

traverseBody :: Applicative m => (body0 -> m body1) -> T time body0 -> m (T time body1)

traverseTime :: Applicative m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

mapM :: Monad m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

mapM_ :: Monad m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

mapBodyM :: Monad m => (body0 -> m body1) -> T time body0 -> m (T time body1)

mapTimeM :: Monad m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

getTimes :: T time body -> [time]

getBodies :: T time body -> [body]

duration :: Num time => T time body -> time

merge :: (Ord time, Ord body) => T time body -> T time body -> T time body

mergeBy :: Ord time => (body -> body -> Bool) -> T time body -> T time body -> T time body

insert :: (Ord time, Ord body) => time -> body -> T time body -> T time body

insertBy :: Ord time => (body -> body -> Bool) -> time -> body -> T time body -> T time body

moveForward :: (Ord time, Num time) => T time (time, body) -> T time body

Move events towards the front of the event list. You must make sure, that no event is moved before time zero. This works only for finite lists.

decreaseStart :: (Ord time, Num time) => time -> T time body -> T time body

delay :: (Ord time, Num time) => time -> T time body -> T time body

filter :: Num time => (body -> Bool) -> T time body -> T time body

partition :: (body -> Bool) -> T time body -> (T time body, T time body)

slice :: (Eq a, Num time) => (body -> a) -> T time body -> [(a, T time body)]

foldr :: (time -> a -> b) -> (body -> b -> a) -> a -> T time body -> b

mapMaybe :: Num time => (body0 -> Maybe body1) -> T time body0 -> T time body1

catMaybes :: Num time => T time (Maybe body) -> T time body

normalize :: (Ord time, Num time, Ord body) => T time body -> T time body

sort sorts a list of coinciding events, that is all events but the first one have time difference 0. normalize sorts all coinciding events in a list thus yielding a canonical representation of a time ordered list.

isNormalized :: (Ord time, Num time, Ord body) => T time body -> Bool

collectCoincident :: Eq time => T time body -> T time [body]

flatten :: Ord time => T time [body] -> T time body

mapCoincident :: Ord time => ([a] -> [b]) -> T time a -> T time b

Apply a function to the lists of coincident events.

append :: (Ord time, Num time) => T time body -> T time body -> T time body

concat :: (Ord time, Num time) => [T time body] -> T time body

cycle :: (Ord time, Num time) => T time body -> T time body

discretize :: (RealFrac time, Integral i) => T time body -> T i body

resample :: (RealFrac time, Integral i) => time -> T time body -> T i body