{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE NamedFieldPuns #-}

-- | Hedgehog generators for the timeline library.
module Data.Timeline.Hedgehog
  ( -- * Timeline Generators
    gen,
    genRecord,
  )
where

import Data.Timeline
import Hedgehog (MonadGen)
import Hedgehog.Gen qualified as Gen
import Hedgehog.Range qualified as Range

-- | Generator for @'Timeline' a@
gen ::
  (MonadGen m, Ord t) =>
  m t ->
  -- | Generator for values
  m a ->
  m (Timeline t a)
gen :: forall (m :: * -> *) t a.
(MonadGen m, Ord t) =>
m t -> m a -> m (Timeline t a)
gen m t
genTime m a
genValue = do
  a
initialValue <- m a
genValue
  Map t a
values <- Range Int -> m (t, a) -> m (Map t a)
forall (m :: * -> *) k v.
(MonadGen m, Ord k) =>
Range Int -> m (k, v) -> m (Map k v)
Gen.map (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
20) (m (t, a) -> m (Map t a)) -> m (t, a) -> m (Map t a)
forall a b. (a -> b) -> a -> b
$ (,) (t -> a -> (t, a)) -> m t -> m (a -> (t, a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m t
genTime m (a -> (t, a)) -> m a -> m (t, a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m a
genValue
  Timeline t a -> m (Timeline t a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Timeline {a
initialValue :: a
$sel:initialValue:Timeline :: a
initialValue, Map t a
values :: Map t a
$sel:values:Timeline :: Map t a
values}

-- | Generator for @'Record' a@
genRecord ::
  (MonadGen m, Ord t) =>
  m t ->
  -- | Generator for the value
  m a ->
  m (Record t a)
genRecord :: forall (m :: * -> *) t a.
(MonadGen m, Ord t) =>
m t -> m a -> m (Record t a)
genRecord m t
genTime m a
genValue =
  m (Maybe (Record t a)) -> m (Record t a)
forall (m :: * -> *) a. MonadGen m => m (Maybe a) -> m a
Gen.justT (m (Maybe (Record t a)) -> m (Record t a))
-> m (Maybe (Record t a)) -> m (Record t a)
forall a b. (a -> b) -> a -> b
$ do
    t
t1 <- m t
genTime
    Maybe t
t2 <- m t -> m (Maybe t)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe (m t -> m (Maybe t)) -> m t -> m (Maybe t)
forall a b. (a -> b) -> a -> b
$ (t -> Bool) -> m t -> m t
forall (m :: * -> *) a. MonadGen m => (a -> Bool) -> m a -> m a
Gen.filterT (t -> t -> Bool
forall a. Eq a => a -> a -> Bool
/= t
t1) m t
genTime
    t -> Maybe t -> a -> Maybe (Record t a)
forall t a. Ord t => t -> Maybe t -> a -> Maybe (Record t a)
makeRecord t
t1 Maybe t
t2 (a -> Maybe (Record t a)) -> m a -> m (Maybe (Record t a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m a
genValue