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

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

import qualified Data.EventList.Relative.BodyBodyPrivate as BodyBodyList
import qualified Data.EventList.Relative.BodyBodyPrivate as BodyBodyPriv

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 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, )
import Data.Semigroup (Semigroup, (<>), )

import Data.Tuple.HT (mapSnd, )

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



newtype T time body = Cons {forall time body. T time body -> T time body
decons :: Disp.T time body}
   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 time body -> ShowS
forall a b.
(Show a, Show b) =>
String -> String -> Int -> T a b -> ShowS
Disp.format String
" /. " String
" ./ " Int
p (T time body -> ShowS)
-> (T time body -> T time body) -> T time body -> ShowS
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
decons


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

instance Semigroup (T time body) where
   Cons T time body
x <> :: T time body -> T time body -> T time body
<> Cons T time body
y = T time body -> T time body
forall time body. T time body -> T time body
Cons (T time body -> T time body -> T time body
forall a b. T a b -> T a b -> T a b
Disp.append T time body
x T time body
y)

instance Monoid (T time body) where
   mempty :: T time body
mempty = T time body -> T time body
forall time body. T time body -> T time body
Cons T time body
forall a b. T a b
Disp.empty
   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
(<>)

instance Functor (T time) where
   fmap :: forall a b. (a -> b) -> T time a -> T time b
fmap a -> b
f (Cons T time a
x) = T time b -> T time b
forall time body. T time body -> T time body
Cons ((a -> b) -> T time a -> T time b
forall b0 b1 a. (b0 -> b1) -> T a b0 -> T a b1
Disp.mapSecond a -> b
f T time a
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 time b -> T time b) -> f (T time b) -> f (T time b)
forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
App.liftA T time b -> T time b
forall time body. T time body -> T time body
Cons (f (T time b) -> f (T time b))
-> (T time a -> f (T time b)) -> T time a -> f (T time b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (time -> f time) -> (a -> f b) -> T time a -> f (T time b)
forall (m :: * -> *) a0 a1 b0 b1.
Applicative m =>
(a0 -> m a1) -> (b0 -> m b1) -> T a0 b0 -> m (T a1 b1)
Disp.traverse time -> f time
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
App.pure a -> f b
f (T time a -> f (T time b))
-> (T time a -> T time a) -> T time a -> f (T time b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time a -> T time a
forall time body. T time body -> T time body
decons


infixl 5 $~*

($~*) :: (Disp.T time body -> a) -> (T time body -> a)
$~* :: forall time body a. (T time body -> a) -> T time body -> a
($~*) T time body -> a
f = T time body -> a
f (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
decons


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

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

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

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



mapTimeL ::
   (time -> time, BodyBodyList.T time body0 -> BodyBodyList.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 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
lift ((T time body0 -> T time body1) -> T time body0 -> T time body1)
-> ((time -> time, T time body0 -> T time body1)
    -> T time body0 -> T time body1)
-> (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 time body0 -> T time body1)
-> T time body0 -> T time body1
forall a b0 b1. (a -> a, T a b0 -> T a b1) -> T a b0 -> T a b1
Mixed.mapFirstL ((time -> time, T time body0 -> T time body1)
 -> 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 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 time body0 -> T time body1)
-> (time -> 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)
mapSnd (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
BodyBodyPriv.unlift

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

mapTimeTail ::
   (BodyBodyList.T time body0 -> BodyBodyList.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) -> T time body0 -> T time body1
forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
lift ((T time body0 -> T time body1) -> T time body0 -> T time body1)
-> ((T time body0 -> T time body1) -> T time body0 -> 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) -> T time body0 -> T time body1
forall a b0 b1. (T a b0 -> T a b1) -> T a b0 -> T a b1
Mixed.mapFirstTail ((T time body0 -> T time body1) -> T time body0 -> T time body1)
-> ((T time body0 -> T time body1) -> T time body0 -> 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) -> T time body0 -> T time body1
forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
BodyBodyPriv.unlift