{- |
Copyright   :  (c) Henning Thielemann 2007-2010

Maintainer  :  haskell@henning-thielemann.de
Stability   :  stable
Portability :  Haskell 98
-}
module Data.EventList.Relative.TimeTimePrivate where

import qualified Data.EventList.Relative.TimeBodyPrivate as TimeBodyList
import qualified Data.EventList.Relative.TimeBodyPrivate as TimeBodyPriv

import qualified Data.EventList.Relative.BodyTimePrivate as BodyTimeList
import qualified Data.EventList.Relative.BodyTimePrivate as BodyTimePriv

import Data.EventList.Relative.TimeBodyPrivate (($~*))

import qualified Data.AlternatingList.List.Disparate as Disp
import qualified Data.AlternatingList.List.Uniform as Uniform
import qualified Data.AlternatingList.List.Mixed as Mixed

import qualified Numeric.NonNegative.Class as NonNeg
import Numeric.NonNegative.Class (zero, add, )

import Data.Tuple.HT (mapFst, mapSnd, )

import qualified Control.Monad as Monad
import qualified Data.Foldable as Fold
import qualified Data.Traversable as Trav
import qualified Control.Applicative as App
import Control.Applicative (Applicative, )
import Data.Monoid (Monoid, mempty, mappend, mconcat, )
import Data.Semigroup (Semigroup, (<>), )

import Test.QuickCheck (Arbitrary(arbitrary, shrink))

import Prelude hiding (foldr, )


newtype T time body = Cons {forall time body. T time body -> T body time
decons :: Uniform.T body time}
   deriving (T time body -> T time body -> Bool
(T time body -> T time body -> Bool)
-> (T time body -> T time body -> Bool) -> Eq (T time body)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall time body.
(Eq time, Eq body) =>
T time body -> T time body -> Bool
$c== :: forall time body.
(Eq time, Eq body) =>
T time body -> T time body -> Bool
== :: T time body -> T time body -> Bool
$c/= :: forall time body.
(Eq time, Eq body) =>
T time body -> T time body -> Bool
/= :: T time body -> T time body -> Bool
Eq, Eq (T time body)
Eq (T time body) =>
(T time body -> T time body -> Ordering)
-> (T time body -> T time body -> Bool)
-> (T time body -> T time body -> Bool)
-> (T time body -> T time body -> Bool)
-> (T time body -> T time body -> Bool)
-> (T time body -> T time body -> T time body)
-> (T time body -> T time body -> T time body)
-> Ord (T time body)
T time body -> T time body -> Bool
T time body -> T time body -> Ordering
T time body -> T time body -> T time body
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall time body. (Ord time, Ord body) => Eq (T time body)
forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> Bool
forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> Ordering
forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> T time body
$ccompare :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> Ordering
compare :: T time body -> T time body -> Ordering
$c< :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> Bool
< :: T time body -> T time body -> Bool
$c<= :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> Bool
<= :: T time body -> T time body -> Bool
$c> :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> Bool
> :: T time body -> T time body -> Bool
$c>= :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> Bool
>= :: T time body -> T time body -> Bool
$cmax :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> T time body
max :: T time body -> T time body -> T time body
$cmin :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> T time body
min :: T time body -> T time body -> T time body
Ord)


instance (Show time, Show body) => Show (T time body) where
   showsPrec :: Int -> T time body -> ShowS
showsPrec Int
p = String -> String -> Int -> T body time -> ShowS
forall a b.
(Show a, Show b) =>
String -> String -> Int -> T a b -> ShowS
Uniform.format String
" ./ " String
" /. " Int
p (T body time -> ShowS)
-> (T time body -> T body time) -> T time body -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
decons

instance (Arbitrary time, Arbitrary body) =>
             Arbitrary (T time body) where
   arbitrary :: Gen (T time body)
arbitrary = (T body time -> T time body)
-> Gen (T body time) -> Gen (T time body)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Monad.liftM T body time -> T time body
forall time body. T body time -> T time body
Cons Gen (T body time)
forall a. Arbitrary a => Gen a
arbitrary
   shrink :: T time body -> [T time body]
