{-# LANGUAGE UndecidableInstances #-}

module Test.Dahdit.GenDefault
  ( genSigned
  , genUnsigned
  , genFractional
  , genEnum
  , genSum
  , genList
  , genSeq
  , genString
  , genSBS
  , genText
  , LengthBounds (..)
  , DahditTag
  )
where

import Dahdit
  ( BoolByte (..)
  , DoubleBE (..)
  , DoubleLE (..)
  , ExactBytes (..)
  , FloatBE (..)
  , FloatLE (..)
  , Int16BE (..)
  , Int16LE (..)
  , Int32BE (..)
  , Int32LE (..)
  , Int64BE (..)
  , Int64LE (..)
  , StaticBytes (..)
  , StaticSeq (..)
  , TermBytes16 (..)
  , TermBytes8 (..)
  , Word16BE (..)
  , Word16LE (..)
  , Word32BE (..)
  , Word32LE (..)
  , Word64BE (..)
  , Word64LE (..)
  )
import Data.ByteString.Internal (w2c)
import Data.ByteString.Short (ShortByteString)
import Data.ByteString.Short qualified as BSS
import Data.Int (Int16, Int32, Int64, Int8)
import Data.IntMap (IntMap)
import Data.IntMap qualified as IntMap
import Data.IntSet (IntSet)
import Data.IntSet qualified as IntSet
import Data.List.NonEmpty (NonEmpty (..))
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Proxy (Proxy (..))
import Data.Ratio ((%))
import Data.Sequence (Seq)
import Data.Sequence qualified as Seq
import Data.Set (Set)
import Data.Set qualified as Set
import Data.Text (Text)
import Data.Text qualified as T
import Data.Word (Word16, Word32, Word64, Word8)
import GHC.TypeLits (KnownNat, natVal)
import PropUnit (Gen, GenDefault (..), genDefaultGeneric)
import PropUnit.Hedgehog.Gen qualified as Gen
import PropUnit.Hedgehog.Range qualified as Range

genPrintableChar :: Gen Char
genPrintableChar :: Gen Char
genPrintableChar = (Word8 -> Char) -> GenT Identity Word8 -> Gen Char
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word8 -> Char
w2c (Range Word8 -> GenT Identity Word8
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Word8 -> Word8 -> Range Word8
forall a. a -> a -> Range a
Range.constant Word8
32 Word8
126))

genSigned :: (Integral a, Bounded a) => Gen a
genSigned :: forall a. (Integral a, Bounded a) => Gen a
genSigned = Range a -> GenT Identity a
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (a -> a -> a -> Range a
forall a. a -> a -> a -> Range a
Range.constantFrom a
0 a
forall a. Bounded a => a
minBound a
forall a. Bounded a => a
maxBound)

genUnsigned :: (Integral a, Bounded a) => Gen a
genUnsigned :: forall a. (Integral a, Bounded a) => Gen a
genUnsigned = Range a -> GenT Identity a
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (a -> a -> Range a
forall a. a -> a -> Range a
Range.constant a
0 a
forall a. Bounded a => a
maxBound)

genFractional :: (Fractional a) => Gen a
genFractional :: forall a. Fractional a => Gen a
genFractional = do
  -- Picked so bound**2 fits in int
  let bound :: Int
bound = Int
3037000499 :: Int
  Int
n <- Range Int -> GenT Identity Int
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
bound)
  Int
b <- Range Int -> GenT Identity Int
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
bound)
  Int
a <- Range Int -> GenT Identity Int
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Int -> Int -> Int -> Range Int
forall a. a -> a -> a -> Range a
Range.constantFrom Int
0 ((-Int
n) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
b) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
b))
  a -> Gen a
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> a
forall a. Fractional a => Rational -> a
fromRational (Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
b))

genEnum :: (Enum a, Bounded a) => Gen a
genEnum :: forall a. (Enum a, Bounded a) => Gen a
genEnum = GenT Identity a
forall (m :: * -> *) a. (MonadGen m, Enum a, Bounded a) => m a
Gen.enumBounded

