{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE GADTs               #-}
{-# LANGUAGE LambdaCase          #-}
{-# LANGUAGE PolyKinds           #-}
{-# LANGUAGE TypeApplications    #-}
{-# LANGUAGE TypeOperators       #-}

module PlutusCore.Generators.Hedgehog.Builtin (
    GenTypedTerm (..),
    GenArbitraryTerm (..),
    genConstant,
    genInteger,
    genByteString,
    genText,
    genData,
    genI,
    genB,
    genList,
    genMap,
    genConstr,
    genBls12_381_G1_Element,
    genBls12_381_G2_Element,
    genBls12_381_MlResult
) where

import PlutusCore hiding (Constr)
import PlutusCore.Builtin
import PlutusCore.Crypto.BLS12_381.G1 qualified as BLS12_381.G1
import PlutusCore.Crypto.BLS12_381.G2 qualified as BLS12_381.G2
import PlutusCore.Crypto.BLS12_381.Pairing qualified as BLS12_381.Pairing
import PlutusCore.Data (Data (..))
import PlutusCore.Evaluation.Machine.ExMemoryUsage (LiteralByteSize)
import PlutusCore.Generators.Hedgehog.AST hiding (genConstant)

import Data.ByteString qualified as BS
import Data.Int (Int64)
import Data.Kind qualified as GHC
import Data.Text (Text)
import Data.Type.Equality
import Data.Word (Word8)
import Hedgehog hiding (Opaque, Var, eval)
import Hedgehog.Gen qualified as Gen
import Hedgehog.Range qualified as Range
import Type.Reflection

-- | This class exists so we can provide an ad-hoc typed term generator
-- for various universes. We usually rely-on a universe-specific generator
-- for well-typed constants within that universe.
--
-- TODO: Move this to "PlutusIR.Generators.AST", and merge `genConstant` with
-- `PlutusIR.Generators.AST.genConstant`.
class GenTypedTerm uni where
    -- | Generate a `Term` in @uni@ with the given type.
    genTypedTerm ::
        forall (a :: GHC.Type) tyname name fun.
        TypeRep a ->
        Gen (Term tyname name uni fun ())

instance GenTypedTerm DefaultUni where
    -- TODO: currently it only generates constant terms.
    genTypedTerm :: forall a tyname name fun.
TypeRep a -> Gen (Term tyname name DefaultUni fun ())
genTypedTerm TypeRep a
tr = case TypeRep a -> SomeGen DefaultUni
forall a. TypeRep a -> SomeGen DefaultUni
genConstant TypeRep a
tr of
        SomeGen Gen a
gen -> ()
-> Some (ValueOf DefaultUni) -> Term tyname name DefaultUni fun ()
forall tyname name (uni :: * -> *) fun ann.
ann -> Some (ValueOf uni) -> Term tyname name uni fun ann
Constant () (Some (ValueOf DefaultUni) -> Term tyname name DefaultUni fun ())
-> (a -> Some (ValueOf DefaultUni))
-> a
-> Term tyname name DefaultUni fun ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Some (ValueOf DefaultUni)
forall a (uni :: * -> *). Contains uni a => a -> Some (ValueOf uni)
someValue (a -> Term tyname name DefaultUni fun ())
-> Gen a -> Gen (Term tyname name DefaultUni fun ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
gen

-- | This class exists so we can provide an ad-hoc arbitrary term generator
-- for various universes.
class GenArbitraryTerm uni where
    -- | Generate an arbitrary `Term` in @uni@.
    genArbitraryTerm ::
        forall fun.
        (Bounded fun, Enum fun) =>
        Gen (Term TyName Name uni fun ())

instance GenArbitraryTerm DefaultUni where
    genArbitraryTerm :: forall fun.
(Bounded fun, Enum fun) =>
Gen (Term TyName Name DefaultUni fun ())
genArbitraryTerm = AstGen (Term TyName Name DefaultUni fun ())
-> GenT Identity (Term TyName Name DefaultUni fun ())
forall (m :: * -> *) a. MonadGen m => AstGen a -> m a
runAstGen AstGen (Term TyName Name DefaultUni fun ())
forall fun.
(Bounded fun, Enum fun) =>
AstGen (Term TyName Name DefaultUni fun ())
genTerm

data SomeGen uni = forall a. uni `HasTermLevel` a => SomeGen (Gen a)

genConstant :: forall (a :: GHC.Type). TypeRep a -> SomeGen DefaultUni
genConstant :: forall a. TypeRep a -> SomeGen DefaultUni
genConstant TypeRep a
tr
    | Just a :~~: ()
HRefl <- TypeRep a -> TypeRep () -> Maybe (a :~~: ())
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @()) = Gen () -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen (Gen () -> SomeGen DefaultUni) -> Gen () -> SomeGen DefaultUni
forall a b. (a -> b) -> a -> b
$ () -> Gen ()
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    | Just a :~~: Integer
HRefl <- TypeRep a -> TypeRep Integer -> Maybe (a :~~: Integer)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Integer) = Gen Integer -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen Gen Integer
genInteger
    | Just a :~~: Int
HRefl <- TypeRep a -> TypeRep Int -> Maybe (a :~~: Int)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Int) = Gen Integer -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen Gen Integer
genInteger
    | Just a :~~: Word8
HRefl <- TypeRep a -> TypeRep Word8 -> Maybe (a :~~: Word8)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Word8) = Gen Integer -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen Gen Integer
genInteger
    | Just a :~~: LiteralByteSize
HRefl <- TypeRep a
-> TypeRep LiteralByteSize -> Maybe (a :~~: LiteralByteSize)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @LiteralByteSize) = Gen Integer -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen Gen Integer
genInteger
    | Just a :~~: Bool
HRefl <- TypeRep a -> TypeRep Bool -> Maybe (a :~~: Bool)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Bool) = Gen Bool -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen Gen Bool
forall (m :: * -> *). MonadGen m => m Bool
Gen.bool
    | Just a :~~: ByteString
