module Haskore.RealTime.EventList.TimeBody
(T,
mapBodyM, mapM, mapM_, getBodies,
mapBody, mapTime,
mapTimeTail,
empty, singleton, null, viewL, viewTimeL, viewBodyL, cons, snoc,
consBody, consTime,
append, concat, cycle,
insert, decreaseStart, delay, partition, foldr, slice, normalize,
collectCoincident, flatten, mapCoincident,
resample, toAbsoluteEventList,
run, runTimeStamp, runTimeStampGrouped,
runCore, runRelative, runRelativeCore,
attachTime,
) where
import Data.EventList.Relative.TimeBody
import Data.EventList.Relative.MixedBody
import qualified Data.EventList.Absolute.TimeBody as AbsList
import qualified Haskore.RealTime.Timer as Timer
import qualified Numeric.NonNegative.Class as NonNeg
import qualified Numeric.NonNegative.Wrapper as NonNegW
import qualified Control.Monad as Monad
import Control.Monad.Trans (MonadIO, liftIO)
import Prelude hiding (null, foldr, mapM, mapM_, concat, cycle)
runRelative :: (NonNeg.C time, RealFrac time, MonadIO io) =>
Timer.T -> (body -> io a) -> T time body -> io [a]
runRelative timer action =
runRelativeCore timer action .
resample (fromIntegral $ Timer.resolution timer)
runRelativeCore :: MonadIO io =>
Timer.T -> (body -> io a) -> T NonNegW.Integer body -> io [a]
runRelativeCore timer action =
Monad.liftM getBodies .
mapM (liftIO . Timer.wait timer) action
run :: (RealFrac time, MonadIO io) =>
Timer.T -> (body -> io a) -> T time body -> io [a]
run timer action = runTimeStamp timer (const action)
runTimeStamp :: (RealFrac time, MonadIO io) =>
Timer.T -> (time -> body -> io a) -> T time body -> io [a]
runTimeStamp =
runCore id
runTimeStampGrouped :: (RealFrac time, MonadIO io) =>
Timer.T -> (time -> [body] -> io a) -> T time body -> io [a]
runTimeStampGrouped =
runCore AbsList.collectCoincident
runCore :: (Fractional time0, RealFrac time1, MonadIO io) =>
(AbsList.T time0 body0 -> AbsList.T time1 body1) ->
Timer.T -> (time1 -> body1 -> io a) -> T time0 body0 -> io [a]
runCore convertAbs timer action evs =
Monad.liftM AbsList.getBodies .
AbsList.mapM
(liftIO . Timer.waitUntilSeconds timer)
(uncurry action) .
attachTime .
convertAbs .
flip toAbsoluteEventList evs =<<
liftIO (Timer.getTimeSeconds timer)
attachTime :: AbsList.T time body -> AbsList.T time (time, body)
attachTime =
AbsList.fromPairList .
map (\ ~(time,body) -> (time, (time,body))) .
AbsList.toPairList