genSum :: NonEmpty (Gen a) -> Gen a
genSum :: forall a. NonEmpty (Gen a) -> Gen a
genSum (Gen a
g :| [Gen a]
gs) = [Gen a] -> Gen a
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice (Gen a
g Gen a -> [Gen a] -> [Gen a]
forall a. a -> [a] -> [a]
: [Gen a]
gs)

genList :: Word -> Word -> Gen a -> Gen [a]
genList :: forall a. Word -> Word -> Gen a -> Gen [a]
genList Word
mn Word
mx = Range Int -> GenT Identity a -> GenT Identity [a]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant (Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
mn) (Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
mx))

genSeq :: Word -> Word -> Gen a -> Gen (Seq a)
genSeq :: forall a. Word -> Word -> Gen a -> Gen (Seq a)
genSeq Word
mn Word
mx = ([a] -> Seq a) -> GenT Identity [a] -> GenT Identity (Seq a)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> Seq a
forall a. [a] -> Seq a
Seq.fromList (GenT Identity [a] -> GenT Identity (Seq a))
-> (Gen a -> GenT Identity [a]) -> Gen a -> GenT Identity (Seq a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Word -> Gen a -> GenT Identity [a]
forall a. Word -> Word -> Gen a -> Gen [a]
genList Word
mn Word
mx

genString :: Word -> Word -> Gen String
genString :: Word -> Word -> Gen String
genString Word
mn Word
mx = Word -> Word -> Gen Char -> Gen String
forall a. Word -> Word -> Gen a -> Gen [a]
genList Word
mn Word
mx Gen Char
genPrintableChar

genSBS :: Word -> Word -> Gen ShortByteString
genSBS :: Word -> Word -> Gen ShortByteString
genSBS Word
mn Word
mx = ([Word8] -> ShortByteString)
-> GenT Identity [Word8] -> Gen ShortByteString
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Word8] -> ShortByteString
BSS.pack (Word -> Word -> GenT Identity Word8 -> GenT Identity [Word8]
forall a. Word -> Word -> Gen a -> Gen [a]
genList Word
mn Word
mx GenT Identity Word8
forall a. (Integral a, Bounded a) => Gen a
genUnsigned)

genText :: Word -> Word -> Gen Text
genText :: Word -> Word -> Gen Text
genText Word
mn Word
mx = (String -> Text) -> Gen String -> Gen Text
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> Text
T.pack (Word -> Word -> Gen String
genString Word
mn Word
mx)

newtype ViaSigned a = ViaSigned {forall a. ViaSigned a -> a
unViaSigned :: a}

instance (Integral a, Bounded a) => GenDefault p (ViaSigned a) where
  genDefault :: Proxy p -> Gen (ViaSigned a)
genDefault Proxy p
_ = (a -> ViaSigned a) -> GenT Identity a -> Gen (ViaSigned a)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> ViaSigned a
forall a. a -> ViaSigned a
ViaSigned GenT Identity a
forall a. (Integral a, Bounded a) => Gen a
genSigned

newtype ViaUnsigned a = ViaUnsigned {forall a. ViaUnsigned a -> a
unViaUnsigned :: a}

instance (Integral a, Bounded a) => GenDefault p (ViaUnsigned a) where
  genDefault :: Proxy p -> Gen (ViaUnsigned a)
genDefault Proxy p
_ = (a -> ViaUnsigned a) -> GenT Identity a -> Gen (ViaUnsigned a)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> ViaUnsigned a
forall a. a -> ViaUnsigned a
ViaUnsigned GenT Identity a
forall a. (Integral a, Bounded a) => Gen a
genUnsigned

newtype ViaFractional a = ViaFractional {forall a. ViaFractional a -> a
unViaFractional :: a}

instance (Fractional a) => GenDefault p (ViaFractional a) where
  genDefault :: Proxy p -> Gen (ViaFractional a)
genDefault Proxy p
_ = (a -> ViaFractional a) -> GenT Identity a -> Gen (ViaFractional a)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> ViaFractional a
forall a. a -> ViaFractional a
ViaFractional GenT Identity a
forall a. Fractional a => Gen a
genFractional

class LengthBounds p a where
  lengthBounds :: Proxy p -> Proxy a -> (Word, Word)

