module Hedgehog.Golden.Sample
  ( genSamples
  ) where

import           Prelude

import           Data.Sequence (Seq)
import           Hedgehog
import qualified Hedgehog.Internal.Gen as Gen
import qualified Hedgehog.Internal.Tree as Tree
import qualified Hedgehog.Range as Range

-- | Generate a fixed Seq of @a@ from the given generator
genSamples :: Seed -> Gen a -> Seq a
genSamples :: Seed -> Gen a -> Seq a
genSamples Seed
seed Gen a
gen =
  let
    loop :: t -> Maybe (Tree (Seq a)) -> Seq a
loop t
n = \case
      Just Tree (Seq a)
tree -> Tree (Seq a) -> Seq a
forall a. Tree a -> a
Tree.treeValue Tree (Seq a)
tree
      Maybe (Tree (Seq a))
Nothing ->
        if t
n t -> t -> Bool
forall a. Ord a => a -> a -> Bool
< t
0 then
          [Char] -> Seq a
forall a. HasCallStack => [Char] -> a
error [Char]
"Too many discards - abandoned generating samples"
        else
          t -> Maybe (Tree (Seq a)) -> Seq a
loop (t
n t -> t -> t
forall a. Num a => a -> a -> a
- t
1) (Maybe (Tree (Seq a)) -> Seq a)
-> (Gen (Seq a) -> Maybe (Tree (Seq a))) -> Gen (Seq a) -> Seq a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Size -> Seed -> Gen (Seq a) -> Maybe (Tree (Seq a))
forall a. Size -> Seed -> Gen a -> Maybe (Tree a)
Gen.evalGen Size
0 Seed
seed (Gen (Seq a) -> Seq a) -> Gen (Seq a) -> Seq a
forall a b. (a -> b) -> a -> b
$ Range Int -> Gen a -> Gen (Seq a)
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m (Seq a)
Gen.seq (Int -> Range Int
forall a. a -> Range a
Range.singleton Int
10) Gen a
gen
  in
    Int -> Maybe (Tree (Seq a)) -> Seq a
forall t. (Ord t, Num t) => t -> Maybe (Tree (Seq a)) -> Seq a
loop (Int
100 :: Int) Maybe (Tree (Seq a))
forall a. Maybe a
Nothing