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

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

-- 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 Test.QuickCheck (Arbitrary(arbitrary, shrink))


newtype T time body = Cons {forall time body. T time body -> T time body
decons :: Uniform.T time body}
   deriving (T time body -> T time body -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall time body.
(Eq body, Eq time) =>
T time body -> T time body -> Bool
/= :: T time body -> T time body -> Bool
$c/= :: forall time body.
(Eq body, Eq time) =>
T time body -> T time body -> Bool
== :: T time body -> T time body -> Bool
$c== :: forall time body.
(Eq body, Eq time) =>
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 body, Ord time) => Eq (T time body)
forall time body.
(Ord body, Ord time) =>
T time body -> T time body -> Bool
forall time body.
(Ord body, Ord time) =>
T time body -> T time body -> Ordering
forall time body.
(Ord body, Ord time) =>
T time body -> T time body -> T time body
min :: T time body -> T time body -> T time body
$cmin :: forall time body.
(Ord body, Ord time) =>
T time body -> T time body -> T time body
max :: T time body -> T time body -> T time body
$cmax :: forall time body.
(Ord body, Ord time) =>
T time body -> T time body -> T time body
>= :: T time body -> T time body -> Bool
$c>= :: forall time body.
(Ord body, Ord time) =>
T time body -> T time body -> Bool
> :: T time body -> T time body -> Bool
$c> :: forall time body.
(Ord body, Ord time) =>
T time body -> T time body -> Bool
<= :: T time body -> T time body -> Bool
$c<= :: forall time body.
(Ord body, Ord time) =>
T time body -> T time body -> Bool
< :: T time body -> T time body -> Bool
$c< :: forall time body.
(Ord body, Ord time) =>
T time body -> T time body -> Bool
compare :: T time body -> T time body -> Ordering
$ccompare :: forall time body.
(Ord body, Ord time) =>
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 time body
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 time body -> T time body
Cons forall a. Arbitrary a => Gen a
arbitrary
   shrink :: T time body -> [T time body]
shrink = forall (m :: * -> *) time0 body0 time1 body1.
Monad m =>
(T time0 body0 -> m (T time1 body1))
-> T time0 body0 -> m (T time1 body1)
liftM forall a. Arbitrary a => a -> [a]
shrink


{-
instance Monoid (T time body) where

mempty cannot be defined

mappend could be defined by inserting a time difference of zero
-}

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) = forall time body. T time body -> T time body
Cons (forall b0 b1 a. (b0 -> b1) -> T a b0 -> T a b1
Uniform.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 = 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 time body -> 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 forall (f :: * -> *) a. Applicative f => a -> f a
App.pure a -> f b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons


infixl 5 $**

($**) :: (Uniform.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 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons


lift ::
   (Uniform.T time0 body0 -> Uniform.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 = forall time body. T time body -> T time body
Cons 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 time body -> T time body
decons

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

unlift ::
   (T time0 body0 -> T time1 body1) ->
   (Uniform.T time0 body0 -> Uniform.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 = forall time body. T time body -> T time body
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 time body -> T time body
Cons