proxyForRange :: (x -> b) -> Proxy b
proxyForRange :: forall x b. (x -> b) -> Proxy b
proxyForRange x -> b
_ = Proxy b
forall {k} (t :: k). Proxy t
Proxy

genListLike :: (LengthBounds p b, GenDefault p a) => ([a] -> b) -> Proxy p -> Gen b
genListLike :: forall p b a.
(LengthBounds p b, GenDefault p a) =>
([a] -> b) -> Proxy p -> Gen b
genListLike [a] -> b
f Proxy p
p =
  let (Word
mn, Word
mx) = Proxy p -> Proxy b -> (Word, Word)
forall {k} {k} (p :: k) (a :: k).
LengthBounds p a =>
Proxy p -> Proxy a -> (Word, Word)
lengthBounds Proxy p
p (([a] -> b) -> Proxy b
forall x b. (x -> b) -> Proxy b
proxyForRange [a] -> b
f)
  in  ([a] -> b) -> GenT Identity [a] -> GenT Identity b
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> b
f (Word -> Word -> Gen a -> GenT Identity [a]
forall a. Word -> Word -> Gen a -> Gen [a]
genList Word
mn Word
mx (Proxy p -> Gen a
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault Proxy p
p))

data DahditTag p

type D = DahditTag

instance GenDefault (D p) Word8 where
  genDefault :: Proxy (D p) -> GenT Identity Word8
genDefault Proxy (D p)
_ = GenT Identity Word8
forall a. (Integral a, Bounded a) => Gen a
genUnsigned

instance GenDefault (D p) Int8 where
  genDefault :: Proxy (D p) -> Gen Int8
genDefault Proxy (D p)
_ = Gen Int8
forall a. (Integral a, Bounded a) => Gen a
genSigned

instance GenDefault (D p) Word16 where
  genDefault :: Proxy (D p) -> Gen Word16
genDefault Proxy (D p)
_ = Gen Word16
forall a. (Integral a, Bounded a) => Gen a
genUnsigned

instance GenDefault (D p) Int16 where
  genDefault :: Proxy (D p) -> Gen Int16
genDefault Proxy (D p)
_ = Gen Int16
forall a. (Integral a, Bounded a) => Gen a
genSigned

instance GenDefault (D p) Word32 where
  genDefault :: Proxy (D p) -> Gen Word32
genDefault Proxy (D p)
_ = Gen Word32
forall a. (Integral a, Bounded a) => Gen a
genUnsigned

instance GenDefault (D p) Int32 where
  genDefault :: Proxy (D p) -> Gen Int32
genDefault Proxy (D p)
_ = Gen Int32
forall a. (Integral a, Bounded a) => Gen a
genSigned

instance GenDefault (D p) Word64 where
  genDefault :: Proxy (D p) -> Gen Word64
genDefault Proxy (D p)
_ = Gen Word64
forall a. (Integral a, Bounded a) => Gen a
genUnsigned

instance GenDefault (D p) Int64 where
  genDefault :: Proxy (D p) -> Gen Int64
genDefault Proxy (D p)
_ = Gen Int64
forall a. (Integral a, Bounded a) => Gen a
genSigned

instance GenDefault (D p) Float where
  genDefault :: Proxy (D p) -> Gen Float
genDefault Proxy (D p)
_ = Gen Float
forall a. Fractional a => Gen a
genFractional

instance GenDefault (D p) Double where
  genDefault :: Proxy (D p) -> Gen Double
genDefault Proxy (D p)
_ = Gen Double
forall a. Fractional a => Gen a
genFractional

instance GenDefault (D p) Int where
  genDefault :: Proxy (D p) -> GenT Identity Int
genDefault Proxy (D p)
_ = GenT Identity Int
forall a. (Integral a, Bounded a) => Gen a
genSigned

instance GenDefault (D p) Word16LE where
  genDefault :: Proxy (D p) -> Gen Word16LE
genDefault = (Word16 -> Word16LE) -> Gen Word16 -> Gen Word16LE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word16 -> Word16LE
Word16LE (Gen Word16 -> Gen Word16LE)
-> (Proxy (D p) -> Gen Word16) -> Proxy (D p) -> Gen Word16LE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Word16
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Int16LE where
  genDefault :: Proxy (D p) -> Gen Int16LE
