event-list 0.0.11 → 0.0.11.1

raw patch · 2 files changed

+10/−3 lines, 2 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Data.EventList.Absolute.TimeBody: catMaybes :: (Num time) => T time (Maybe body) -> T time body

+ Data.EventList.Absolute.TimeBody: catMaybes :: Num time => T time (Maybe body) -> T time body

- Data.EventList.Absolute.TimeBody: checkTimes :: (Ord time) => T time body -> T time body

+ Data.EventList.Absolute.TimeBody: checkTimes :: Ord time => T time body -> T time body

- Data.EventList.Absolute.TimeBody: collectCoincident :: (Eq time) => T time body -> T time [body]

+ Data.EventList.Absolute.TimeBody: collectCoincident :: Eq time => T time body -> T time [body]

- Data.EventList.Absolute.TimeBody: collectCoincidentFoldr :: (Eq time) => T time body -> T time [body]

+ Data.EventList.Absolute.TimeBody: collectCoincidentFoldr :: Eq time => T time body -> T time [body]

- Data.EventList.Absolute.TimeBody: collectCoincidentNonLazy :: (Eq time) => T time body -> T time [body]

+ Data.EventList.Absolute.TimeBody: collectCoincidentNonLazy :: Eq time => T time body -> T time [body]

- Data.EventList.Absolute.TimeBody: concatMapMonoid :: (Monoid m) => (time -> m) -> (body -> m) -> T time body -> m

+ Data.EventList.Absolute.TimeBody: concatMapMonoid :: Monoid m => (time -> m) -> (body -> m) -> T time body -> m

- Data.EventList.Absolute.TimeBody: duration :: (Num time) => T time body -> time

+ Data.EventList.Absolute.TimeBody: duration :: Num time => T time body -> time

- Data.EventList.Absolute.TimeBody: filter :: (Num time) => (body -> Bool) -> T time body -> T time body

+ Data.EventList.Absolute.TimeBody: filter :: Num time => (body -> Bool) -> T time body -> T time body

- Data.EventList.Absolute.TimeBody: insertBy :: (Ord time) => (body -> body -> Bool) -> time -> body -> T time body -> T time body

+ Data.EventList.Absolute.TimeBody: insertBy :: Ord time => (body -> body -> Bool) -> time -> body -> T time body -> T time body

- Data.EventList.Absolute.TimeBody: mapBodyM :: (Monad m) => (body0 -> m body1) -> T time body0 -> m (T time body1)

+ Data.EventList.Absolute.TimeBody: mapBodyM :: Monad m => (body0 -> m body1) -> T time body0 -> m (T time body1)