HRefl <- TypeRep a -> TypeRep ByteString -> Maybe (a :~~: ByteString)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @BS.ByteString) = Gen ByteString -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen Gen ByteString
genByteString
    | Just a :~~: Text
HRefl <- TypeRep a -> TypeRep Text -> Maybe (a :~~: Text)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Text) = Gen Text -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen Gen Text
genText
    | Just a :~~: Data
HRefl <- TypeRep a -> TypeRep Data -> Maybe (a :~~: Data)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Data) = GenT Identity Data -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen (GenT Identity Data -> SomeGen DefaultUni)
-> GenT Identity Data -> SomeGen DefaultUni
forall a b. (a -> b) -> a -> b
$ Int -> GenT Identity Data
genData Int
5
    | Just a :~~: Element
HRefl <- TypeRep a -> TypeRep Element -> Maybe (a :~~: Element)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @BLS12_381.G1.Element) =
                    Gen Element -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen (Gen Element -> SomeGen DefaultUni)
-> Gen Element -> SomeGen DefaultUni
forall a b. (a -> b) -> a -> b
$ Gen Element
genBls12_381_G1_Element
    | Just a :~~: Element
HRefl <- TypeRep a -> TypeRep Element -> Maybe (a :~~: Element)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @BLS12_381.G2.Element) =
                    Gen Element -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen (Gen Element -> SomeGen DefaultUni)
-> Gen Element -> SomeGen DefaultUni
forall a b. (a -> b) -> a -> b
$ Gen Element
genBls12_381_G2_Element
    | Just a :~~: MlResult
HRefl <- TypeRep a -> TypeRep MlResult -> Maybe (a :~~: MlResult)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
tr (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @BLS12_381.Pairing.MlResult) =
                    Gen MlResult -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen (Gen MlResult -> SomeGen DefaultUni)