genDefault = (Int16 -> Int16LE) -> Gen Int16 -> Gen Int16LE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int16 -> Int16LE
Int16LE (Gen Int16 -> Gen Int16LE)
-> (Proxy (D p) -> Gen Int16) -> Proxy (D p) -> Gen Int16LE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Int16
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Word32LE where
  genDefault :: Proxy (D p) -> Gen Word32LE
genDefault = (Word32 -> Word32LE) -> Gen Word32 -> Gen Word32LE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word32 -> Word32LE
Word32LE (Gen Word32 -> Gen Word32LE)
-> (Proxy (D p) -> Gen Word32) -> Proxy (D p) -> Gen Word32LE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Word32
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Int32LE where
  genDefault :: Proxy (D p) -> Gen Int32LE
genDefault = (Int32 -> Int32LE) -> Gen Int32 -> Gen Int32LE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int32 -> Int32LE
Int32LE (Gen Int32 -> Gen Int32LE)
-> (Proxy (D p) -> Gen Int32) -> Proxy (D p) -> Gen Int32LE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Int32
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Word64LE where
  genDefault :: Proxy (D p) -> Gen Word64LE
genDefault = (Word64 -> Word64LE) -> Gen Word64 -> Gen Word64LE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word64 -> Word64LE
Word64LE (Gen Word64 -> Gen Word64LE)
-> (Proxy (D p) -> Gen Word64) -> Proxy (D p) -> Gen Word64LE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Word64
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Int64LE where
  genDefault :: Proxy (D p) -> Gen Int64LE
genDefault = (Int64 -> Int64LE) -> Gen Int64 -> Gen Int64LE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int64 -> Int64LE
Int64LE (Gen Int64 -> Gen Int64LE)
-> (Proxy (D p) -> Gen Int64) -> Proxy (D p) -> Gen Int64LE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Int64
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) FloatLE where
  genDefault :: Proxy (D p) -> Gen FloatLE
genDefault = (Float -> FloatLE) -> Gen Float -> Gen FloatLE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Float -> FloatLE
FloatLE (Gen Float -> Gen FloatLE)
-> (Proxy (D p) -> Gen Float) -> Proxy (D p) -> Gen FloatLE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Float
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) DoubleLE where
  genDefault :: Proxy (D p) -> Gen DoubleLE
genDefault = (Double -> DoubleLE) -> Gen Double -> Gen DoubleLE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Double -> DoubleLE
DoubleLE (Gen Double -> Gen DoubleLE)
-> (Proxy (D p) -> Gen Double) -> Proxy (D p) -> Gen DoubleLE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Double
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Word16BE where
  genDefault :: Proxy (D p) -> Gen Word16BE
genDefault = (Word16 -> Word16BE) -> Gen Word16 -> Gen Word16BE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word16 -> Word16BE
Word16BE (Gen Word16 -> Gen Word16BE)
-> (Proxy (D p) -> Gen Word16) -> Proxy (D p) -> Gen Word16BE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Word16
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Int16BE where
  genDefault :: Proxy (D p) -> Gen Int16BE
genDefault = (Int16 -> Int16BE) -> Gen Int16 -> Gen Int16BE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int16 -> Int16BE
Int16BE (Gen Int16 -> Gen Int16BE)
-> (Proxy (D p) -> Gen Int16) -> Proxy (D p) -> Gen Int16BE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Int16
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Word32BE where
  genDefault :: Proxy (D p) -> Gen Word32BE
genDefault = (Word32 -> Word32BE) -> Gen Word32 -> Gen Word32BE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word32 -> Word32BE
Word32BE (Gen Word32 -> Gen Word32BE)
-> (Proxy (D p) -> Gen Word32) -> Proxy (D p) -> Gen Word32BE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Word32
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Int32BE where
  genDefault :: Proxy (D p) -> Gen Int32BE
