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

Maintainer  :  haskell@henning-thielemann.de
Stability   :  stable
Portability :  Haskell 98
-}
module Data.EventList.Relative.BodyTimePrivate 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 Data.Monoid (Monoid, mempty, mappend, )
import Data.Semigroup (Semigroup, (<>), )

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



newtype T time body = Cons {forall time body. T time body -> T body time
decons :: Disp.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 body, Eq time) =>
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
/= :: 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 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
$ccompare :: forall time body.
(Ord body, Ord time) =>
T time body -> T time body -> Ordering
compare :: T time body -> T time body -> Ordering
$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
>= :: T time body -> T time body -> Bool
$cmax :: 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
$cmin :: 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
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
Disp.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 Semigroup (T time body) where
   Cons T body time
x <> :: T time body -> T time body -> T time body
<> Cons T body time
y = T body time -> T time body
forall time body. T body time -> T time body
Cons (T body time -> T body time -> T body time
forall a b. T a b -> T a b -> T a b
Disp.append T body time
x T body time
y)

instance 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 T body time
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 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
Disp.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)
Disp.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 $*~

($*~) :: (Disp.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 ::
   (Disp.T body0 time0 -> Disp.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 :: App.Applicative m =>
   (Disp.T body0 time0 -> m (Disp.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 =>
   (Disp.T body0 time0 -> m (Disp.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) ->
   (Disp.T body0 time0 -> Disp.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



-- mconcat
concat :: -- (NonNeg.C time) =>
   [T time body] -> T time body
concat :: forall time body. [T time body] -> T time body
concat =
   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
. [T body time] -> T body time
forall a b. [T a b] -> T a b
Disp.concat ([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) -> [T time body] -> [T body time]
forall a b. (a -> b) -> [a] -> [b]
map T time body -> T body time
forall time body. T time body -> T body time
decons


-- mcycle - if it would be a standard function
cycle :: -- (NonNeg.C time) =>
   T time body -> T time body
cycle :: forall time body. T time body -> T time body
cycle = (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
forall a b. T a b -> T a b
Disp.cycle


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 a b. (a -> a) -> T b a -> T b a
Mixed.mapFirstLast