-> Gen MlResult -> SomeGen DefaultUni
forall a b. (a -> b) -> a -> b
$ Gen MlResult
genBls12_381_MlResult
    | TypeRep a
trPair `App` TypeRep b
tr1 `App` TypeRep b
tr2 <- TypeRep a
tr
    , Just a :~~: (,)
HRefl <- TypeRep a -> TypeRep (,) -> Maybe (a :~~: (,))
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
trPair (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> * -> *). Typeable a => TypeRep a
typeRep @(,)) =
        case (TypeRep b -> SomeGen DefaultUni
forall a. TypeRep a -> SomeGen DefaultUni
genConstant TypeRep b
TypeRep b
tr1, TypeRep b -> SomeGen DefaultUni
forall a. TypeRep a -> SomeGen DefaultUni
genConstant TypeRep b
TypeRep b
tr2) of
            (SomeGen Gen a
g1, SomeGen Gen a
g2) -> Gen (a, a) -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen (Gen (a, a) -> SomeGen DefaultUni)
-> Gen (a, a) -> SomeGen DefaultUni
forall a b. (a -> b) -> a -> b
$ (,) (a -> a -> (a, a)) -> Gen a -> GenT Identity (a -> (a, a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
g1 GenT Identity (a -> (a, a)) -> Gen a -> Gen (a, a)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen a
g2
    | TypeRep a
trList `App` TypeRep b
trElem <- TypeRep a
tr
    , Just a :~~: []
HRefl <- TypeRep a -> TypeRep [] -> Maybe (a :~~: [])
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
trList (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> *). Typeable a => TypeRep a
typeRep @[]) =
        case TypeRep b -> SomeGen DefaultUni
forall a. TypeRep a -> SomeGen DefaultUni
genConstant TypeRep b
TypeRep b
trElem of
            SomeGen Gen a
genElem -> Gen [a] -> SomeGen DefaultUni
forall (uni :: * -> *) a.
HasTermLevel uni a =>
Gen a -> SomeGen uni
SomeGen (Gen [a] -> SomeGen DefaultUni) -> Gen [a] -> SomeGen DefaultUni
forall a b. (a -> b) -> a -> b
$ Range Int -> Gen a -> Gen [a]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
10) Gen a
genElem
    | TypeRep a
trSomeConstant `App` TypeRep b
_ `App` TypeRep b
trEl <- TypeRep a
tr
    , Just a :~~: SomeConstant
HRefl <- TypeRep a -> TypeRep SomeConstant -> Maybe (a :~~: SomeConstant)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
trSomeConstant (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: (* -> *) -> * -> *). Typeable a => TypeRep a
typeRep @SomeConstant) =
        TypeRep b -> SomeGen DefaultUni
forall a. TypeRep a -> SomeGen DefaultUni
genConstant TypeRep b
TypeRep b
trEl
    | TypeRep a
trOpaque `App` TypeRep b
_ `App` TypeRep b
trEl <- TypeRep a
tr
    , Just a :~~: Opaque
HRefl <- TypeRep a -> TypeRep Opaque -> Maybe (a :~~: Opaque)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
trOpaque (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> * -> *). Typeable a => TypeRep a
typeRep @Opaque) =
        TypeRep b -> SomeGen DefaultUni
forall a. TypeRep a -> SomeGen DefaultUni
genConstant TypeRep b
TypeRep b
trEl
    | TypeRep a
trTyVarRep `App` TypeRep b
_ <- TypeRep a
tr
    , Just a :~~: TyVarRep
HRefl <- TypeRep a -> TypeRep TyVarRep -> Maybe (a :~~: TyVarRep)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep TypeRep a
trTyVarRep (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: TyNameRep (*) -> *). Typeable a => TypeRep a
typeRep @(TyVarRep @GHC.Type)) =
        -- In the current implementation, all type variables are instantiated
        -- to `Integer` (TODO: change this?).
        TypeRep Integer -> SomeGen DefaultUni