genDefault = (Int32 -> Int32BE) -> Gen Int32 -> Gen Int32BE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int32 -> Int32BE
Int32BE (Gen Int32 -> Gen Int32BE)
-> (Proxy (D p) -> Gen Int32) -> Proxy (D p) -> Gen Int32BE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Int32
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Word64BE where
  genDefault :: Proxy (D p) -> Gen Word64BE
genDefault = (Word64 -> Word64BE) -> Gen Word64 -> Gen Word64BE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word64 -> Word64BE
Word64BE (Gen Word64 -> Gen Word64BE)
-> (Proxy (D p) -> Gen Word64) -> Proxy (D p) -> Gen Word64BE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Word64
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Int64BE where
  genDefault :: Proxy (D p) -> Gen Int64BE
genDefault = (Int64 -> Int64BE) -> Gen Int64 -> Gen Int64BE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int64 -> Int64BE
Int64BE (Gen Int64 -> Gen Int64BE)
-> (Proxy (D p) -> Gen Int64) -> Proxy (D p) -> Gen Int64BE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Int64
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) FloatBE where
  genDefault :: Proxy (D p) -> Gen FloatBE
genDefault = (Float -> FloatBE) -> Gen Float -> Gen FloatBE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Float -> FloatBE
FloatBE (Gen Float -> Gen FloatBE)
-> (Proxy (D p) -> Gen Float) -> Proxy (D p) -> Gen FloatBE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Float
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) DoubleBE where
  genDefault :: Proxy (D p) -> Gen DoubleBE
genDefault = (Double -> DoubleBE) -> Gen Double -> Gen DoubleBE
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Double -> DoubleBE
DoubleBE (Gen Double -> Gen DoubleBE)
-> (Proxy (D p) -> Gen Double) -> Proxy (D p) -> Gen DoubleBE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Double
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) Char where
  genDefault :: Proxy (D p) -> Gen Char
genDefault = (Word8 -> Char) -> GenT Identity Word8 -> Gen Char
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word8 -> Char
w2c (GenT Identity Word8 -> Gen Char)
-> (Proxy (D p) -> GenT Identity Word8) -> Proxy (D p) -> Gen Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> GenT Identity Word8
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) () where
  genDefault :: Proxy (D p) -> Gen ()
genDefault = Proxy (D p) -> Gen ()
forall tag a.
(Generic a, GGenDefault tag (Rep a)) =>
Proxy tag -> Gen a
genDefaultGeneric

instance GenDefault (D p) Bool where
  genDefault :: Proxy (D p) -> Gen Bool
genDefault = Proxy (D p) -> Gen Bool
forall tag a.
(Generic a, GGenDefault tag (Rep a)) =>
Proxy tag -> Gen a
genDefaultGeneric

instance (GenDefault (D p) a) => GenDefault (D p) (Maybe a) where
  genDefault :: Proxy (D p) -> Gen (Maybe a)
genDefault = Proxy (D p) -> Gen (Maybe a)
forall tag a.
(Generic a, GGenDefault tag (Rep a)) =>
Proxy tag -> Gen a
genDefaultGeneric

instance (GenDefault (D p) a, GenDefault (D p) b) => GenDefault (D p) (Either a b) where
  genDefault :: Proxy (D p) -> Gen (Either a b)
genDefault = Proxy (D p) -> Gen (Either a b)
forall tag a.
(Generic a, GGenDefault tag (Rep a)) =>
Proxy tag -> Gen a
genDefaultGeneric

instance (GenDefault (D p) a, GenDefault (D p) b) => GenDefault (D p) (a, b) where
  genDefault :: Proxy (D p) -> Gen (a, b)
genDefault = Proxy (D p) -> Gen (a, b)
forall tag a.
(Generic a, GGenDefault tag (Rep a)) =>
Proxy tag -> Gen a
genDefaultGeneric

instance (GenDefault (D p) a, GenDefault (D p) b, GenDefault (D p) c) => GenDefault (D p) (a, b, c) where
  genDefault :: Proxy (D p) -> Gen (a, b, c)
genDefault = Proxy (D p) -> Gen (a, b, c)
forall tag a.
(Generic a, GGenDefault tag (Rep a)) =>
Proxy tag -> Gen a
genDefaultGeneric