shrink = (T body time -> [T body time]) -> T time body -> [T time body]
forall (m :: * -> *) body0 time0 body1 time1.
Monad m =>
(T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
liftM T body time -> [T body time]
forall a. Arbitrary a => a -> [a]
shrink


instance (NonNeg.C time) => Semigroup (T time body) where
   <> :: T time body -> T time body -> T time body
(<>) = T time body -> T time body -> T time body
forall time body.
C time =>
T time body -> T time body -> T time body
append

instance (NonNeg.C time) => Monoid (T time body) where
   mempty :: T time body
mempty = T body time -> T time body
forall time body. T body time -> T time body
Cons (time -> T body time
forall b a. b -> T a b
Uniform.singleton time
forall a. C a => a
zero)
   mappend :: T time body -> T time body -> T time body
mappend = T time body -> T time body -> T time body
forall a. Semigroup a => a -> a -> a
(<>)
   mconcat :: [T time body] -> T time body
mconcat =
      T time [body] -> T time body
forall time body. C time => T time [body] -> T time body
flatten (T time [body] -> T time body)
-> ([T time body] -> T time [body]) -> [T time body] -> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. time -> T time [body] -> T time [body]
forall time body. time -> T time body -> T time body
consTime time
forall a. C a => a
zero (T time [body] -> T time [body])
-> ([T time body] -> T time [body])
-> [T time body]
-> T time [body]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      [T time [body]] -> T time [body]
forall a. Monoid a => [a] -> a
mconcat ([T time [body]] -> T time [body])
-> ([T time body] -> [T time [body]])
-> [T time body]
-> T time [body]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      (T time body -> T time [body]) -> [T time body] -> [T time [body]]
forall a b. (a -> b) -> [a] -> [b]
map ([body] -> T time [body] -> T time [body]
forall body time. body -> T time body -> T time body
consBody [] (T time [body] -> T time [body])
-> (T time body -> T time [body]) -> T time body -> T time [body]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (body -> [body]) -> T time body -> T time [body]
forall a b. (a -> b) -> T time a -> T time b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (body -> [body] -> [body]
forall a. a -> [a] -> [a]
:[]))

append, appendAlt, appendSwitch ::
   (NonNeg.C time) =>
   T time body -> T time body -> T time body
append :: forall time body.
C time =>
T time body -> T time body -> T time body
append T time body
xs T time body
ys =
   T time body -> T time body
forall time body. C time => T time body -> T time body
forceTimeHead (T time body -> T time body) -> T time body -> T time body
forall a b. (a -> b) -> a -> b
$
   (time -> T time body -> T time body)
-> (body -> T time body -> T time body)
-> T time body
-> T time body
-> T time body
forall time a b body.
(time -> a -> b) -> (body -> b -> a) -> a -> T time body -> b
foldr
      time -> T time body -> T time body
forall time body. C time => time -> T time body -> T time body
delay
      (\body
b ->
         time -> T time body -> T time body
forall time body. time -> T time body -> T time body
consTime time
forall a. C a => a
NonNeg.zero (T time body -> T time body)
-> (T time body -> T time body) -> T time body -> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
         body -> T time body -> T time body
forall body time. body -> T time body -> T time body
consBody body
b)
      T time body
ys T time body
xs

appendAlt :: forall time body.
C time =>
T time body -> T time body -> T time body
appendAlt T time body
xs T time body
ys =
   (time -> Either (T time body) (T time body) -> T time body)
-> (body -> T time body -> Either (T time body) (T time body))
-> Either (T time body) (T time body)
-> T time body
-> T time body
forall time a b body.
(time -> a -> b) -> (body -> b -> a) -> a -> T time body -> b
foldr
      (\time
t ->
         time -> T time body -> T time body
forall time body. C time => time -> T time body -> T time body
delay time
t (T time body -> T time body)
-> (Either (T time body) (T time body) -> T time body)
-> Either (T time body) (T time body)
-> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
         (T time body -> T time body)
-> (T time body -> T time body)
-> Either (T time body) (T time body)
-> T time body
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either T time body -> T time body
forall a. a -> a
id (time -> T time body -> T time body
forall time body. time -> T time body -> T time body
consTime time
forall a. C a => a
NonNeg.zero))
      (\body
b -> T time body -> Either (T time body) (T time body)
forall a b. b -> Either a b
Right (T time body -> Either (T time body) (T time body))
-> (T time body -> T time body)
-> T time body
-> Either (T time body) (T time body)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. body -> T time body -> T time body
forall body time. body -> T time body -> T time body
consBody body
b)
      (T time body -> Either (T time body) (T time body)
forall a b. a -> Either a b
Left T time body
ys) T time body
xs

{-
not lazy enough for @append (2 /. 'a' ./ 4 /. 'b' ./ 2 /. undefined) undefined@
-}
appendSwitch :: forall time body.
C time =>
T time body -> T time body -> T time body
appendSwitch =
   (T time body -> time -> T time body -> T time body)
-> T time body -> T time body -> T time body
forall time body a. (T time body -> time -> a) -> T time body -> a
switchTimeR
      (\ T time body
xs time
t ->
         (T body time -> T body time) -> T time body -> T time body
forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift (T time body -> T body time -> T body time
forall b a. T b a -> T a b -> T a b
Mixed.appendDisparateUniform (T time body -> T body time -> T body time)
-> T time body -> T body time -> T body time
forall time body a. (T time body -> a) -> T time body -> a
$~* T time body
xs) (T time body -> T time body)
-> (T time body -> T time body) -> T time body -> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
         time -> T time body -> T time body
forall time body. C time => time -> T time body -> T time body
delay time
t)


instance Functor (T time) where
   fmap :: forall a b. (a -> b) -> T time a -> T time b
fmap a -> b
f (Cons T a time
x) = T b time -> T time b
forall time body. T body time -> T time body
Cons ((a -> b) -> T a time -> T b time
forall a0 a1 b. (a0 -> a1) -> T a0 b -> T a1 b
Uniform.mapFirst a -> b
f T a time
x)

instance Fold.Foldable (T time) where
   foldMap :: forall m a. Monoid m => (a -> m) -> T time a -> m
foldMap = (a -> m) -> T time a -> m
forall (t :: * -> *) m a.
(Traversable t, Monoid m) =>
(a -> m) -> t a -> m
Trav.foldMapDefault

instance Trav.Traversable (T time) where
   traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> T time a -> f (T time b)
traverse a -> f b
f =
      (T b time -> T time b) -> f (T b time) -> f (T time b)
forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
App.liftA T b time -> T time b
forall time body. T body time -> T time body
Cons (f (T b time) -> f (T time b))
-> (T time a -> f (T b time)) -> T time a -> f (T time b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f b) -> (time -> f time) -> T a time -> f (T b time)
forall (m :: * -> *) a0 a1 b0 b1.
Applicative m =>
(a0 -> m a1) -> (b0 -> m b1) -> T a0 b0 -> m (T a1 b1)
Uniform.traverse a -> f b
f time -> f time
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
App.pure (T a time -> f (T b time))
-> (T time a -> T a time) -> T time a -> f (T b time)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time a -> T a time
forall time body. T time body -> T body time
decons


infixl 5 $~~

($~~) :: (Uniform.T body time -> a) -> (T time body -> a)
$~~ :: forall body time a. (T body time -> a) -> T time body -> a
($~~) T body time -> a
f = T body time -> a
f (T body time -> a)
-> (T time body -> T body time) -> T time body -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
decons


lift ::
   (Uniform.T body0 time0 -> Uniform.T body1 time1) ->
   (T time0 body0 -> T time1 body1)
lift :: forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift T body0 time0 -> T body1 time1
f = T body1 time1 -> T time1 body1
forall time body. T body time -> T time body
Cons (T body1 time1 -> T time1 body1)
-> (T time0 body0 -> T body1 time1)
-> T time0 body0
-> T time1 body1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body0 time0 -> T body1 time1
f (T body0 time0 -> T body1 time1)
-> (T time0 body0 -> T body0 time0)
-> T time0 body0
-> T body1 time1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time0 body0 -> T body0 time0
forall time body. T time body -> T body time
decons

liftA :: Applicative m =>
   (Uniform.T body0 time0 -> m (Uniform.T body1 time1)) ->
   (T time0 body0 -> m (T time1 body1))
liftA :: forall (m :: * -> *) body0 time0 body1 time1.
Applicative m =>
(T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
liftA T body0 time0 -> m (T body1 time1)
f = (T body1 time1 -> T time1 body1)
-> m (T body1 time1) -> m (T time1 body1)
forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
App.liftA T body1 time1 -> T time1 body1
forall time body. T body time -> T time body
Cons (m (T body1 time1) -> m (T time1 body1))
-> (T time0 body0 -> m (T body1 time1))
-> T time0 body0
-> m (T time1 body1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body0 time0 -> m (T body1 time1)
f (T body0 time0 -> m (T body1 time1))
-> (T time0 body0 -> T body0 time0)
-> T time0 body0
-> m (T body1 time1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time0 body0 -> T body0 time0
forall time body. T time body -> T body time
decons

liftM :: Monad m =>
   (Uniform.T body0 time0 -> m (Uniform.T body1 time1)) ->
   (T time0 body0 -> m (T time1 body1))
liftM :: forall (m :: * -> *) body0 time0 body1 time1.
Monad m =>
(T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
liftM T body0 time0 -> m (T body1 time1)
f = (T body1 time1 -> T time1 body1)
-> m (T body1 time1) -> m (T time1 body1)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Monad.liftM T body1 time1 -> T time1 body1
forall time body. T body time -> T time body
Cons (m (T body1 time1) -> m (T time1 body1))
-> (T time0 body0 -> m (T body1 time1))
-> T time0 body0
-> m (T time1 body1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body0 time0 -> m (T body1 time1)
f (T body0 time0 -> m (T body1 time1))
-> (T time0 body0 -> T body0 time0)
-> T time0 body0
-> m (T body1 time1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time0 body0 -> T body0 time0
forall time body. T time body -> T body time
decons

unlift ::
   (T time0 body0 -> T time1 body1) ->
   (Uniform.T body0 time0 -> Uniform.T body1 time1)
unlift :: forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T body0 time0 -> T body1 time1
unlift T time0 body0 -> T time1 body1
f = T time1 body1 -> T body1 time1
forall time body. T time body -> T body time
decons (T time1 body1 -> T body1 time1)
-> (T body0 time0 -> T time1 body1)
-> T body0 time0
-> T body1 time1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time0 body0 -> T time1 body1
f (T time0 body0 -> T time1 body1)
-> (T body0 time0 -> T time0 body0)
-> T body0 time0
-> T time1 body1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body0 time0 -> T time0 body0
forall time body. T body time -> T time body
Cons




consBody :: body -> T time body -> BodyTimeList.T time body
consBody :: forall body time. body -> T time body -> T time body
consBody body
b = T body time -> T time body
forall time body. T body time -> T time body
BodyTimePriv.Cons (T body time -> T time body)
-> (T time body -> T body time) -> T time body -> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. body -> T body time -> T body time
forall a b. a -> T a b -> T a b
Mixed.consFirst body
b (T body time -> T body time)
-> (T time body -> T body time) -> T time body -> T body time
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
decons

consTime :: time -> BodyTimeList.T time body -> T time body
consTime :: forall time body. time -> T time body -> T time body
consTime time
t = T body time -> T time body
forall time body. T body time -> T time body
Cons (T body time -> T time body)
-> (T time body -> T body time) -> T time body -> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. time -> T body time -> T body time
forall b a. b -> T a b -> T a b
Mixed.consSecond time
t (T body time -> T body time)
-> (T time body -> T body time) -> T time body -> T body time
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
BodyTimePriv.decons


viewTimeL :: T time body -> (time, BodyTimeList.T time body)
viewTimeL :: forall time body. T time body -> (time, T time body)
viewTimeL = (T body time -> T time body)
-> (time, T body time) -> (time, T time body)
forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd T body time -> T time body
forall time body. T body time -> T time body
BodyTimePriv.Cons ((time, T body time) -> (time, T time body))
-> (T time body -> (time, T body time))
-> T time body
-> (time, T time body)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body time -> (time, T body time)
forall a b. T a b -> (b, T a b)
Mixed.viewSecondL (T body time -> (time, T body time))
-> (T time body -> T body time)
-> T time body
-> (time, T body time)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
decons

viewBodyL :: BodyTimeList.T time body -> Maybe (body, T time body)
viewBodyL :: forall time body. T time body -> Maybe (body, T time body)
viewBodyL = ((body, T body time) -> (body, T time body))
-> Maybe (body, T body time) -> Maybe (body, T time body)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((T body time -> T time body)
-> (body, T body time) -> (body, T time body)
forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd T body time -> T time body
forall time body. T body time -> T time body
Cons) (Maybe (body, T body time) -> Maybe (body, T time body))
-> (T time body -> Maybe (body, T body time))
-> T time body
-> Maybe (body, T time body)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body time -> Maybe (body, T body time)
forall a b. T a b -> Maybe (a, T a b)
Mixed.viewFirstL (T body time -> Maybe (body, T body time))
-> (T time body -> T body time)
-> T time body
-> Maybe (body, T body time)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
BodyTimePriv.decons


viewTimeR :: T time body -> (TimeBodyList.T time body, time)
viewTimeR :: forall time body. T time body -> (T time body, time)
viewTimeR = (T time body -> T time body)
-> (T time body, time) -> (T time body, time)
forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst T time body -> T time body
forall time body. T time body -> T time body
TimeBodyPriv.Cons ((T time body, time) -> (T time body, time))
-> (T time body -> (T time body, time))
-> T time body
-> (T time body, time)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body time -> (T time body, time)
forall a b. T a b -> (T b a, b)
Mixed.viewSecondR (T body time -> (T time body, time))
-> (T time body -> T body time)
-> T time body
-> (T time body, time)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
decons

viewBodyR :: TimeBodyList.T time body -> Maybe (T time body, body)
viewBodyR :: forall time body. T time body -> Maybe (T time body, body)
viewBodyR = ((T body time, body) -> (T time body, body))
-> Maybe (T body time, body) -> Maybe (T time body, body)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((T body time -> T time body)
-> (T body time, body) -> (T time body, body)
forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst T body time -> T time body
forall time body. T body time -> T time body
Cons) (Maybe (T body time, body) -> Maybe (T time body, body))
-> (T time body -> Maybe (T body time, body))
-> T time body
-> Maybe (T time body, body)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> Maybe (T body time, body)
forall b a. T b a -> Maybe (T a b, a)
Mixed.viewFirstR (T time body -> Maybe (T body time, body))
-> (T time body -> T time body)
-> T time body
-> Maybe (T body time, body)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T time body
forall time body. T time body -> T time body
TimeBodyPriv.decons


{-# INLINE switchTimeL #-}
switchTimeL :: (time -> BodyTimeList.T time body -> a) -> T time body -> a
switchTimeL :: forall time body a. (time -> T time body -> a) -> T time body -> a
switchTimeL time -> T time body -> a
f =
   (time -> T body time -> a) -> T body time -> a
forall b a c. (b -> T a b -> c) -> T a b -> c
Mixed.switchSecondL (\time
b -> time -> T time body -> a
f time
b (T time body -> a)
-> (T body time -> T time body) -> T body time -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body time -> T time body
forall time body. T body time -> T time body
BodyTimePriv.Cons) (T body time -> a)
-> (T time body -> T body time) -> T time body -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
decons

{-# INLINE switchBodyL #-}
switchBodyL :: a -> (body -> T time body -> a) -> BodyTimeList.T time body -> a
switchBodyL :: forall a body time.
a -> (body -> T time body -> a) -> T time body -> a
switchBodyL a
f body -> T time body -> a
g =
   a -> (body -> T body time -> a) -> T body time -> a
forall c a b. c -> (a -> T a b -> c) -> T a b -> c
Mixed.switchFirstL a
f (\body
t -> body -> T time body -> a
g body
t (T time body -> a)
-> (T body time -> T time body) -> T body time -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body time -> T time body
forall time body. T body time -> T time body
Cons) (T body time -> a)
-> (T time body -> T body time) -> T time body -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
BodyTimePriv.decons


{-# INLINE switchTimeR #-}
switchTimeR :: (TimeBodyList.T time body -> time -> a) -> T time body -> a
switchTimeR :: forall time body a. (T time body -> time -> a) -> T time body -> a
switchTimeR T time body -> time -> a
f = (T time body -> time -> a) -> T body time -> a
forall b a c. (T b a -> b -> c) -> T a b -> c
Mixed.switchSecondR (T time body -> time -> a
f (T time body -> time -> a)
-> (T time body -> T time body) -> T time body -> time -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T time body
forall time body. T time body -> T time body
TimeBodyPriv.Cons) (T body time -> a)
-> (T time body -> T body time) -> T time body -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
decons

{-# INLINE switchBodyR #-}
switchBodyR :: a -> (T time body -> body -> a) -> TimeBodyList.T time body -> a
switchBodyR :: forall a time body.
a -> (T time body -> body -> a) -> T time body -> a
switchBodyR a
f T time body -> body -> a
g = a -> (T body time -> body -> a) -> T time body -> a
forall c a b. c -> (T a b -> a -> c) -> T b a -> c
Mixed.switchFirstR a
f (T time body -> body -> a
g (T time body -> body -> a)
-> (T body time -> T time body) -> T body time -> body -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body time -> T time body
forall time body. T body time -> T time body
Cons) (T time body -> a)
-> (T time body -> T time body) -> T time body -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T time body
forall time body. T time body -> T time body
TimeBodyPriv.decons


mapTimeL ::
   (time -> time, BodyTimeList.T time body0 -> BodyTimeList.T time body1) ->
   T time body0 -> T time body1
mapTimeL :: forall time body0 body1.
(time -> time, T time body0 -> T time body1)
-> T time body0 -> T time body1
mapTimeL = (T body0 time -> T body1 time) -> T time body0 -> T time body1
forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift ((T body0 time -> T body1 time) -> T time body0 -> T time body1)
-> ((time -> time, T time body0 -> T time body1)
    -> T body0 time -> T body1 time)
-> (time -> time, T time body0 -> T time body1)
-> T time body0
-> T time body1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (time -> time, T body0 time -> T body1 time)
-> T body0 time -> T body1 time
forall b a0 a1. (b -> b, T a0 b -> T a1 b) -> T a0 b -> T a1 b
Mixed.mapSecondL ((time -> time, T body0 time -> T body1 time)
 -> T body0 time -> T body1 time)
-> ((time -> time, T time body0 -> T time body1)
    -> (time -> time, T body0 time -> T body1 time))
-> (time -> time, T time body0 -> T time body1)
-> T body0 time
-> T body1 time
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((T time body0 -> T time body1) -> T body0 time -> T body1 time)
-> (time -> time, T time body0 -> T time body1)
-> (time -> time, T body0 time -> T body1 time)
forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd (T time body0 -> T time body1) -> T body0 time -> T body1 time
forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T body0 time0 -> T body1 time1
BodyTimePriv.unlift

mapTimeHead ::
   (time -> time) ->
   T time body -> T time body
mapTimeHead :: forall time body. (time -> time) -> T time body -> T time body
mapTimeHead = (T body time -> T body time) -> T time body -> T time body
forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift ((T body time -> T body time) -> T time body -> T time body)
-> ((time -> time) -> T body time -> T body time)
-> (time -> time)
-> T time body
-> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (time -> time) -> T body time -> T body time
forall b a. (b -> b) -> T a b -> T a b
Mixed.mapSecondHead

mapTimeTail ::
   (BodyTimeList.T time body0 -> BodyTimeList.T time body1) ->
   T time body0 -> T time body1
mapTimeTail :: forall time body0 body1.
(T time body0 -> T time body1) -> T time body0 -> T time body1
mapTimeTail T time body0 -> T time body1
f =
   (time -> T time body0 -> T time body1)
-> T time body0 -> T time body1
forall time body a. (time -> T time body -> a) -> T time body -> a
switchTimeL (\time
time -> time -> T time body1 -> T time body1
forall time body. time -> T time body -> T time body
consTime time
time (T time body1 -> T time body1)
-> (T time body0 -> T time body1) -> T time body0 -> T time body1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body0 -> T time body1
f)
{-
This causes a memory leak when used with chunky time values.
I have found this problem in synthesizer-alsa:EventList.MIDI.matchNote,
but I could not reliably reproduce that in smaller setups.

mapTimeTail =
   lift . Mixed.mapSecondTail . BodyTimePriv.unlift
-}


mapTimeR ::
   (TimeBodyList.T time body0 -> TimeBodyList.T time body1, time -> time) ->
   T time body0 -> T time body1
mapTimeR :: forall time body0 body1.
(T time body0 -> T time body1, time -> time)
-> T time body0 -> T time body1
mapTimeR = (T body0 time -> T body1 time) -> T time body0 -> T time body1
forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift ((T body0 time -> T body1 time) -> T time body0 -> T time body1)
-> ((T time body0 -> T time body1, time -> time)
    -> T body0 time -> T body1 time)
-> (T time body0 -> T time body1, time -> time)
-> T time body0
-> T time body1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T time body0 -> T time body1, time -> time)
-> T body0 time -> T body1 time
forall b a0 a1. (T b a0 -> T b a1, b -> b) -> T a0 b -> T a1 b
Mixed.mapSecondR ((T time body0 -> T time body1, time -> time)
 -> T body0 time -> T body1 time)
-> ((T time body0 -> T time body1, time -> time)
    -> (T time body0 -> T time body1, time -> time))
-> (T time body0 -> T time body1, time -> time)
-> T body0 time
-> T body1 time
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((T time body0 -> T time body1) -> T time body0 -> T time body1)
-> (T time body0 -> T time body1, time -> time)
-> (T time body0 -> T time body1, time -> time)
forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst (T time body0 -> T time body1) -> T time body0 -> T time body1
forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
TimeBodyPriv.unlift

mapTimeLast ::
   (time -> time) ->
   T time body -> T time body
mapTimeLast :: forall time body. (time -> time) -> T time body -> T time body
mapTimeLast = (T body time -> T body time) -> T time body -> T time body
forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift ((T body time -> T body time) -> T time body -> T time body)
-> ((time -> time) -> T body time -> T body time)
-> (time -> time)
-> T time body
-> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (time -> time) -> T body time -> T body time
forall b a. (b -> b) -> T a b -> T a b
Mixed.mapSecondLast

mapTimeInit ::
   (TimeBodyList.T time body0 -> TimeBodyList.T time body1) ->
   T time body0 -> T time body1
mapTimeInit :: forall time body0 body1.
(T time body0 -> T time body1) -> T time body0 -> T time body1
mapTimeInit = (T body0 time -> T body1 time) -> T time body0 -> T time body1
forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift ((T body0 time -> T body1 time) -> T time body0 -> T time body1)
-> ((T time body0 -> T time body1) -> T body0 time -> T body1 time)
-> (T time body0 -> T time body1)
-> T time body0
-> T time body1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T time body0 -> T time body1) -> T body0 time -> T body1 time
forall b a0 a1. (T b a0 -> T b a1) -> T a0 b -> T a1 b
Mixed.mapSecondInit ((T time body0 -> T time body1) -> T body0 time -> T body1 time)
-> ((T time body0 -> T time body1) -> T time body0 -> T time body1)
-> (T time body0 -> T time body1)
-> T body0 time
-> T body1 time
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T time body0 -> T time body1) -> T time body0 -> T time body1
forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
TimeBodyPriv.unlift


foldr :: (time -> a -> b) -> (body -> b -> a) -> a -> T time body -> b
foldr :: forall time a b body.
(time -> a -> b) -> (body -> b -> a) -> a -> T time body -> b
foldr time -> a -> b
f body -> b -> a
g a
x = (body -> b -> a) -> (time -> a -> b) -> a -> T body time -> b
forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> c
Uniform.foldr body -> b -> a
g time -> a -> b
f a
x (T body time -> b)
-> (T time body -> T body time) -> T time body -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
forall time body. T time body -> T body time
decons

forceTimeHead :: (NonNeg.C time) =>
   T time body -> T time body
forceTimeHead :: forall time body. C time => T time body -> T time body
forceTimeHead =
   (time -> time) -> T time body -> T time body
forall time body. (time -> time) -> T time body -> T time body
mapTimeHead time -> time
forall a. a -> a
id

delay :: (NonNeg.C time) =>
   time -> T time body -> T time body
delay :: forall time body. C time => time -> T time body -> T time body
delay time
dif =
   (time -> time) -> T time body -> T time body
forall time body. (time -> time) -> T time body -> T time body
mapTimeHead (time -> time -> time
forall a. C a => a -> a -> a
add time
dif)

flatten :: (NonNeg.C time) => T time [body] -> T time body
flatten :: forall time body. C time => T time [body] -> T time body
flatten =
   T body time -> T time body
forall time body. T body time -> T time body
Cons (T body time -> T time body)
-> (T time [body] -> T body time) -> T time [body] -> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   ([body] -> T body time -> T body time)
-> (time -> T body time -> T body time)
-> T body time
-> T [body] time
-> T body time
forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> c
Uniform.foldr
      (T time body -> T body time -> T body time
forall a b. T a b -> T b a -> T b a
Mixed.appendUniformUniform (T time body -> T body time -> T body time)
-> ([body] -> T time body) -> [body] -> T body time -> T body time
forall b c a. (b -> c) -> (a -> b) -> a -> c
. time -> [body] -> T time body
forall a b. a -> [b] -> T a b
Uniform.fromSecondList time
forall a. C a => a
zero)
      time -> T body time -> T body time
forall b a. b -> T a b -> T a b
Mixed.consSecond    -- consTime
      T body time
forall a b. T a b
Disp.empty (T [body] time -> T body time)
-> (T time [body] -> T [body] time) -> T time [body] -> T body time
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
--      (\(b:bs) xs -> consBody b (List.foldr (cons 0) xs bs)) empty .
   ([time] -> time) -> T [body] [time] -> T [body] time
forall b0 b1 a. (b0 -> b1) -> T a b0 -> T a b1
Uniform.mapSecond [time] -> time
forall a. C a => [a] -> a
NonNeg.sum (T [body] [time] -> T [body] time)
-> (T time [body] -> T [body] [time])
-> T time [body]
-> T [body] time
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   ([body] -> Bool) -> T [body] time -> T [body] [time]
forall a b. (a -> Bool) -> T a b -> T a [b]
Uniform.filterFirst (Bool -> Bool
not (Bool -> Bool) -> ([body] -> Bool) -> [body] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [body] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) (T [body] time -> T [body] [time])
-> (T time [body] -> T [body] time)
-> T time [body]
-> T [body] [time]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   T time [body] -> T [body] time
forall time body. T time body -> T body time
decons