forall a. TypeRep a -> SomeGen DefaultUni
genConstant (TypeRep Integer -> SomeGen DefaultUni)
-> TypeRep Integer -> SomeGen DefaultUni
forall a b. (a -> b) -> a -> b
$ forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Integer
    | Bool
otherwise =
        [Char] -> SomeGen DefaultUni
forall a. HasCallStack => [Char] -> a
error ([Char] -> SomeGen DefaultUni) -> [Char] -> SomeGen DefaultUni
forall a b. (a -> b) -> a -> b
$
            [Char]
"genConstant: I don't know how to generate constants of this type: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> TypeRep a -> [Char]
forall a. Show a => a -> [Char]
show TypeRep a
tr

----------------------------------------------------------
-- Generators

genInteger :: Gen Integer
genInteger :: Gen Integer
genInteger = forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int64 (Int64 -> Integer) -> GenT Identity Int64 -> Gen Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity Int64
forall (m :: * -> *) a. (MonadGen m, Enum a, Bounded a) => m a
Gen.enumBounded

genByteString :: Gen BS.ByteString
genByteString :: Gen ByteString
genByteString = Range Int -> GenT Identity Char -> Gen ByteString
forall (m :: * -> *).
MonadGen m =>
Range Int -> m Char -> m ByteString
Gen.utf8 (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
100) GenT Identity Char
forall (m :: * -> *) a. (MonadGen m, Enum a, Bounded a) => m a
Gen.enumBounded

genText :: Gen Text
genText :: Gen Text
genText = Range Int -> GenT Identity Char -> Gen Text
forall (m :: * -> *). MonadGen m => Range Int -> m Char -> m Text
Gen.text (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
100) GenT Identity Char
forall (m :: * -> *) a. (MonadGen m, Enum a, Bounded a) => m a
Gen.enumBounded

genData :: Int -> Gen Data
genData :: Int -> GenT Identity Data
genData Int
depth =
    [GenT Identity Data] -> GenT Identity Data
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice ([GenT Identity Data] -> GenT Identity Data)
-> [GenT Identity Data] -> GenT Identity Data
forall a b. (a -> b) -> a -> b
$
        [GenT Identity Data
genI, GenT Identity Data
genB]
            [GenT Identity Data]