instance (GenDefault (D p) a, GenDefault (D p) b, GenDefault (D p) c, GenDefault (D p) d) => GenDefault (D p) (a, b, c, d) where
  genDefault :: Proxy (D p) -> Gen (a, b, c, d)
genDefault = Proxy (D p) -> Gen (a, b, c, d)
forall tag a.
(Generic a, GGenDefault tag (Rep a)) =>
Proxy tag -> Gen a
genDefaultGeneric

instance
  (GenDefault (D p) a, GenDefault (D p) b, GenDefault (D p) c, GenDefault (D p) d, GenDefault (D p) e)
  => GenDefault (D p) (a, b, c, d, e)
  where
  genDefault :: Proxy (D p) -> Gen (a, b, c, d, e)
genDefault = Proxy (D p) -> Gen (a, b, c, d, e)
forall tag a.
(Generic a, GGenDefault tag (Rep a)) =>
Proxy tag -> Gen a
genDefaultGeneric

instance (LengthBounds (D p) [a], GenDefault (D p) a) => GenDefault (D p) [a] where
  genDefault :: Proxy (D p) -> Gen [a]
genDefault = ([a] -> [a]) -> Proxy (D p) -> Gen [a]
forall p b a.
(LengthBounds p b, GenDefault p a) =>
([a] -> b) -> Proxy p -> Gen b
genListLike [a] -> [a]
forall a. a -> a
id

instance (LengthBounds (D p) (Seq a), GenDefault (D p) a) => GenDefault (D p) (Seq a) where
  genDefault :: Proxy (D p) -> Gen (Seq a)
genDefault = ([a] -> Seq a) -> Proxy (D p) -> Gen (Seq a)
forall p b a.
(LengthBounds p b, GenDefault p a) =>
([a] -> b) -> Proxy p -> Gen b
genListLike [a] -> Seq a
forall a. [a] -> Seq a
Seq.fromList

instance (LengthBounds (D p) (Map a b), GenDefault (D p) a, GenDefault (D p) b, Ord a) => GenDefault (D p) (Map a b) where
  genDefault :: Proxy (D p) -> Gen (Map a b)
genDefault = ([(a, b)] -> Map a b) -> Proxy (D p) -> Gen (Map a b)
forall p b a.
(LengthBounds p b, GenDefault p a) =>
([a] -> b) -> Proxy p -> Gen b
genListLike [(a, b)] -> Map a b
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList

instance (LengthBounds (D p) (Set a), GenDefault (D p) a, Ord a) => GenDefault (D p) (Set a) where
  genDefault :: Proxy (D p) -> Gen (Set a)
genDefault = ([a] -> Set a) -> Proxy (D p) -> Gen (Set a)
forall p b a.
(LengthBounds p b, GenDefault p a) =>
([a] -> b) -> Proxy p -> Gen b
genListLike [a] -> Set a
forall a. Ord a => [a] -> Set a
Set.fromList

instance (LengthBounds (D p) IntSet) => GenDefault (D p) IntSet where
  genDefault :: Proxy (D p) -> Gen IntSet
genDefault = ([Int] -> IntSet) -> Proxy (D p) -> Gen IntSet
forall p b a.
(LengthBounds p b, GenDefault p a) =>
([a] -> b) -> Proxy p -> Gen b
genListLike [Int] -> IntSet
IntSet.fromList

instance (LengthBounds (D p) (IntMap a), GenDefault (D p) a) => GenDefault (D p) (IntMap a) where
  genDefault :: Proxy (D p) -> Gen (IntMap a)
genDefault = ([(Int, a)] -> IntMap a) -> Proxy (D p) -> Gen (IntMap a)
forall p b a.
(LengthBounds p b, GenDefault p a) =>
([a] -> b) -> Proxy p -> Gen b
genListLike [(Int, a)] -> IntMap a
forall a. [(Int, a)] -> IntMap a
IntMap.fromList

instance (LengthBounds (D p) TermBytes8) => GenDefault (D p) TermBytes8 where
  genDefault :: Proxy (D p) -> Gen TermBytes8
