{- |
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
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
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
$c== :: forall time body.
(Eq time, Eq body) =>
T time body -> T time body -> Bool
Eq, 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
min :: 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
max :: T time body -> T time body -> T time body
$cmax :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> T time body
>= :: 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
$c< :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> Bool
compare :: T time body -> T time body -> Ordering
$ccompare :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> Ordering
Ord)


instance (Show time, Show body) => Show (T time body) where
   showsPrec :: Int -> T time body -> ShowS
showsPrec Int
p = forall a b.
(Show a, Show b) =>
String -> String -> Int -> T a b -> ShowS
Uniform.format String
" ./ " String
" /. " Int
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Monad.liftM forall time body. T body time -> T time body
Cons forall a. Arbitrary a => Gen a
arbitrary
   shrink :: T time body -> [T time body]
shrink = forall (m :: * -> *) body0 time0 body1 time1.
Monad m =>
(T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
liftM 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
(<>) = 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 = forall time body. T body time -> T time body
Cons (forall b a. b -> T a b
Uniform.singleton forall a. C a => a
zero)
   mappend :: T time body -> T time body -> T time body
mappend = forall a. Semigroup a => a -> a -> a
(<>)
   mconcat :: [T time body] -> T time body
mconcat =
      forall time body. C time => T time [body] -> T time body
flatten forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. time -> T time body -> T time body
consTime forall a. C a => a
zero forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      forall a. Monoid a => [a] -> a
mconcat forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      forall a b. (a -> b) -> [a] -> [b]
map (forall body time. body -> T time body -> T time body
consBody [] forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (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 =
   forall time body. C time => T time body -> T time body
forceTimeHead forall a b. (a -> b) -> a -> b
$
   forall time a b body.
(time -> a -> b) -> (body -> b -> a) -> a -> T time body -> b
foldr
      forall time body. C time => time -> T time body -> T time body
delay
      (\body
b ->
         forall time body. time -> T time body -> T time body
consTime forall a. C a => a
NonNeg.zero forall b c a. (b -> c) -> (a -> b) -> a -> c
.
         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 =
   forall time a b body.
(time -> a -> b) -> (body -> b -> a) -> a -> T time body -> b
foldr
      (\time
t ->
         forall time body. C time => time -> T time body -> T time body
delay time
t forall b c a. (b -> c) -> (a -> b) -> a -> c
.
         forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. a -> a
id (forall time body. time -> T time body -> T time body
consTime forall a. C a => a
NonNeg.zero))
      (\body
b -> forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall body time. body -> T time body -> T time body
consBody body
b)
      (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 =
   forall time body a. (T time body -> time -> a) -> T time body -> a
switchTimeR
      (\ T time body
xs time
t ->
         forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift (forall b a. T b a -> T a b -> T a b
Mixed.appendDisparateUniform forall time body a. (T time body -> a) -> T time body -> a
$~* T time body
xs) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
         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) = forall time body. T body time -> T time body
Cons (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 = 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 =
      forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
App.liftA forall time body. T body time -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 forall (f :: * -> *) a. Applicative f => a -> f a
App.pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall time body. T body time -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body0 time0 -> T body1 time1
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
App.liftA forall time body. T body time -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body0 time0 -> m (T body1 time1)
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Monad.liftM forall time body. T body time -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body0 time0 -> m (T body1 time1)
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall time body. T time body -> T body time
decons forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time0 body0 -> T time1 body1
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall time body. T body time -> T time body
BodyTimePriv.Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> T a b -> T a b
Mixed.consFirst body
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall time body. T body time -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. b -> T a b -> T a b
Mixed.consSecond time
t forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd forall time body. T body time -> T time body
BodyTimePriv.Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> (b, T a b)
Mixed.viewSecondL forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd forall time body. T body time -> T time body
Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> Maybe (a, T a b)
Mixed.viewFirstL forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst forall time body. T time body -> T time body
TimeBodyPriv.Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> (T b a, b)
Mixed.viewSecondR forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst forall time body. T body time -> T time body
Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. T b a -> Maybe (T a b, a)
Mixed.viewFirstR forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 =
   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 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T body time -> T time body
BodyTimePriv.Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 =
   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 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T body time -> T time body
Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall b a c. (T b a -> b -> c) -> T a b -> c
Mixed.switchSecondR (T time body -> time -> a
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
TimeBodyPriv.Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall c a b. c -> (T a b -> a -> c) -> T b a -> c
Mixed.switchFirstR a
f (T time body -> body -> a
g forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T body time -> T time body
Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a0 a1. (b -> b, T a0 b -> T a1 b) -> T a0 b -> T a1 b
Mixed.mapSecondL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd 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 = forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 =
   forall time body a. (time -> T time body -> a) -> T time body -> a
switchTimeL (\time
time -> forall time body. time -> T time body -> T time body
consTime time
time 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 = forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a0 a1. (T b a0 -> T b a1, b -> b) -> T a0 b -> T a1 b
Mixed.mapSecondR forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst 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 = forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a0 a1. (T b a0 -> T b a1) -> T a0 b -> T a1 b
Mixed.mapSecondInit forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = 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 forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 =
   forall time body. (time -> time) -> T time body -> T time body
mapTimeHead 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 =
   forall time body. (time -> time) -> T time body -> T time body
mapTimeHead (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 =
   forall time body. T body time -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> c
Uniform.foldr
      (forall a b. T a b -> T b a -> T b a
Mixed.appendUniformUniform forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> [b] -> T a b
Uniform.fromSecondList forall a. C a => a
zero)
      forall b a. b -> T a b -> T a b
Mixed.consSecond    -- consTime
      forall a b. T a b
Disp.empty forall b c a. (b -> c) -> (a -> b) -> a -> c
.
--      (\(b:bs) xs -> consBody b (List.foldr (cons 0) xs bs)) empty .
   forall b0 b1 a. (b0 -> b1) -> T a b0 -> T a b1
Uniform.mapSecond forall a. C a => [a] -> a
NonNeg.sum forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a b. (a -> Bool) -> T a b -> T a [b]
Uniform.filterFirst (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> Bool
null) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall time body. T time body -> T body time
decons