- Data.EventList.Absolute.TimeBody: mapM :: (Monad m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Absolute.TimeBody: mapM :: Monad m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Absolute.TimeBody: mapM_ :: (Monad m) => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

+ Data.EventList.Absolute.TimeBody: mapM_ :: Monad m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

- Data.EventList.Absolute.TimeBody: mapMaybe :: (Num time) => (body0 -> Maybe body1) -> T time body0 -> T time body1

+ Data.EventList.Absolute.TimeBody: mapMaybe :: Num time => (body0 -> Maybe body1) -> T time body0 -> T time body1

- Data.EventList.Absolute.TimeBody: mapTimeM :: (Monad m) => (time0 -> m time1) -> T time0 body -> m (T time1 body)

+ Data.EventList.Absolute.TimeBody: mapTimeM :: Monad m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

- Data.EventList.Absolute.TimeBody: mergeBy :: (Ord time) => (body -> body -> Bool) -> T time body -> T time body -> T time body

+ Data.EventList.Absolute.TimeBody: mergeBy :: Ord time => (body -> body -> Bool) -> T time body -> T time body -> T time body

- Data.EventList.Absolute.TimeBody: slice :: (Eq a) => (body -> a) -> T time body -> [(a, T time body)]

+ Data.EventList.Absolute.TimeBody: slice :: Eq a => (body -> a) -> T time body -> [(a, T time body)]

- Data.EventList.Absolute.TimeBody: traverse :: (Applicative m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Absolute.TimeBody: traverse :: Applicative m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Absolute.TimeBody: traverseBody :: (Applicative m) => (body0 -> m body1) -> T time body0 -> m (T time body1)

+ Data.EventList.Absolute.TimeBody: traverseBody :: Applicative m => (body0 -> m body1) -> T time body0 -> m (T time body1)

- Data.EventList.Absolute.TimeBody: traverseTime :: (Applicative m) => (time0 -> m time1) -> T time0 body -> m (T time1 body)

+ Data.EventList.Absolute.TimeBody: traverseTime :: Applicative m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

- Data.EventList.Absolute.TimeBody: traverse_ :: (Applicative m) => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

+ Data.EventList.Absolute.TimeBody: traverse_ :: Applicative m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

- Data.EventList.Absolute.TimeTime: catMaybes :: (Num time) => T time (Maybe body) -> T time body

+ Data.EventList.Absolute.TimeTime: catMaybes :: Num time => T time (Maybe body) -> T time body

- Data.EventList.Absolute.TimeTime: collectCoincident :: (Eq time) => T time body -> T time [body]

+ Data.EventList.Absolute.TimeTime: collectCoincident :: Eq time => T time body -> T time [body]

- Data.EventList.Absolute.TimeTime: concatMapMonoid :: (Monoid m) => (time -> m) -> (body -> m) -> T time body -> m

+ Data.EventList.Absolute.TimeTime: concatMapMonoid :: Monoid m => (time -> m) -> (body -> m) -> T time body -> m

- Data.EventList.Absolute.TimeTime: duration :: (Num time) => T time body -> time

+ Data.EventList.Absolute.TimeTime: duration :: Num time => T time body -> time

- Data.EventList.Absolute.TimeTime: filter :: (Num time) => (body -> Bool) -> T time body -> T time body

+ Data.EventList.Absolute.TimeTime: filter :: Num time => (body -> Bool) -> T time body -> T time body

- Data.EventList.Absolute.TimeTime: insertBy :: (Ord time) => (body -> body -> Bool) -> time -> body -> T time body -> T time body

+ Data.EventList.Absolute.TimeTime: insertBy :: Ord time => (body -> body -> Bool) -> time -> body -> T time body -> T time body

- Data.EventList.Absolute.TimeTime: mapBodyM :: (Monad m) => (body0 -> m body1) -> T time body0 -> m (T time body1)

+ Data.EventList.Absolute.TimeTime: mapBodyM :: Monad m => (body0 -> m body1) -> T time body0 -> m (T time body1)

- Data.EventList.Absolute.TimeTime: mapM :: (Monad m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Absolute.TimeTime: mapM :: Monad m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Absolute.TimeTime: mapM_ :: (Monad m) => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

+ Data.EventList.Absolute.TimeTime: mapM_ :: Monad m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

- Data.EventList.Absolute.TimeTime: mapMaybe :: (Num time) => (body0 -> Maybe body1) -> T time body0 -> T time body1

+ Data.EventList.Absolute.TimeTime: mapMaybe :: Num time => (body0 -> Maybe body1) -> T time body0 -> T time body1

- Data.EventList.Absolute.TimeTime: mapTimeM :: (Monad m) => (time0 -> m time1) -> T time0 body -> m (T time1 body)

+ Data.EventList.Absolute.TimeTime: mapTimeM :: Monad m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

- Data.EventList.Absolute.TimeTime: mergeBy :: (Ord time) => (body -> body -> Bool) -> T time body -> T time body -> T time body

+ Data.EventList.Absolute.TimeTime: mergeBy :: Ord time => (body -> body -> Bool) -> T time body -> T time body -> T time body

- Data.EventList.Absolute.TimeTime: traverse :: (Applicative m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Absolute.TimeTime: traverse :: Applicative m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Absolute.TimeTime: traverseBody :: (Applicative m) => (body0 -> m body1) -> T time body0 -> m (T time body1)

+ Data.EventList.Absolute.TimeTime: traverseBody :: Applicative m => (body0 -> m body1) -> T time body0 -> m (T time body1)

- Data.EventList.Absolute.TimeTime: traverseTime :: (Applicative m) => (time0 -> m time1) -> T time0 body -> m (T time1 body)

+ Data.EventList.Absolute.TimeTime: traverseTime :: Applicative m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

- Data.EventList.Absolute.TimeTime: traverse_ :: (Applicative m) => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

+ Data.EventList.Absolute.TimeTime: traverse_ :: Applicative m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

- Data.EventList.Relative.BodyBody: concatMapMonoid :: (Monoid m) => (time -> m) -> (body -> m) -> T time body -> m

+ Data.EventList.Relative.BodyBody: concatMapMonoid :: Monoid m => (time -> m) -> (body -> m) -> T time body -> m

- Data.EventList.Relative.BodyBody: mapM :: (Monad m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Relative.BodyBody: mapM :: Monad m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Relative.BodyBody: traverse :: (Applicative m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Relative.BodyBody: traverse :: Applicative m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Relative.BodyTime: concatMapMonoid :: (Monoid m) => (time -> m) -> (body -> m) -> T time body -> m

+ Data.EventList.Relative.BodyTime: concatMapMonoid :: Monoid m => (time -> m) -> (body -> m) -> T time body -> m

- Data.EventList.Relative.BodyTime: duration :: (Num time) => T time body -> time

+ Data.EventList.Relative.BodyTime: duration :: Num time => T time body -> time

- Data.EventList.Relative.BodyTime: durationR :: (Num time) => T time body -> time

+ Data.EventList.Relative.BodyTime: durationR :: Num time => T time body -> time

- Data.EventList.Relative.BodyTime: mapBodyM :: (Monad m) => (body0 -> m body1) -> T time body0 -> m (T time body1)

+ Data.EventList.Relative.BodyTime: mapBodyM :: Monad m => (body0 -> m body1) -> T time body0 -> m (T time body1)

- Data.EventList.Relative.BodyTime: mapM :: (Monad m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Relative.BodyTime: mapM :: Monad m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Relative.BodyTime: mapM_ :: (Monad m) => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

+ Data.EventList.Relative.BodyTime: mapM_ :: Monad m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

- Data.EventList.Relative.BodyTime: mapTimeM :: (Monad m) => (time0 -> m time1) -> T time0 body -> m (T time1 body)

+ Data.EventList.Relative.BodyTime: mapTimeM :: Monad m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

- Data.EventList.Relative.BodyTime: traverse :: (Applicative m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Relative.BodyTime: traverse :: Applicative m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Relative.BodyTime: traverseBody :: (Applicative m) => (body0 -> m body1) -> T time body0 -> m (T time body1)

+ Data.EventList.Relative.BodyTime: traverseBody :: Applicative m => (body0 -> m body1) -> T time body0 -> m (T time body1)

- Data.EventList.Relative.BodyTime: traverseTime :: (Applicative m) => (time0 -> m time1) -> T time0 body -> m (T time1 body)

+ Data.EventList.Relative.BodyTime: traverseTime :: Applicative m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

- Data.EventList.Relative.BodyTime: traverse_ :: (Applicative m) => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

+ Data.EventList.Relative.BodyTime: traverse_ :: Applicative m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

- Data.EventList.Relative.TimeBody: catMaybes :: (Num time) => T time (Maybe body) -> T time body

+ Data.EventList.Relative.TimeBody: catMaybes :: Num time => T time (Maybe body) -> T time body

- Data.EventList.Relative.TimeBody: collectCoincident :: (C time) => T time body -> T time [body]

+ Data.EventList.Relative.TimeBody: collectCoincident :: C time => T time body -> T time [body]

- Data.EventList.Relative.TimeBody: concatMapMonoid :: (Monoid m) => (time -> m) -> (body -> m) -> T time body -> m

+ Data.EventList.Relative.TimeBody: concatMapMonoid :: Monoid m => (time -> m) -> (body -> m) -> T time body -> m

- Data.EventList.Relative.TimeBody: decreaseStart :: (C time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeBody: decreaseStart :: C time => time -> T time body -> T time body

- Data.EventList.Relative.TimeBody: delay :: (C time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeBody: delay :: C time => time -> T time body -> T time body

- Data.EventList.Relative.TimeBody: duration :: (Num time) => T time body -> time

+ Data.EventList.Relative.TimeBody: duration :: Num time => T time body -> time

- Data.EventList.Relative.TimeBody: filter :: (Num time) => (body -> Bool) -> T time body -> T time body

+ Data.EventList.Relative.TimeBody: filter :: Num time => (body -> Bool) -> T time body -> T time body

- Data.EventList.Relative.TimeBody: flatten :: (C time) => T time [body] -> T time body

+ Data.EventList.Relative.TimeBody: flatten :: C time => T time [body] -> T time body

- Data.EventList.Relative.TimeBody: fromAbsoluteEventList :: (Num time) => T time body -> T time body

+ Data.EventList.Relative.TimeBody: fromAbsoluteEventList :: Num time => T time body -> T time body

- Data.EventList.Relative.TimeBody: insertBy :: (C time) => (body -> body -> Bool) -> time -> body -> T time body -> T time body

+ Data.EventList.Relative.TimeBody: insertBy :: C time => (body -> body -> Bool) -> time -> body -> T time body -> T time body

- Data.EventList.Relative.TimeBody: mapBodyM :: (Monad m) => (body0 -> m body1) -> T time body0 -> m (T time body1)

+ Data.EventList.Relative.TimeBody: mapBodyM :: Monad m => (body0 -> m body1) -> T time body0 -> m (T time body1)

- Data.EventList.Relative.TimeBody: mapCoincident :: (C time) => ([a] -> [b]) -> T time a -> T time b

+ Data.EventList.Relative.TimeBody: mapCoincident :: C time => ([a] -> [b]) -> T time a -> T time b

- Data.EventList.Relative.TimeBody: mapM :: (Monad m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Relative.TimeBody: mapM :: Monad m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Relative.TimeBody: mapM_ :: (Monad m) => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

+ Data.EventList.Relative.TimeBody: mapM_ :: Monad m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

- Data.EventList.Relative.TimeBody: mapMaybe :: (Num time) => (body0 -> Maybe body1) -> T time body0 -> T time body1

+ Data.EventList.Relative.TimeBody: mapMaybe :: Num time => (body0 -> Maybe body1) -> T time body0 -> T time body1

- Data.EventList.Relative.TimeBody: mapTimeM :: (Monad m) => (time0 -> m time1) -> T time0 body -> m (T time1 body)

+ Data.EventList.Relative.TimeBody: mapTimeM :: Monad m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

- Data.EventList.Relative.TimeBody: mergeBy :: (C time) => (body -> body -> Bool) -> T time body -> T time body -> T time body

+ Data.EventList.Relative.TimeBody: mergeBy :: C time => (body -> body -> Bool) -> T time body -> T time body -> T time body

- Data.EventList.Relative.TimeBody: moveForward :: (C time) => T time (time, body) -> T time body

+ Data.EventList.Relative.TimeBody: moveForward :: C time => T time (time, body) -> T time body

- Data.EventList.Relative.TimeBody: partition :: (Num time) => (body -> Bool) -> T time body -> (T time body, T time body)

+ Data.EventList.Relative.TimeBody: partition :: Num time => (body -> Bool) -> T time body -> (T time body, T time body)

- Data.EventList.Relative.TimeBody: partitionMaybe :: (Num time) => (body0 -> Maybe body1) -> T time body0 -> (T time body1, T time body0)

+ Data.EventList.Relative.TimeBody: partitionMaybe :: Num time => (body0 -> Maybe body1) -> T time body0 -> (T time body1, T time body0)

- Data.EventList.Relative.TimeBody: toAbsoluteEventList :: (Num time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeBody: toAbsoluteEventList :: Num time => time -> T time body -> T time body

- Data.EventList.Relative.TimeBody: traverse :: (Applicative m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Relative.TimeBody: traverse :: Applicative m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Relative.TimeBody: traverseBody :: (Applicative m) => (body0 -> m body1) -> T time body0 -> m (T time body1)

+ Data.EventList.Relative.TimeBody: traverseBody :: Applicative m => (body0 -> m body1) -> T time body0 -> m (T time body1)

- Data.EventList.Relative.TimeBody: traverseTime :: (Applicative m) => (time0 -> m time1) -> T time0 body -> m (T time1 body)

+ Data.EventList.Relative.TimeBody: traverseTime :: Applicative m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

- Data.EventList.Relative.TimeBody: traverse_ :: (Applicative m) => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

+ Data.EventList.Relative.TimeBody: traverse_ :: Applicative m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

- Data.EventList.Relative.TimeMixed: appendBodyEnd :: (C time) => T time body -> T time body -> T time body

+ Data.EventList.Relative.TimeMixed: appendBodyEnd :: C time => T time body -> T time body -> T time body

- Data.EventList.Relative.TimeMixed: dropTime :: (C time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeMixed: dropTime :: C time => time -> T time body -> T time body

- Data.EventList.Relative.TimeMixed: splitAtTime :: (C time) => time -> T time body -> (T time body, T time body)

+ Data.EventList.Relative.TimeMixed: splitAtTime :: C time => time -> T time body -> (T time body, T time body)

- Data.EventList.Relative.TimeMixed: takeTime :: (C time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeMixed: takeTime :: C time => time -> T time body -> T time body

- Data.EventList.Relative.TimeTime: append :: (C time) => T time body -> T time body -> T time body

+ Data.EventList.Relative.TimeTime: append :: C time => T time body -> T time body -> T time body

- Data.EventList.Relative.TimeTime: arrangeBy :: (C time) => (body -> body -> Bool) -> T time (T time body) -> T time body

+ Data.EventList.Relative.TimeTime: arrangeBy :: C time => (body -> body -> Bool) -> T time (T time body) -> T time body

- Data.EventList.Relative.TimeTime: catMaybes :: (Num time) => T time (Maybe body) -> T time body

+ Data.EventList.Relative.TimeTime: catMaybes :: Num time => T time (Maybe body) -> T time body

- Data.EventList.Relative.TimeTime: catMaybesR :: (Num time) => T time (Maybe body) -> T time body

+ Data.EventList.Relative.TimeTime: catMaybesR :: Num time => T time (Maybe body) -> T time body

- Data.EventList.Relative.TimeTime: collectCoincident :: (C time) => T time body -> T time [body]

+ Data.EventList.Relative.TimeTime: collectCoincident :: C time => T time body -> T time [body]

- Data.EventList.Relative.TimeTime: concat :: (C time) => [T time body] -> T time body

+ Data.EventList.Relative.TimeTime: concat :: C time => [T time body] -> T time body

- Data.EventList.Relative.TimeTime: concatMapMonoid :: (Monoid m) => (time -> m) -> (body -> m) -> T time body -> m

+ Data.EventList.Relative.TimeTime: concatMapMonoid :: Monoid m => (time -> m) -> (body -> m) -> T time body -> m

- Data.EventList.Relative.TimeTime: concatNaive :: (C time) => [T time body] -> T time body

+ Data.EventList.Relative.TimeTime: concatNaive :: C time => [T time body] -> T time body

- Data.EventList.Relative.TimeTime: cycle :: (C time) => T time body -> T time body

+ Data.EventList.Relative.TimeTime: cycle :: C time => T time body -> T time body

- Data.EventList.Relative.TimeTime: cycleNaive :: (C time) => T time body -> T time body

+ Data.EventList.Relative.TimeTime: cycleNaive :: C time => T time body -> T time body

- Data.EventList.Relative.TimeTime: decreaseStart :: (C time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeTime: decreaseStart :: C time => time -> T time body -> T time body

- Data.EventList.Relative.TimeTime: delay :: (C time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeTime: delay :: C time => time -> T time body -> T time body

- Data.EventList.Relative.TimeTime: dropTime :: (C time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeTime: dropTime :: C time => time -> T time body -> T time body

- Data.EventList.Relative.TimeTime: duration :: (Num time) => T time body -> time

+ Data.EventList.Relative.TimeTime: duration :: Num time => T time body -> time

- Data.EventList.Relative.TimeTime: filter :: (Num time) => (body -> Bool) -> T time body -> T time body

+ Data.EventList.Relative.TimeTime: filter :: Num time => (body -> Bool) -> T time body -> T time body

- Data.EventList.Relative.TimeTime: flatten :: (Num time) => T time [body] -> T time body

+ Data.EventList.Relative.TimeTime: flatten :: Num time => T time [body] -> T time body

- Data.EventList.Relative.TimeTime: fromAbsoluteEventList :: (Num time) => T time body -> T time body

+ Data.EventList.Relative.TimeTime: fromAbsoluteEventList :: Num time => T time body -> T time body

- Data.EventList.Relative.TimeTime: mapBodyM :: (Monad m) => (body0 -> m body1) -> T time body0 -> m (T time body1)

+ Data.EventList.Relative.TimeTime: mapBodyM :: Monad m => (body0 -> m body1) -> T time body0 -> m (T time body1)

- Data.EventList.Relative.TimeTime: mapCoincident :: (C time) => ([a] -> [b]) -> T time a -> T time b

+ Data.EventList.Relative.TimeTime: mapCoincident :: C time => ([a] -> [b]) -> T time a -> T time b

- Data.EventList.Relative.TimeTime: mapM :: (Monad m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Relative.TimeTime: mapM :: Monad m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Relative.TimeTime: mapM_ :: (Monad m) => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

+ Data.EventList.Relative.TimeTime: mapM_ :: Monad m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

- Data.EventList.Relative.TimeTime: mapMaybe :: (Num time) => (body0 -> Maybe body1) -> T time body0 -> T time body1

+ Data.EventList.Relative.TimeTime: mapMaybe :: Num time => (body0 -> Maybe body1) -> T time body0 -> T time body1

- Data.EventList.Relative.TimeTime: mapTimeM :: (Monad m) => (time0 -> m time1) -> T time0 body -> m (T time1 body)

+ Data.EventList.Relative.TimeTime: mapTimeM :: Monad m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

- Data.EventList.Relative.TimeTime: mergeBy :: (C time) => (body -> body -> Bool) -> T time body -> T time body -> T time body

+ Data.EventList.Relative.TimeTime: mergeBy :: C time => (body -> body -> Bool) -> T time body -> T time body -> T time body

- Data.EventList.Relative.TimeTime: moveBackward :: (C time) => T time (time, body) -> T time body

+ Data.EventList.Relative.TimeTime: moveBackward :: C time => T time (time, body) -> T time body

- Data.EventList.Relative.TimeTime: moveForward :: (C time) => T time (time, body) -> T time body

+ Data.EventList.Relative.TimeTime: moveForward :: C time => T time (time, body) -> T time body

- Data.EventList.Relative.TimeTime: moveForwardRestrictedBy :: (C time) => (body -> body -> Bool) -> time -> T time (time, body) -> T time body

+ Data.EventList.Relative.TimeTime: moveForwardRestrictedBy :: C time => (body -> body -> Bool) -> time -> T time (time, body) -> T time body

- Data.EventList.Relative.TimeTime: moveForwardRestrictedByQueue :: (C time) => (body -> body -> Bool) -> time -> T time (time, body) -> T time body

+ Data.EventList.Relative.TimeTime: moveForwardRestrictedByQueue :: C time => (body -> body -> Bool) -> time -> T time (time, body) -> T time body

- Data.EventList.Relative.TimeTime: moveForwardRestrictedByStrict :: (C time) => (body -> body -> Bool) -> time -> T time (time, body) -> T time body

+ Data.EventList.Relative.TimeTime: moveForwardRestrictedByStrict :: C time => (body -> body -> Bool) -> time -> T time (time, body) -> T time body

- Data.EventList.Relative.TimeTime: pad :: (C time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeTime: pad :: C time => time -> T time body -> T time body

- Data.EventList.Relative.TimeTime: partition :: (Num time) => (body -> Bool) -> T time body -> (T time body, T time body)

+ Data.EventList.Relative.TimeTime: partition :: Num time => (body -> Bool) -> T time body -> (T time body, T time body)

- Data.EventList.Relative.TimeTime: partitionMaybe :: (Num time) => (body0 -> Maybe body1) -> T time body0 -> (T time body1, T time body0)

+ Data.EventList.Relative.TimeTime: partitionMaybe :: Num time => (body0 -> Maybe body1) -> T time body0 -> (T time body1, T time body0)

- Data.EventList.Relative.TimeTime: partitionMaybeR :: (Num time) => (body0 -> Maybe body1) -> T time body0 -> (T time body1, T time body0)

+ Data.EventList.Relative.TimeTime: partitionMaybeR :: Num time => (body0 -> Maybe body1) -> T time body0 -> (T time body1, T time body0)

- Data.EventList.Relative.TimeTime: splitAtTime :: (C time) => time -> T time body -> (T time body, T time body)

+ Data.EventList.Relative.TimeTime: splitAtTime :: C time => time -> T time body -> (T time body, T time body)

- Data.EventList.Relative.TimeTime: takeTime :: (C time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeTime: takeTime :: C time => time -> T time body -> T time body

- Data.EventList.Relative.TimeTime: toAbsoluteEventList :: (Num time) => time -> T time body -> T time body

+ Data.EventList.Relative.TimeTime: toAbsoluteEventList :: Num time => time -> T time body -> T time body

- Data.EventList.Relative.TimeTime: traverse :: (Applicative m) => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

+ Data.EventList.Relative.TimeTime: traverse :: Applicative m => (time0 -> m time1) -> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)

- Data.EventList.Relative.TimeTime: traverseBody :: (Applicative m) => (body0 -> m body1) -> T time body0 -> m (T time body1)

+ Data.EventList.Relative.TimeTime: traverseBody :: Applicative m => (body0 -> m body1) -> T time body0 -> m (T time body1)

- Data.EventList.Relative.TimeTime: traverseTime :: (Applicative m) => (time0 -> m time1) -> T time0 body -> m (T time1 body)

+ Data.EventList.Relative.TimeTime: traverseTime :: Applicative m => (time0 -> m time1) -> T time0 body -> m (T time1 body)

- Data.EventList.Relative.TimeTime: traverse_ :: (Applicative m) => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

+ Data.EventList.Relative.TimeTime: traverse_ :: Applicative m => (time -> m ()) -> (body -> m ()) -> T time body -> m ()

Files

event-list.cabal +2/−2
src/Data/EventList/Relative/TimeTimePrivate.hs +8/−1

event-list.cabal view

@@ -1,5 +1,5 @@ Name:             event-list-Version:          0.0.11+Version:          0.0.11.1 License:          GPL License-File:     LICENSE Author:           Henning Thielemann <haskell@henning-thielemann.de>@@ -26,7 +26,7 @@ Source-Repository this   type:     darcs   location: http://code.haskell.org/~thielema/event-list/-  tag:      0.0.11+  tag:      0.0.11.1  Flag splitBase   description: Choose the new smaller, split-up base package.

src/Data/EventList/Relative/TimeTimePrivate.hs view

@@ -150,7 +150,14 @@ mapTimeTail ::    (BodyTimeList.T time body0 -> BodyTimeList.T time body1) ->    T time body0 -> T time body1-mapTimeTail = lift . Mixed.mapSecondTail . BodyTimePriv.unlift+mapTimeTail f =+   switchTimeL (\time -> consTime time . f)+{-+This causes a memory leak when used with chunky time values.++mapTimeTail =+   lift . Mixed.mapSecondTail . BodyTimePriv.unlift+-}   mapTimeR ::