genDefault = ([Word8] -> TermBytes8) -> Proxy (D p) -> Gen TermBytes8
forall p b a.
(LengthBounds p b, GenDefault p a) =>
([a] -> b) -> Proxy p -> Gen b
genListLike (ShortByteString -> TermBytes8
TermBytes8 (ShortByteString -> TermBytes8)
-> ([Word8] -> ShortByteString) -> [Word8] -> TermBytes8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> ShortByteString
BSS.pack)

instance (LengthBounds (D p) TermBytes16) => GenDefault (D p) TermBytes16 where
  genDefault :: Proxy (D p) -> Gen TermBytes16
genDefault = ([Word8] -> TermBytes16) -> Proxy (D p) -> Gen TermBytes16
forall p b a.
(LengthBounds p b, GenDefault p a) =>
([a] -> b) -> Proxy p -> Gen b
genListLike (ShortByteString -> TermBytes16
TermBytes16 (ShortByteString -> TermBytes16)
-> ([Word8] -> ShortByteString) -> [Word8] -> TermBytes16
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> ShortByteString
BSS.pack)

instance (KnownNat n) => GenDefault (D p) (StaticBytes n) where
  genDefault :: Proxy (D p) -> Gen (StaticBytes n)
genDefault Proxy (D p)
_ =
    let mn :: Word
mn = Integer -> Word
forall a. Num a => Integer -> a
fromInteger (Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall (t :: Nat). Proxy t
forall {k} (t :: k). Proxy t
Proxy @n))
    in  ([Word8] -> StaticBytes n)
-> GenT Identity [Word8] -> Gen (StaticBytes n)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ShortByteString -> StaticBytes n
forall (n :: Nat). ShortByteString -> StaticBytes n
StaticBytes (ShortByteString -> StaticBytes n)
-> ([Word8] -> ShortByteString) -> [Word8] -> StaticBytes n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> ShortByteString
BSS.pack) (Word -> Word -> GenT Identity Word8 -> GenT Identity [Word8]
forall a. Word -> Word -> Gen a -> Gen [a]
genList Word
mn Word
mn (forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault @(D p) Proxy (D p)
forall {k} (t :: k). Proxy t
Proxy))

instance (KnownNat n, GenDefault (D p) a) => GenDefault (D p) (StaticSeq n a) where
  genDefault :: Proxy (D p) -> Gen (StaticSeq n a)
genDefault Proxy (D p)
_ =
    let mn :: Word
mn = Integer -> Word
forall a. Num a => Integer -> a
fromInteger (Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall (t :: Nat). Proxy t
forall {k} (t :: k). Proxy t
Proxy @n))
    in  ([a] -> StaticSeq n a) -> GenT Identity [a] -> Gen (StaticSeq n a)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Seq a -> StaticSeq n a
forall (n :: Nat) a. Seq a -> StaticSeq n a
StaticSeq (Seq a -> StaticSeq n a) -> ([a] -> Seq a) -> [a] -> StaticSeq n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Seq a
forall a. [a] -> Seq a
Seq.fromList) (Word -> Word -> Gen a -> GenT Identity [a]
forall a. Word -> Word -> Gen a -> Gen [a]
genList Word
mn Word
mn (forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault @(D p) Proxy (D p)
forall {k} (t :: k). Proxy t
Proxy))

instance GenDefault (D p) BoolByte where
  genDefault :: Proxy (D p) -> Gen BoolByte
genDefault = (Bool -> BoolByte) -> Gen Bool -> Gen BoolByte
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> BoolByte
BoolByte (Gen Bool -> Gen BoolByte)
-> (Proxy (D p) -> Gen Bool) -> Proxy (D p) -> Gen BoolByte
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (D p) -> Gen Bool
forall tag a. GenDefault tag a => Proxy tag -> Gen a
genDefault

instance GenDefault (D p) (ExactBytes n s) where
  genDefault :: Proxy (D p) -> Gen (ExactBytes n s)
genDefault Proxy (D p)
_ = ExactBytes n s -> Gen (ExactBytes n s)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (() -> ExactBytes n s
forall (n :: Nat) (s :: Symbol). () -> ExactBytes n s
ExactBytes ())