-- SPDX-FileCopyrightText: 2020 Tocqueville Group
--
-- SPDX-License-Identifier: LicenseRef-MIT-TQ

module Util.Test.Gen
  ( genInternalByteString
  , genVar
  , genTyVar
  , genExpandedOp
  , genInstrCallStack
  , genSrcPos
  , genPos
  , genLetName
  , genExtInstrAbstract
  , genPrintComment
  , genStackRef
  , genTestAssert
  , genStackFn
  , genStackTypePattern
  , genInstrAbstract
  , genContract
  , genContract'
  , genValue
  , genValue'
  , genElt
  , genParameterType
  , genType
  , genEpName
  , genAnnotation
  , genT
  ) where

import Prelude hiding (EQ, GT, LT)

import qualified Data.Text as T
import Hedgehog (MonadGen(GenBase), Range)
import qualified Hedgehog.Gen as Gen
import qualified Hedgehog.Range as Range

import Michelson.ErrorPos (InstrCallStack(..), LetName(..), Pos(..), SrcPos(..))
import Michelson.Test.Util (genEither)
import Michelson.Text (genMText)
import Michelson.Untyped
  (Annotation, Contract, Contract'(..), Elt(..), EpName, ExpandedOp(..), ExtInstrAbstract(..),
  InstrAbstract(..), InternalByteString(..), ParameterType(..), PrintComment(..), StackFn(..),
  StackRef(..), StackTypePattern(..), T(..), TestAssert(..), TyVar(..), Type(..), Value,
  Value'(..), Var(..), epNameFromRefAnn, mkAnnotation, specialFieldAnn, specialVarAnns)

genInternalByteString :: MonadGen m => m InternalByteString
genInternalByteString :: m InternalByteString
genInternalByteString = ByteString -> InternalByteString
InternalByteString (ByteString -> InternalByteString)
-> m ByteString -> m InternalByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> m ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear 0 100)

genVar :: MonadGen m => m Var
genVar :: m Var
genVar = Text -> Var
Var (Text -> Var) -> m Text -> m Var
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text
forall (m :: * -> *). MonadGen m => m Text
genSmallText

genTyVar :: (MonadGen m, GenBase m ~ Identity) => m TyVar
genTyVar :: m TyVar
genTyVar = [m TyVar] -> m TyVar
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice [Var -> TyVar
VarID (Var -> TyVar) -> m Var -> m TyVar
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Var
forall (m :: * -> *). MonadGen m => m Var
genVar, Type -> TyVar
TyCon (Type -> TyVar) -> m Type -> m TyVar
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType]

genExpandedOp :: (MonadGen m, GenBase m ~ Identity) => m ExpandedOp
genExpandedOp :: m ExpandedOp
genExpandedOp = ([m ExpandedOp] -> m ExpandedOp)
-> [m ExpandedOp] -> [m ExpandedOp] -> m ExpandedOp
forall (m :: * -> *) a.
MonadGen m =>
([m a] -> m a) -> [m a] -> [m a] -> m a
Gen.recursive [m ExpandedOp] -> m ExpandedOp
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
  -- non-recursive constructors
  [
    -- NB: When used together, genExpandedOp & genInstrAbstract are mutually recursive.
    -- So we use a generator of InstrAbstract that does not contain any ops as an escape hatch.
    ExpandedInstr -> ExpandedOp
PrimEx (ExpandedInstr -> ExpandedOp) -> m ExpandedInstr -> m ExpandedOp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [m ExpandedInstr] -> m ExpandedInstr
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice [m ExpandedInstr]
forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
[m (InstrAbstract op)]
instrAbstractWithoutOp
  ]
  -- recursive constructors
  [ ExpandedInstr -> ExpandedOp
PrimEx (ExpandedInstr -> ExpandedOp) -> m ExpandedInstr -> m ExpandedOp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ExpandedOp -> m ExpandedInstr
forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> m (InstrAbstract op)
genInstrAbstract m ExpandedOp
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m ExpandedOp
genExpandedOp
  , [ExpandedOp] -> ExpandedOp
SeqEx ([ExpandedOp] -> ExpandedOp) -> m [ExpandedOp] -> m ExpandedOp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ExpandedOp -> m [ExpandedOp]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m ExpandedOp
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m ExpandedOp
genExpandedOp
  , m ExpandedOp -> (ExpandedOp -> m ExpandedOp) -> m ExpandedOp
forall (m :: * -> *) a. MonadGen m => m a -> (a -> m a) -> m a
Gen.subtermM m ExpandedOp
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m ExpandedOp
genExpandedOp ((ExpandedOp -> m ExpandedOp) -> m ExpandedOp)
-> (ExpandedOp -> m ExpandedOp) -> m ExpandedOp
forall a b. (a -> b) -> a -> b
$ \expandedOp :: ExpandedOp
expandedOp -> InstrCallStack -> ExpandedOp -> ExpandedOp
WithSrcEx (InstrCallStack -> ExpandedOp -> ExpandedOp)
-> m InstrCallStack -> m (ExpandedOp -> ExpandedOp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m InstrCallStack
forall (m :: * -> *). MonadGen m => m InstrCallStack
genInstrCallStack m (ExpandedOp -> ExpandedOp) -> m ExpandedOp -> m ExpandedOp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ExpandedOp -> m ExpandedOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure ExpandedOp
expandedOp
  ]

genInstrCallStack :: MonadGen m => m InstrCallStack
genInstrCallStack :: m InstrCallStack
genInstrCallStack = LetCallStack -> SrcPos -> InstrCallStack
InstrCallStack (LetCallStack -> SrcPos -> InstrCallStack)
-> m LetCallStack -> m (SrcPos -> InstrCallStack)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m LetCallStack
genLetCallStack m (SrcPos -> InstrCallStack) -> m SrcPos -> m InstrCallStack
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m SrcPos
forall (m :: * -> *). MonadGen m => m SrcPos
genSrcPos
  where
    genLetCallStack :: m LetCallStack
genLetCallStack = [(Int, m LetCallStack)] -> m LetCallStack
forall (m :: * -> *) a. MonadGen m => [(Int, m a)] -> m a
Gen.frequency
      [ (80, LetCallStack -> m LetCallStack
forall (f :: * -> *) a. Applicative f => a -> f a
pure [])
      , (18, Range Int -> m LetName -> m LetCallStack
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Range Int
forall a. a -> Range a
Range.singleton 1) m LetName
forall (m :: * -> *). MonadGen m => m LetName
genLetName)
      , (2, Range Int -> m LetName -> m LetCallStack
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Range Int
forall a. a -> Range a
Range.singleton 2) m LetName
forall (m :: * -> *). MonadGen m => m LetName
genLetName)
      ]