-> [GenT Identity Data] -> [GenT Identity Data]
forall a. Semigroup a => a -> a -> a
<> [ GenT Identity Data
genRec | Int
depth Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1, GenT Identity Data
genRec <-
                                        [ Int -> GenT Identity Data
genList (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
                                        , Int -> GenT Identity Data
genMap (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
                                        , Int -> GenT Identity Data
genConstr (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
                                        ]
               ]

genI :: Gen Data
genI :: GenT Identity Data
genI = Integer -> Data
I (Integer -> Data) -> Gen Integer -> GenT Identity Data
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Integer
genInteger

genB :: Gen Data
genB :: GenT Identity Data
genB = ByteString -> Data
B (ByteString -> Data) -> Gen ByteString -> GenT Identity Data
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByteString
genByteString

genList :: Int -> Gen Data
genList :: Int -> GenT Identity Data
genList Int
depth = [Data] -> Data
List ([Data] -> Data) -> GenT Identity [Data] -> GenT Identity Data
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> GenT Identity Data -> GenT Identity [Data]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
5) (Int -> GenT Identity Data
genData (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1))

genMap :: Int -> Gen Data
genMap :: Int -> GenT Identity Data
genMap Int
depth =
    [(Data, Data)] -> Data
Map
        ([(Data, Data)] -> Data)
-> GenT Identity [(Data, Data)] -> GenT Identity Data
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int
-> GenT Identity (Data, Data) -> GenT Identity [(Data, Data)]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list
            (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
5)
            ((,) (Data -> Data -> (Data, Data))
-> GenT Identity Data -> GenT Identity (Data -> (Data, Data))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> GenT Identity Data
genData (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) GenT Identity (Data -> (Data, Data))
-> GenT Identity Data -> GenT Identity (Data, Data)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> GenT Identity Data
genData (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1))

genConstr :: Int -> Gen Data
genConstr :: Int -> GenT Identity Data
genConstr Int
depth =
    Integer -> [Data] -> Data
Constr (Integer -> [Data] -> Data)
-> Gen Integer -> GenT Identity ([Data] -> Data)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Integer
genInteger
        GenT Identity ([Data] -> Data)
-> GenT Identity [Data] -> GenT Identity Data
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Range Int -> GenT Identity Data -> GenT Identity [Data]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list
            (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
5)
            (Int -> GenT Identity Data
genData (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1))

genBls12_381_G1_Element :: Gen BLS12_381.G1.Element
genBls12_381_G1_Element :: Gen Element
genBls12_381_G1_Element =
  ByteString -> ByteString -> Either BLS12_381_Error Element
BLS12_381.G1.hashToGroup (ByteString -> ByteString -> Either BLS12_381_Error Element)
-> Gen ByteString
-> GenT Identity (ByteString -> Either BLS12_381_Error Element)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByteString
genByteString GenT Identity (ByteString -> Either BLS12_381_Error Element)
-> Gen ByteString -> GenT Identity (Either BLS12_381_Error Element)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ByteString -> Gen ByteString
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ByteString
BS.empty GenT Identity (Either BLS12_381_Error Element)
-> (Either BLS12_381_Error Element -> Gen Element) -> Gen Element
forall a b.
GenT Identity a -> (a -> GenT Identity b) -> GenT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
  -- We should only get a failure if the second argument is greater than 255 bytes, which it isn't.
       Left BLS12_381_Error
err -> [Char] -> Gen Element
forall a. [Char] -> GenT Identity a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> Gen Element) -> [Char] -> Gen Element
forall a b. (a -> b) -> a -> b
$ BLS12_381_Error -> [Char]
forall a. Show a => a -> [Char]
show BLS12_381_Error
err  -- This should never happen
       Right Element
p  -> Element -> Gen Element
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Element
p

genBls12_381_G2_Element :: Gen BLS12_381.G2.Element
genBls12_381_G2_Element :: Gen Element
genBls12_381_G2_Element =
  ByteString -> ByteString -> Either BLS12_381_Error Element
BLS12_381.G2.hashToGroup (ByteString -> ByteString -> Either BLS12_381_Error Element)
-> Gen ByteString
-> GenT Identity (ByteString -> Either BLS12_381_Error Element)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByteString
genByteString GenT Identity (ByteString -> Either BLS12_381_Error Element)
-> Gen ByteString -> GenT Identity (Either BLS12_381_Error Element)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ByteString -> Gen ByteString
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ByteString
BS.empty GenT Identity (Either BLS12_381_Error Element)
-> (Either BLS12_381_Error Element -> Gen Element) -> Gen Element
forall a b.
GenT Identity a -> (a -> GenT Identity b) -> GenT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
  -- We should only get a failure if the second argument is greater than 255 bytes, which it isn't.
       Left BLS12_381_Error
err -> [Char] -> Gen Element
forall a. [Char] -> GenT Identity a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> Gen Element) -> [Char] -> Gen Element
forall a b. (a -> b) -> a -> b
$ BLS12_381_Error -> [Char]
forall a. Show a => a -> [Char]
show BLS12_381_Error
err
       Right Element
p  -> Element -> Gen Element
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Element
p

genBls12_381_MlResult :: Gen BLS12_381.Pairing.MlResult
genBls12_381_MlResult :: Gen MlResult
genBls12_381_MlResult = do
  Element
p1 <- Gen Element
genBls12_381_G1_Element
  Element
p2 <- Gen Element
genBls12_381_G2_Element
  MlResult -> Gen MlResult
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MlResult -> Gen MlResult) -> MlResult -> Gen MlResult
forall a b. (a -> b) -> a -> b
$ Element -> Element -> MlResult
BLS12_381.Pairing.millerLoop Element
p1 Element
p2