genSrcPos :: MonadGen m => m SrcPos
genSrcPos :: m SrcPos
genSrcPos = Pos -> Pos -> SrcPos
SrcPos (Pos -> Pos -> SrcPos) -> m Pos -> m (Pos -> SrcPos)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Pos
forall (m :: * -> *). MonadGen m => m Pos
genPos m (Pos -> SrcPos) -> m Pos -> m SrcPos
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Pos
forall (m :: * -> *). MonadGen m => m Pos
genPos

genPos :: MonadGen m => m Pos
genPos :: m Pos
genPos = Word -> Pos
Pos (Word -> Pos) -> m Word -> m Pos
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word -> m Word
forall (m :: * -> *). MonadGen m => Range Word -> m Word
Gen.word Range Word
forall a. (Bounded a, Integral a) => Range a
Range.linearBounded

genLetName :: MonadGen m => m LetName
genLetName :: m LetName
genLetName = Text -> LetName
LetName (Text -> LetName) -> m Text -> m LetName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> m Char -> m 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 0 3) m Char
forall (m :: * -> *). MonadGen m => m Char
Gen.unicodeAll

genExtInstrAbstract :: (MonadGen m, GenBase m ~ Identity) => m op -> m (ExtInstrAbstract op)
genExtInstrAbstract :: m op -> m (ExtInstrAbstract op)
genExtInstrAbstract genOp :: m op
genOp = [m (ExtInstrAbstract op)] -> m (ExtInstrAbstract op)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
  [ StackTypePattern -> ExtInstrAbstract op
forall op. StackTypePattern -> ExtInstrAbstract op
STACKTYPE (StackTypePattern -> ExtInstrAbstract op)
-> m StackTypePattern -> m (ExtInstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m StackTypePattern
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m StackTypePattern
genStackTypePattern
  , Text -> StackFn -> [op] -> ExtInstrAbstract op
forall op. Text -> StackFn -> [op] -> ExtInstrAbstract op
FN (Text -> StackFn -> [op] -> ExtInstrAbstract op)
-> m Text -> m (StackFn -> [op] -> ExtInstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text
forall (m :: * -> *). MonadGen m => m Text
genSmallText m (StackFn -> [op] -> ExtInstrAbstract op)
-> m StackFn -> m ([op] -> ExtInstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m StackFn
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m StackFn
genStackFn m ([op] -> ExtInstrAbstract op)
-> m [op] -> m (ExtInstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , TestAssert op -> ExtInstrAbstract op
forall op. TestAssert op -> ExtInstrAbstract op
UTEST_ASSERT (TestAssert op -> ExtInstrAbstract op)
-> m (TestAssert op) -> m (ExtInstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m (TestAssert op)
forall (m :: * -> *) op. MonadGen m => m op -> m (TestAssert op)
genTestAssert m op
genOp
  , PrintComment -> ExtInstrAbstract op
forall op. PrintComment -> ExtInstrAbstract op
UPRINT (PrintComment -> ExtInstrAbstract op)
-> m PrintComment -> m (ExtInstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m PrintComment
forall (m :: * -> *). MonadGen m => m PrintComment
genPrintComment
  , Text -> ExtInstrAbstract op
forall op. Text -> ExtInstrAbstract op
UCOMMENT (Text -> ExtInstrAbstract op) -> m Text -> m (ExtInstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text
forall (m :: * -> *). MonadGen m => m Text
genSmallText
  ]

genPrintComment :: MonadGen m => m PrintComment
genPrintComment :: m PrintComment
genPrintComment = [Either Text StackRef] -> PrintComment
PrintComment ([Either Text StackRef] -> PrintComment)
-> m [Either Text StackRef] -> m PrintComment
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> m (Either Text StackRef) -> m [Either Text StackRef]
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 0 5) (m Text -> m StackRef -> m (Either Text StackRef)
forall (m :: * -> *) a b.
MonadGen m =>
m a -> m b -> m (Either a b)
genEither m Text
forall (m :: * -> *). MonadGen m => m Text
genSmallText m StackRef
forall (m :: * -> *). MonadGen m => m StackRef
genStackRef)

genStackRef :: MonadGen m => m StackRef
genStackRef :: m StackRef
genStackRef = Natural -> StackRef
StackRef (Natural -> StackRef) -> m Natural -> m StackRef
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Natural -> m Natural
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Natural -> Natural -> Range Natural
forall a. Integral a => a -> a -> Range a
Range.linear 0 (Word64 -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64 -> Natural) -> Word64 -> Natural
forall a b. (a -> b) -> a -> b
$ Bounded Word64 => Word64
forall a. Bounded a => a
maxBound @Word64))

genTestAssert :: MonadGen m => m op -> m (TestAssert op)
genTestAssert :: m op -> m (TestAssert op)
genTestAssert genOp :: m op
genOp = Text -> PrintComment -> [op] -> TestAssert op
forall op. Text -> PrintComment -> [op] -> TestAssert op
TestAssert (Text -> PrintComment -> [op] -> TestAssert op)
-> m Text -> m (PrintComment -> [op] -> TestAssert op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text
forall (m :: * -> *). MonadGen m => m Text
genSmallText m (PrintComment -> [op] -> TestAssert op)
-> m PrintComment -> m ([op] -> TestAssert op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m PrintComment
forall (m :: * -> *). MonadGen m => m PrintComment
genPrintComment m ([op] -> TestAssert op) -> m [op] -> m (TestAssert op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp

genStackFn :: (MonadGen m, GenBase m ~ Identity) => m StackFn
genStackFn :: m StackFn
genStackFn = Maybe (Set Var) -> StackTypePattern -> StackTypePattern -> StackFn
StackFn
  (Maybe (Set Var)
 -> StackTypePattern -> StackTypePattern -> StackFn)
-> m (Maybe (Set Var))
-> m (StackTypePattern -> StackTypePattern -> StackFn)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Set Var) -> m (Maybe (Set Var))
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe (Range Int -> m Var -> m (Set Var)
forall (m :: * -> *) a.
(MonadGen m, Ord a) =>
Range Int -> m a -> m (Set a)
Gen.set Range Int
smallCollectionRange m Var
forall (m :: * -> *). MonadGen m => m Var
genVar)
  m (StackTypePattern -> StackTypePattern -> StackFn)
-> m StackTypePattern -> m (StackTypePattern -> StackFn)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m StackTypePattern
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m StackTypePattern
genStackTypePattern
  m (StackTypePattern -> StackFn) -> m StackTypePattern -> m StackFn
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m StackTypePattern
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m StackTypePattern
genStackTypePattern

genStackTypePattern :: (MonadGen m, GenBase m ~ Identity) => m StackTypePattern
genStackTypePattern :: m StackTypePattern
genStackTypePattern = ([m StackTypePattern] -> m StackTypePattern)
-> [m StackTypePattern]
-> [m StackTypePattern]
-> m StackTypePattern
forall (m :: * -> *) a.
MonadGen m =>
([m a] -> m a) -> [m a] -> [m a] -> m a
Gen.recursive [m StackTypePattern] -> m StackTypePattern
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
  [ StackTypePattern -> m StackTypePattern
forall (f :: * -> *) a. Applicative f => a -> f a
pure StackTypePattern
StkEmpty, StackTypePattern -> m StackTypePattern
forall (f :: * -> *) a. Applicative f => a -> f a
pure StackTypePattern
StkRest ]
  [ m StackTypePattern
-> (StackTypePattern -> m StackTypePattern) -> m StackTypePattern
forall (m :: * -> *) a. MonadGen m => m a -> (a -> m a) -> m a
Gen.subtermM m StackTypePattern
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m StackTypePattern
genStackTypePattern ((StackTypePattern -> m StackTypePattern) -> m StackTypePattern)
-> (StackTypePattern -> m StackTypePattern) -> m StackTypePattern
forall a b. (a -> b) -> a -> b
$ \stp :: StackTypePattern
stp -> TyVar -> StackTypePattern -> StackTypePattern
StkCons (TyVar -> StackTypePattern -> StackTypePattern)
-> m TyVar -> m (StackTypePattern -> StackTypePattern)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TyVar
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m TyVar
genTyVar m (StackTypePattern -> StackTypePattern)
-> m StackTypePattern -> m StackTypePattern
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StackTypePattern -> m StackTypePattern
forall (f :: * -> *) a. Applicative f => a -> f a
pure StackTypePattern
stp ]

genInstrAbstract :: (MonadGen m, GenBase m ~ Identity) => m op -> m (InstrAbstract op)
genInstrAbstract :: m op -> m (InstrAbstract op)
genInstrAbstract genOp :: m op
genOp =
  [m (InstrAbstract op)] -> m (InstrAbstract op)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice ([m (InstrAbstract op)] -> m (InstrAbstract op))
-> [m (InstrAbstract op)] -> m (InstrAbstract op)
forall a b. (a -> b) -> a -> b
$ m op -> [m (InstrAbstract op)]
forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> [m (InstrAbstract op)]
instrAbstractWithOp m op
genOp [m (InstrAbstract op)]
-> [m (InstrAbstract op)] -> [m (InstrAbstract op)]
forall a. Semigroup a => a -> a -> a
<> [m (InstrAbstract op)]
forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
[m (InstrAbstract op)]
instrAbstractWithoutOp

instrAbstractWithOp :: (MonadGen m, GenBase m ~ Identity) => m op -> [m (InstrAbstract op)]
instrAbstractWithOp :: m op -> [m (InstrAbstract op)]
instrAbstractWithOp genOp :: m op
genOp =
  [ ExtInstrAbstract op -> InstrAbstract op
forall op. ExtInstrAbstract op -> InstrAbstract op
EXT (ExtInstrAbstract op -> InstrAbstract op)
-> m (ExtInstrAbstract op) -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m (ExtInstrAbstract op)
forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> m (ExtInstrAbstract op)
genExtInstrAbstract m op
genOp
  , VarAnn -> Type -> Value' op -> InstrAbstract op
forall op. VarAnn -> Type -> Value' op -> InstrAbstract op
PUSH (VarAnn -> Type -> Value' op -> InstrAbstract op)
-> m VarAnn -> m (Type -> Value' op -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> Value' op -> InstrAbstract op)
-> m Type -> m (Value' op -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m (Value' op -> InstrAbstract op)
-> m (Value' op) -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m (Value' op)
forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' m op
genOp
  , [op] -> [op] -> InstrAbstract op
forall op. [op] -> [op] -> InstrAbstract op
IF_NONE ([op] -> [op] -> InstrAbstract op)
-> m [op] -> m ([op] -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp m ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , [op] -> [op] -> InstrAbstract op
forall op. [op] -> [op] -> InstrAbstract op
IF_LEFT ([op] -> [op] -> InstrAbstract op)
-> m [op] -> m ([op] -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp m ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , [op] -> [op] -> InstrAbstract op
forall op. [op] -> [op] -> InstrAbstract op
IF_CONS ([op] -> [op] -> InstrAbstract op)
-> m [op] -> m ([op] -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp m ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , VarAnn -> [op] -> InstrAbstract op
forall op. VarAnn -> [op] -> InstrAbstract op
MAP (VarAnn -> [op] -> InstrAbstract op)
-> m VarAnn -> m ([op] -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , [op] -> InstrAbstract op
forall op. [op] -> InstrAbstract op
ITER ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , [op] -> [op] -> InstrAbstract op
forall op. [op] -> [op] -> InstrAbstract op
IF ([op] -> [op] -> InstrAbstract op)
-> m [op] -> m ([op] -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp m ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , [op] -> InstrAbstract op
forall op. [op] -> InstrAbstract op
LOOP ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , [op] -> InstrAbstract op
forall op. [op] -> InstrAbstract op
LOOP_LEFT ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , VarAnn -> Type -> Type -> [op] -> InstrAbstract op
forall op. VarAnn -> Type -> Type -> [op] -> InstrAbstract op
LAMBDA (VarAnn -> Type -> Type -> [op] -> InstrAbstract op)
-> m VarAnn -> m (Type -> Type -> [op] -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> Type -> [op] -> InstrAbstract op)
-> m Type -> m (Type -> [op] -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m (Type -> [op] -> InstrAbstract op)
-> m Type -> m ([op] -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , [op] -> InstrAbstract op
forall op. [op] -> InstrAbstract op
DIP ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , Word -> [op] -> InstrAbstract op
forall op. Word -> [op] -> InstrAbstract op
DIPN (Word -> [op] -> InstrAbstract op)
-> m Word -> m ([op] -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word -> m Word
forall (m :: * -> *). MonadGen m => Range Word -> m Word
Gen.word Range Word
forall a. (Bounded a, Integral a) => Range a
Range.linearBounded m ([op] -> InstrAbstract op) -> m [op] -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp
  , VarAnn -> VarAnn -> Contract' op -> InstrAbstract op
forall op. VarAnn -> VarAnn -> Contract' op -> InstrAbstract op
CREATE_CONTRACT (VarAnn -> VarAnn -> Contract' op -> InstrAbstract op)
-> m VarAnn -> m (VarAnn -> Contract' op -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> Contract' op -> InstrAbstract op)
-> m VarAnn -> m (Contract' op -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Contract' op -> InstrAbstract op)
-> m (Contract' op) -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m (Contract' op)
forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> m (Contract' op)
genContract' m op
genOp
  ]

instrAbstractWithoutOp :: (MonadGen m, GenBase m ~ Identity) => [m (InstrAbstract op)]
instrAbstractWithoutOp :: [m (InstrAbstract op)]
instrAbstractWithoutOp =
  [ Word -> InstrAbstract op
forall op. Word -> InstrAbstract op
DROPN (Word -> InstrAbstract op) -> m Word -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word -> m Word
forall (m :: * -> *). MonadGen m => Range Word -> m Word
Gen.word Range Word
forall a. (Bounded a, Integral a) => Range a
Range.linearBounded
  , InstrAbstract op -> m (InstrAbstract op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrAbstract op
forall op. InstrAbstract op
DROP
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
DUP (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , InstrAbstract op -> m (InstrAbstract op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrAbstract op
forall op. InstrAbstract op
SWAP
  , Word -> InstrAbstract op
forall op. Word -> InstrAbstract op
DIG (Word -> InstrAbstract op) -> m Word -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word -> m Word
forall (m :: * -> *). MonadGen m => Range Word -> m Word
Gen.word Range Word
forall a. (Bounded a, Integral a) => Range a
Range.linearBounded
  , Word -> InstrAbstract op
forall op. Word -> InstrAbstract op
DUG (Word -> InstrAbstract op) -> m Word -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word -> m Word
forall (m :: * -> *). MonadGen m => Range Word -> m Word
Gen.word Range Word
forall a. (Bounded a, Integral a) => Range a
Range.linearBounded
  , TypeAnn -> VarAnn -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> InstrAbstract op
SOME (TypeAnn -> VarAnn -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , TypeAnn -> VarAnn -> Type -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Type -> InstrAbstract op
NONE (TypeAnn -> VarAnn -> Type -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> Type -> InstrAbstract op)
-> m VarAnn -> m (Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> InstrAbstract op) -> m Type -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
  , TypeAnn -> VarAnn -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> InstrAbstract op
UNIT (TypeAnn -> VarAnn -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> InstrAbstract op
forall op.
TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> InstrAbstract op
PAIR (TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> InstrAbstract op)
-> m TypeAnn
-> m (VarAnn -> FieldAnn -> FieldAnn -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> FieldAnn -> FieldAnn -> InstrAbstract op)
-> m VarAnn -> m (FieldAnn -> FieldAnn -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> FieldAnn -> InstrAbstract op)
-> m FieldAnn -> m (FieldAnn -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> InstrAbstract op)
-> m FieldAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> FieldAnn -> InstrAbstract op
forall op. VarAnn -> FieldAnn -> InstrAbstract op
CAR (VarAnn -> FieldAnn -> InstrAbstract op)
-> m VarAnn -> m (FieldAnn -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> InstrAbstract op)
-> m FieldAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> FieldAnn -> InstrAbstract op
forall op. VarAnn -> FieldAnn -> InstrAbstract op
CDR (VarAnn -> FieldAnn -> InstrAbstract op)
-> m VarAnn -> m (FieldAnn -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> InstrAbstract op)
-> m FieldAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , TypeAnn
-> VarAnn -> FieldAnn -> FieldAnn -> Type -> InstrAbstract op
forall op.
TypeAnn
-> VarAnn -> FieldAnn -> FieldAnn -> Type -> InstrAbstract op
LEFT (TypeAnn
 -> VarAnn -> FieldAnn -> FieldAnn -> Type -> InstrAbstract op)
-> m TypeAnn
-> m (VarAnn -> FieldAnn -> FieldAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> FieldAnn -> FieldAnn -> Type -> InstrAbstract op)
-> m VarAnn -> m (FieldAnn -> FieldAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> FieldAnn -> Type -> InstrAbstract op)
-> m FieldAnn -> m (FieldAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> Type -> InstrAbstract op)
-> m FieldAnn -> m (Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> InstrAbstract op) -> m Type -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
  , TypeAnn
-> VarAnn -> FieldAnn -> FieldAnn -> Type -> InstrAbstract op
forall op.
TypeAnn
-> VarAnn -> FieldAnn -> FieldAnn -> Type -> InstrAbstract op
RIGHT (TypeAnn
 -> VarAnn -> FieldAnn -> FieldAnn -> Type -> InstrAbstract op)
-> m TypeAnn
-> m (VarAnn -> FieldAnn -> FieldAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> FieldAnn -> FieldAnn -> Type -> InstrAbstract op)
-> m VarAnn -> m (FieldAnn -> FieldAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> FieldAnn -> Type -> InstrAbstract op)
-> m FieldAnn -> m (FieldAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> Type -> InstrAbstract op)
-> m FieldAnn -> m (Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> InstrAbstract op) -> m Type -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
  , TypeAnn -> VarAnn -> Type -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Type -> InstrAbstract op
NIL (TypeAnn -> VarAnn -> Type -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> Type -> InstrAbstract op)
-> m VarAnn -> m (Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> InstrAbstract op) -> m Type -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
CONS (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
SIZE (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , TypeAnn -> VarAnn -> Type -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Type -> InstrAbstract op
EMPTY_SET (TypeAnn -> VarAnn -> Type -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> Type -> InstrAbstract op)
-> m VarAnn -> m (Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> InstrAbstract op) -> m Type -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
  , TypeAnn -> VarAnn -> Type -> Type -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Type -> Type -> InstrAbstract op
EMPTY_MAP (TypeAnn -> VarAnn -> Type -> Type -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Type -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> Type -> Type -> InstrAbstract op)
-> m VarAnn -> m (Type -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> Type -> InstrAbstract op)
-> m Type -> m (Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m (Type -> InstrAbstract op) -> m Type -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
  , TypeAnn -> VarAnn -> Type -> Type -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Type -> Type -> InstrAbstract op
EMPTY_BIG_MAP (TypeAnn -> VarAnn -> Type -> Type -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Type -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> Type -> Type -> InstrAbstract op)
-> m VarAnn -> m (Type -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> Type -> InstrAbstract op)
-> m Type -> m (Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m (Type -> InstrAbstract op) -> m Type -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
MEM (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
GET (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
UPDATE (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
EXEC (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
APPLY (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , InstrAbstract op -> m (InstrAbstract op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrAbstract op
forall op. InstrAbstract op
FAILWITH
  , VarAnn -> Type -> InstrAbstract op
forall op. VarAnn -> Type -> InstrAbstract op
CAST (VarAnn -> Type -> InstrAbstract op)
-> m VarAnn -> m (Type -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> InstrAbstract op) -> m Type -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
RENAME (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
PACK (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , TypeAnn -> VarAnn -> Type -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Type -> InstrAbstract op
UNPACK (TypeAnn -> VarAnn -> Type -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (VarAnn -> Type -> InstrAbstract op)
-> m VarAnn -> m (Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> InstrAbstract op) -> m Type -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
CONCAT (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
SLICE (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
ISNAT (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
ADD (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
SUB (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
MUL (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
EDIV (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
ABS (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
NEG (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
LSL (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
LSR (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
OR (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
AND (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
XOR (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
NOT (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
COMPARE (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
EQ (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
NEQ (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
LT (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
GT (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
LE (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
GE (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
INT (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> FieldAnn -> InstrAbstract op
forall op. VarAnn -> FieldAnn -> InstrAbstract op
SELF (VarAnn -> FieldAnn -> InstrAbstract op)
-> m VarAnn -> m (FieldAnn -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> InstrAbstract op)
-> m FieldAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> FieldAnn -> Type -> InstrAbstract op
forall op. VarAnn -> FieldAnn -> Type -> InstrAbstract op
CONTRACT (VarAnn -> FieldAnn -> Type -> InstrAbstract op)
-> m VarAnn -> m (FieldAnn -> Type -> InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> Type -> InstrAbstract op)
-> m FieldAnn -> m (Type -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> InstrAbstract op) -> m Type -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
TRANSFER_TOKENS (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
SET_DELEGATE (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
IMPLICIT_ACCOUNT (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
NOW (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
AMOUNT (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
BALANCE (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
CHECK_SIGNATURE (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
SHA256 (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
SHA512 (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
BLAKE2B (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
HASH_KEY (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
SOURCE (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
SENDER (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
ADDRESS (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
CHAIN_ID (VarAnn -> InstrAbstract op) -> m VarAnn -> m (InstrAbstract op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
  ]

genContract :: (MonadGen m, GenBase m ~ Identity) => m Contract
genContract :: m Contract
genContract = m ExpandedOp -> m Contract
forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> m (Contract' op)
genContract' m ExpandedOp
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m ExpandedOp
genExpandedOp

genContract' :: (MonadGen m, GenBase m ~ Identity) => m op -> m (Contract' op)
genContract' :: m op -> m (Contract' op)
genContract' genOp :: m op
genOp = ParameterType -> Type -> [op] -> Contract' op
forall op. ParameterType -> Type -> [op] -> Contract' op
Contract (ParameterType -> Type -> [op] -> Contract' op)
-> m ParameterType -> m (Type -> [op] -> Contract' op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ParameterType
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m ParameterType
genParameterType m (Type -> [op] -> Contract' op)
-> m Type -> m ([op] -> Contract' op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m ([op] -> Contract' op) -> m [op] -> m (Contract' op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m [op]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m op
genOp

genValue :: (MonadGen m, GenBase m ~ Identity) => m Value
genValue :: m Value
genValue = m ExpandedOp -> m Value
forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' m ExpandedOp
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m ExpandedOp
genExpandedOp

genValue' :: MonadGen m => m op -> m (Value' op)
genValue' :: m op -> m (Value' op)
genValue' genOp :: m op
genOp = ([m (Value' op)] -> m (Value' op))
-> [m (Value' op)] -> [m (Value' op)] -> m (Value' op)
forall (m :: * -> *) a.
MonadGen m =>
([m a] -> m a) -> [m a] -> [m a] -> m a
Gen.recursive [m (Value' op)] -> m (Value' op)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
  -- non-recursive constructors
  [ Integer -> Value' op
forall op. Integer -> Value' op
ValueInt (Integer -> Value' op) -> m Integer -> m (Value' op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Integer -> m Integer
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Integer -> Integer -> Integer -> Range Integer
forall a. Integral a => a -> a -> a -> Range a
Range.linearFrom 0 (Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> Integer) -> Int64 -> Integer
forall a b. (a -> b) -> a -> b
$ Bounded Int64 => Int64
forall a. Bounded a => a
minBound @Int64) (Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64 -> Integer) -> Word64 -> Integer
forall a b. (a -> b) -> a -> b
$ Bounded Word64 => Word64
forall a. Bounded a => a
maxBound @Word64))
  , MText -> Value' op
forall op. MText -> Value' op
ValueString (MText -> Value' op) -> m MText -> m (Value' op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m MText
forall (m :: * -> *). MonadGen m => m MText
genMText
  , InternalByteString -> Value' op
forall op. InternalByteString -> Value' op
ValueBytes (InternalByteString -> Value' op)
-> m InternalByteString -> m (Value' op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m InternalByteString
forall (m :: * -> *). MonadGen m => m InternalByteString
genInternalByteString
  , Value' op -> m (Value' op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value' op
forall op. Value' op
ValueUnit
  , Value' op -> m (Value' op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value' op
forall op. Value' op
ValueTrue
  , Value' op -> m (Value' op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value' op
forall op. Value' op
ValueFalse
  , Value' op -> m (Value' op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value' op
forall op. Value' op
ValueNone
  , Value' op -> m (Value' op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value' op
forall op. Value' op
ValueNil
  ]
  -- recursive constructors
  [ m (Value' op)
-> m (Value' op)
-> (Value' op -> Value' op -> Value' op)
-> m (Value' op)
forall (m :: * -> *) a.
MonadGen m =>
m a -> m a -> (a -> a -> a) -> m a
Gen.subterm2 (m op -> m (Value' op)
forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' m op
genOp) (m op -> m (Value' op)
forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' m op
genOp) Value' op -> Value' op -> Value' op
forall op. Value' op -> Value' op -> Value' op
ValuePair
  , m (Value' op) -> (Value' op -> Value' op) -> m (Value' op)
forall (m :: * -> *) a. MonadGen m => m a -> (a -> a) -> m a
Gen.subterm (m op -> m (Value' op)
forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' m op
genOp) Value' op -> Value' op
forall op. Value' op -> Value' op
ValueLeft
  , m (Value' op) -> (Value' op -> Value' op) -> m (Value' op)
forall (m :: * -> *) a. MonadGen m => m a -> (a -> a) -> m a
Gen.subterm (m op -> m (Value' op)
forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' m op
genOp) Value' op -> Value' op
forall op. Value' op -> Value' op
ValueRight
  , m (Value' op) -> (Value' op -> Value' op) -> m (Value' op)
forall (m :: * -> *) a. MonadGen m => m a -> (a -> a) -> m a
Gen.subterm (m op -> m (Value' op)
forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' m op
genOp) Value' op -> Value' op
forall op. Value' op -> Value' op
ValueSome
  , (NonEmpty $ Value' op) -> Value' op
forall op. (NonEmpty $ Value' op) -> Value' op
ValueSeq ((NonEmpty $ Value' op) -> Value' op)
-> m (NonEmpty $ Value' op) -> m (Value' op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Value' op) -> m (NonEmpty $ Value' op)
forall (m :: * -> *) a. MonadGen m => m a -> m (NonEmpty a)
genSmallNonEmpty (m op -> m (Value' op)
forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' m op
genOp)
  , (NonEmpty $ Elt op) -> Value' op
forall op. (NonEmpty $ Elt op) -> Value' op
ValueMap ((NonEmpty $ Elt op) -> Value' op)
-> m (NonEmpty $ Elt op) -> m (Value' op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Elt op) -> m (NonEmpty $ Elt op)
forall (m :: * -> *) a. MonadGen m => m a -> m (NonEmpty a)
genSmallNonEmpty (m op -> m (Elt op)
forall (m :: * -> *) op. MonadGen m => m op -> m (Elt op)
genElt m op
genOp)
  , NonEmpty op -> Value' op
forall op. NonEmpty op -> Value' op
ValueLambda (NonEmpty op -> Value' op) -> m (NonEmpty op) -> m (Value' op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m (NonEmpty op)
forall (m :: * -> *) a. MonadGen m => m a -> m (NonEmpty a)
genSmallNonEmpty m op
genOp
  ]

genElt :: MonadGen m => m op -> m (Elt op)
genElt :: m op -> m (Elt op)
genElt genOp :: m op
genOp = Value' op -> Value' op -> Elt op
forall op. Value' op -> Value' op -> Elt op
Elt (Value' op -> Value' op -> Elt op)
-> m (Value' op) -> m (Value' op -> Elt op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m op -> m (Value' op)
forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' m op
genOp m (Value' op -> Elt op) -> m (Value' op) -> m (Elt op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m op -> m (Value' op)
forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' m op
genOp

genParameterType :: (MonadGen m, GenBase m ~ Identity) => m ParameterType
genParameterType :: m ParameterType
genParameterType = Type -> RootAnn -> ParameterType
ParameterType (Type -> RootAnn -> ParameterType)
-> m Type -> m (RootAnn -> ParameterType)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m (RootAnn -> ParameterType) -> m RootAnn -> m ParameterType
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m RootAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation


genType :: (MonadGen m, GenBase m ~ Identity) => m Type
genType :: m Type
genType = T -> TypeAnn -> Type
Type (T -> TypeAnn -> Type) -> m T -> m (TypeAnn -> Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m T
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m T
genT m (TypeAnn -> Type) -> m TypeAnn -> m Type
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m TypeAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation

genEpName :: (MonadGen m, GenBase m ~ Identity) => m EpName
genEpName :: m EpName
genEpName = (FieldAnn -> Maybe EpName) -> m FieldAnn -> m EpName
forall (m :: * -> *) a b.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Maybe b) -> m a -> m b
Gen.mapMaybe (Either EpNameFromRefAnnError EpName -> Maybe EpName
forall l r. Either l r -> Maybe r
rightToMaybe (Either EpNameFromRefAnnError EpName -> Maybe EpName)
-> (FieldAnn -> Either EpNameFromRefAnnError EpName)
-> FieldAnn
-> Maybe EpName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldAnn -> Either EpNameFromRefAnnError EpName
epNameFromRefAnn) m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation

genAnnotation :: forall m a. (MonadGen m, GenBase m ~ Identity) => m (Annotation a)
genAnnotation :: m (Annotation a)
genAnnotation = (Text -> Maybe (Annotation a)) -> m Text -> m (Annotation a)
forall (m :: * -> *) a b.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Maybe b) -> m a -> m b
Gen.mapMaybe (Either Text (Annotation a) -> Maybe (Annotation a)
forall l r. Either l r -> Maybe r
rightToMaybe (Either Text (Annotation a) -> Maybe (Annotation a))
-> (Text -> Either Text (Annotation a))
-> Text
-> Maybe (Annotation a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either Text (Annotation a)
forall k (a :: k). Text -> Either Text (Annotation a)
mkAnnotation) m Text
genAnnotationText
  where
    genAnnotationText :: m Text
    genAnnotationText :: m Text
genAnnotationText = [(Int, m Text)] -> m Text
forall (m :: * -> *) a. MonadGen m => [(Int, m a)] -> m a
Gen.frequency
      [ (1, Text -> m Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure "")
      , (17, Char -> Text -> Text
T.cons (Char -> Text -> Text) -> m Char -> m (Text -> Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Char
annStart m (Text -> Text) -> m Text -> m Text
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Range Int -> m Char -> m 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 0 100) m Char
annBodyChar)
      , (1, Text -> m Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
specialFieldAnn)
      , (1, [Text] -> m Text
forall (m :: * -> *) a. MonadGen m => [a] -> m a
Gen.element [Text]
specialVarAnns)
      ]

    annStart :: m Char
    annStart :: m Char
annStart = [m Char] -> m Char
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice [ Char -> m Char
forall (f :: * -> *) a. Applicative f => a -> f a
pure '_', m Char
forall (m :: * -> *). MonadGen m => m Char
Gen.alphaNum ]

    annBodyChar :: m Char
    annBodyChar :: m Char
annBodyChar = [m Char] -> m Char
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice [ m Char
annStart, [Char] -> m Char
forall (m :: * -> *) a. MonadGen m => [a] -> m a
Gen.element (".%@" :: String) ]

genT :: (MonadGen m, GenBase m ~ Identity) => m T
genT :: m T
genT =
  ([m T] -> m T) -> [m T] -> [m T] -> m T
forall (m :: * -> *) a.
MonadGen m =>
([m a] -> m a) -> [m a] -> [m a] -> m a
Gen.recursive [m T] -> m T
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    -- non-recursive constructors
    [ T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TKey
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TUnit
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TSignature
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TChainId
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TOperation
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TInt
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TNat
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TString
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TBytes
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TMutez
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TBool
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TKeyHash
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TTimestamp
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TAddress
    ]
    -- recursive constructors
    [ Type -> T
TOption (Type -> T) -> m Type -> m T
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
    , Type -> T
TList (Type -> T) -> m Type -> m T
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
    , Type -> T
TSet (Type -> T) -> m Type -> m T
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
    , Type -> T
TContract (Type -> T) -> m Type -> m T
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
    , FieldAnn -> FieldAnn -> Type -> Type -> T
TPair (FieldAnn -> FieldAnn -> Type -> Type -> T)
-> m FieldAnn -> m (FieldAnn -> Type -> Type -> T)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> Type -> Type -> T)
-> m FieldAnn -> m (Type -> Type -> T)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> Type -> T) -> m Type -> m (Type -> T)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m (Type -> T) -> m Type -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
    , FieldAnn -> FieldAnn -> Type -> Type -> T
TOr (FieldAnn -> FieldAnn -> Type -> Type -> T)
-> m FieldAnn -> m (FieldAnn -> Type -> Type -> T)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (FieldAnn -> Type -> Type -> T)
-> m FieldAnn -> m (Type -> Type -> T)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall k (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation m (Type -> Type -> T) -> m Type -> m (Type -> T)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m (Type -> T) -> m Type -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
    , Type -> Type -> T
TLambda (Type -> Type -> T) -> m Type -> m (Type -> T)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m (Type -> T) -> m Type -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
    , Type -> Type -> T
TMap (Type -> Type -> T) -> m Type -> m (Type -> T)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m (Type -> T) -> m Type -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
    , Type -> Type -> T
TBigMap (Type -> Type -> T) -> m Type -> m (Type -> T)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType m (Type -> T) -> m Type -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Type
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Type
genType
    ]

smallCollectionRange :: Range Int
smallCollectionRange :: Range Int
smallCollectionRange = Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear 0 3

genSmallList :: MonadGen m => m a -> m [a]
genSmallList :: m a -> m [a]
genSmallList = Range Int -> m a -> m [a]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list Range Int
smallCollectionRange

genSmallNonEmpty :: MonadGen m => m a -> m (NonEmpty a)
genSmallNonEmpty :: m a -> m (NonEmpty a)
genSmallNonEmpty = Range Int -> m a -> m (NonEmpty a)
forall (m :: * -> *) a.
MonadGen m =>
Range Int -> m a -> m (NonEmpty a)
Gen.nonEmpty Range Int
smallCollectionRange

genSmallText :: MonadGen m => m Text
genSmallText :: m Text
genSmallText = Range Int -> m Char -> m 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 0 10) m Char
forall (m :: * -> *). MonadGen m => m Char
Gen.unicodeAll