-- SPDX-FileCopyrightText: 2021 Oxhead Alpha
-- SPDX-License-Identifier: LicenseRef-MIT-OA

module Hedgehog.Gen.Michelson.Untyped
  ( genInternalByteString
  , genVar
  , genTyVar
  , genExpandedOp
  , genExtInstrAbstract
  , genPrintComment
  , genStackRef
  , genTestAssert
  , genStackTypePattern
  , genInstrAbstract
  , genContract
  , genContract'
  , genEntriesOrder
  , genValue
  , genValue'
  , genElt
  , genParameterType
  , genType
  , genEpName
  , genAnnotation
  , genT
  ) where

import Prelude hiding (EQ, GT, LT)

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

import Morley.Michelson.Untyped

import Hedgehog.Gen.Michelson (genErrorSrcPos, genMText)
import Hedgehog.Range.Defaults

genInternalByteString :: MonadGen m => Range Length -> m InternalByteString
genInternalByteString :: forall (m :: * -> *).
MonadGen m =>
Range Length -> m InternalByteString
genInternalByteString Range Length
rangeLen = 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 (Length -> Int
unLength (Length -> Int) -> Range Length -> Range Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Length
rangeLen)

genVar :: MonadGen m => m Var
genVar :: forall (m :: * -> *). MonadGen m => 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 :: forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => 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, Ty -> TyVar
TyCon (Ty -> TyVar) -> m Ty -> m TyVar
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType]

genExpandedOp :: (MonadGen m, GenBase m ~ Identity) => m ExpandedOp
genExpandedOp :: forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
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 -> ErrorSrcPos -> ExpandedOp -> ExpandedOp
WithSrcEx (ErrorSrcPos -> ExpandedOp -> ExpandedOp)
-> m ErrorSrcPos -> m (ExpandedOp -> ExpandedOp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ErrorSrcPos
forall (m :: * -> *). MonadGen m => m ErrorSrcPos
genErrorSrcPos 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
  ]

genExtInstrAbstract :: (MonadGen m, GenBase m ~ Identity) => m op -> m (ExtInstrAbstract op)
genExtInstrAbstract :: forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> m (ExtInstrAbstract op)
genExtInstrAbstract 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
  , 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
<$> Range TinyLength -> m PrintComment
forall (m :: * -> *).
MonadGen m =>
Range TinyLength -> m PrintComment
genPrintComment Range TinyLength
forall a. Default a => a
def
  , 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 => Range TinyLength -> m PrintComment
genPrintComment :: forall (m :: * -> *).
MonadGen m =>
Range TinyLength -> m PrintComment
genPrintComment Range TinyLength
rangeLen = [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 (TinyLength -> Int
unTinyLength (TinyLength -> Int) -> Range TinyLength -> Range Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range TinyLength
rangeLen)
  (m Text -> m StackRef -> m (Either Text StackRef)
forall (m :: * -> *) a b.
MonadGen m =>
m a -> m b -> m (Either a b)
Gen.either m Text
forall (m :: * -> *). MonadGen m => m Text
genSmallText (Range StackRef -> m StackRef
forall (m :: * -> *). MonadGen m => Range StackRef -> m StackRef
genStackRef Range StackRef
forall a. Default a => a
def))

genStackRef :: MonadGen m => Range StackRef -> m StackRef
genStackRef :: forall (m :: * -> *). MonadGen m => Range StackRef -> m StackRef
genStackRef Range StackRef
range = 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 (StackRef -> Natural
unStackRef (StackRef -> Natural) -> Range StackRef -> Range Natural
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range StackRef
range)
  where unStackRef :: StackRef -> Natural
unStackRef (StackRef Natural
x) = Natural
x

genTestAssert :: MonadGen m => m op -> m (TestAssert op)
genTestAssert :: forall (m :: * -> *) op. MonadGen m => m op -> m (TestAssert op)
genTestAssert 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
<*> Range TinyLength -> m PrintComment
forall (m :: * -> *).
MonadGen m =>
Range TinyLength -> m PrintComment
genPrintComment Range TinyLength
forall a. Default a => a
def 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

genStackTypePattern :: (MonadGen m, GenBase m ~ Identity) => m StackTypePattern
genStackTypePattern :: forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
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
$ \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 :: forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> m (InstrAbstract op)
genInstrAbstract 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 :: forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> [m (InstrAbstract op)]
instrAbstractWithOp 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 -> Ty -> Value' op -> InstrAbstract op
forall op. VarAnn -> Ty -> Value' op -> InstrAbstract op
PUSH (VarAnn -> Ty -> Value' op -> InstrAbstract op)
-> m VarAnn -> m (Ty -> 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 (Ty -> Value' op -> InstrAbstract op)
-> m Ty -> m (Value' op -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
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 -> Ty -> Ty -> [op] -> InstrAbstract op
forall op. VarAnn -> Ty -> Ty -> [op] -> InstrAbstract op
LAMBDA (VarAnn -> Ty -> Ty -> [op] -> InstrAbstract op)
-> m VarAnn -> m (Ty -> Ty -> [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 (Ty -> Ty -> [op] -> InstrAbstract op)
-> m Ty -> m (Ty -> [op] -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType m (Ty -> [op] -> InstrAbstract op)
-> m Ty -> m ([op] -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
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 :: forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
[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
  , VarAnn -> Word -> InstrAbstract op
forall op. VarAnn -> Word -> InstrAbstract op
DUPN (VarAnn -> Word -> InstrAbstract op)
-> m VarAnn -> m (Word -> 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 (Word -> InstrAbstract op) -> m Word -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => 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
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 -> Ty -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Ty -> InstrAbstract op
NONE (TypeAnn -> VarAnn -> Ty -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m VarAnn -> m (Ty -> 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 (Ty -> InstrAbstract op) -> m Ty -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
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 -> Word -> InstrAbstract op
forall op. VarAnn -> Word -> InstrAbstract op
PAIRN (VarAnn -> Word -> InstrAbstract op)
-> m VarAnn -> m (Word -> 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 (Word -> InstrAbstract op) -> m Word -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => 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
UNPAIRN (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
  , 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 -> Ty -> InstrAbstract op
forall op.
TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract op
LEFT (TypeAnn
 -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract op)
-> m TypeAnn
-> m (VarAnn -> FieldAnn -> FieldAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m VarAnn -> m (FieldAnn -> FieldAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m FieldAnn -> m (FieldAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m FieldAnn -> m (Ty -> 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 (Ty -> InstrAbstract op) -> m Ty -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
  , TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract op
forall op.
TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract op
RIGHT (TypeAnn
 -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract op)
-> m TypeAnn
-> m (VarAnn -> FieldAnn -> FieldAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m VarAnn -> m (FieldAnn -> FieldAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m FieldAnn -> m (FieldAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m FieldAnn -> m (Ty -> 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 (Ty -> InstrAbstract op) -> m Ty -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
  , TypeAnn -> VarAnn -> Ty -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Ty -> InstrAbstract op
NIL (TypeAnn -> VarAnn -> Ty -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m VarAnn -> m (Ty -> 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 (Ty -> InstrAbstract op) -> m Ty -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
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 -> Ty -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Ty -> InstrAbstract op
EMPTY_SET (TypeAnn -> VarAnn -> Ty -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m VarAnn -> m (Ty -> 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 (Ty -> InstrAbstract op) -> m Ty -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
  , TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract op
EMPTY_MAP (TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Ty -> Ty -> 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 -> Ty -> Ty -> InstrAbstract op)
-> m VarAnn -> m (Ty -> Ty -> 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 (Ty -> Ty -> InstrAbstract op)
-> m Ty -> m (Ty -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType m (Ty -> InstrAbstract op) -> m Ty -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
  , TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract op
EMPTY_BIG_MAP (TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Ty -> Ty -> 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 -> Ty -> Ty -> InstrAbstract op)
-> m VarAnn -> m (Ty -> Ty -> 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 (Ty -> Ty -> InstrAbstract op)
-> m Ty -> m (Ty -> InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType m (Ty -> InstrAbstract op) -> m Ty -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
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 -> Word -> InstrAbstract op
forall op. VarAnn -> Word -> InstrAbstract op
GETN (VarAnn -> Word -> InstrAbstract op)
-> m VarAnn -> m (Word -> 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 (Word -> InstrAbstract op) -> m Word -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => 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
  , 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 -> Ty -> InstrAbstract op
forall op. VarAnn -> Ty -> InstrAbstract op
CAST (VarAnn -> Ty -> InstrAbstract op)
-> m VarAnn -> m (Ty -> 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 (Ty -> InstrAbstract op) -> m Ty -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
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 -> Ty -> InstrAbstract op
forall op. TypeAnn -> VarAnn -> Ty -> InstrAbstract op
UNPACK (TypeAnn -> VarAnn -> Ty -> InstrAbstract op)
-> m TypeAnn -> m (VarAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m VarAnn -> m (Ty -> 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 (Ty -> InstrAbstract op) -> m Ty -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
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
SUB_MUTEZ (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 -> Ty -> InstrAbstract op
forall op. VarAnn -> FieldAnn -> Ty -> InstrAbstract op
CONTRACT (VarAnn -> FieldAnn -> Ty -> InstrAbstract op)
-> m VarAnn -> m (FieldAnn -> Ty -> 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 -> Ty -> InstrAbstract op)
-> m FieldAnn -> m (Ty -> 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 (Ty -> InstrAbstract op) -> m Ty -> m (InstrAbstract op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
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
SHA3 (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
KECCAK (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
  , VarAnn -> InstrAbstract op
forall op. VarAnn -> InstrAbstract op
LEVEL (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
SELF_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
  ]

genContract :: (MonadGen m, GenBase m ~ Identity) => m Contract
genContract :: forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
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' :: forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> m (Contract' op)
genContract' m op
genOp = ParameterType
-> Ty -> [op] -> EntriesOrder -> ViewsSet op -> Contract' op
forall op.
ParameterType
-> Ty -> [op] -> EntriesOrder -> ViewsSet op -> Contract' op
Contract
  (ParameterType
 -> Ty -> [op] -> EntriesOrder -> ViewsSet op -> Contract' op)
-> m ParameterType
-> m (Ty -> [op] -> EntriesOrder -> ViewsSet 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 (Ty -> [op] -> EntriesOrder -> ViewsSet op -> Contract' op)
-> m Ty -> m ([op] -> EntriesOrder -> ViewsSet op -> Contract' op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
  m ([op] -> EntriesOrder -> ViewsSet op -> Contract' op)
-> m [op] -> m (EntriesOrder -> ViewsSet op -> 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
  m (EntriesOrder -> ViewsSet op -> Contract' op)
-> m EntriesOrder -> m (ViewsSet op -> Contract' op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m EntriesOrder
forall (m :: * -> *). MonadGen m => m EntriesOrder
genEntriesOrder
  m (ViewsSet op -> Contract' op)
-> m (ViewsSet op) -> m (Contract' op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Map ViewName (View' op) -> ViewsSet op)
-> m (Map ViewName (View' op)) -> m (ViewsSet op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Map ViewName (View' op) -> ViewsSet op
forall instr. Map ViewName (View' instr) -> ViewsSet instr
UnsafeViewsSet (Range Int -> m (ViewName, View' op) -> m (Map ViewName (View' op))
forall (m :: * -> *) k v.
(MonadGen m, Ord k) =>
Range Int -> m (k, v) -> m (Map k v)
Gen.map (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.exponential Int
0 Int
2) m (ViewName, View' op)
genSomeViewWithName)
  where
    genSomeViewWithName :: m (ViewName, View' op)
genSomeViewWithName = do
      View' op
v <- m op -> m (View' op)
forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> m (View' op)
genSomeView m op
genOp
      pure (View' op -> ViewName
forall op. View' op -> ViewName
viewName View' op
v, View' op
v)

genEntriesOrder :: (MonadGen m) => m EntriesOrder
genEntriesOrder :: forall (m :: * -> *). MonadGen m => m EntriesOrder
genEntriesOrder =
  [Entry] -> EntriesOrder
mkEntriesOrder ([Entry] -> EntriesOrder) -> m [Entry] -> m EntriesOrder
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Entry] -> m [Entry]
forall (m :: * -> *) a. MonadGen m => [a] -> m [a]
Gen.shuffle (Map Entry Word -> [Entry]
forall k a. Map k a -> [k]
Map.keys (Map Entry Word -> [Entry]) -> Map Entry Word -> [Entry]
forall a b. (a -> b) -> a -> b
$ EntriesOrder -> Map Entry Word
unEntriesOrder EntriesOrder
canonicalEntriesOrder)

genViewName :: (MonadGen m, GenBase m ~ Identity) => m ViewName
genViewName :: forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m ViewName
genViewName = Either BadViewNameError ViewName -> ViewName
forall a b. (HasCallStack, Buildable a) => Either a b -> b
unsafe (Either BadViewNameError ViewName -> ViewName)
-> (Text -> Either BadViewNameError ViewName) -> Text -> ViewName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either BadViewNameError ViewName
mkViewName (Text -> ViewName) -> m Text -> m ViewName
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 Int
0 Int
viewNameMaxLength)
  ((Char -> Bool) -> m Char -> m Char
forall (m :: * -> *) a.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Bool) -> m a -> m a
Gen.filter Char -> Bool
isValidViewNameChar m Char
forall (m :: * -> *). MonadGen m => m Char
Gen.ascii)

genSomeView :: (MonadGen m, GenBase m ~ Identity) => m op -> m (View' op)
genSomeView :: forall (m :: * -> *) op.
(MonadGen m, GenBase m ~ Identity) =>
m op -> m (View' op)
genSomeView m op
genOp = ViewName -> Ty -> Ty -> [op] -> View' op
forall op. ViewName -> Ty -> Ty -> [op] -> View' op
View
  (ViewName -> Ty -> Ty -> [op] -> View' op)
-> m ViewName -> m (Ty -> Ty -> [op] -> View' op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ViewName
forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m ViewName
genViewName
  m (Ty -> Ty -> [op] -> View' op)
-> m Ty -> m (Ty -> [op] -> View' op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
  m (Ty -> [op] -> View' op) -> m Ty -> m ([op] -> View' op)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
  m ([op] -> View' op) -> m [op] -> m (View' 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 :: forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => 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

genValueInt :: MonadGen m => Range ValueInt -> m (Value' op)
genValueInt :: forall (m :: * -> *) op.
MonadGen m =>
Range ValueInt -> m (Value' op)
genValueInt Range ValueInt
range = 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 (ValueInt -> Integer
unValueInt (ValueInt -> Integer) -> Range ValueInt -> Range Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range ValueInt
range)

genValueString :: MonadGen m => Range Length -> m (Value' op)
genValueString :: forall (m :: * -> *) op.
MonadGen m =>
Range Length -> m (Value' op)
genValueString = (MText -> Value' op) -> m MText -> m (Value' op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MText -> Value' op
forall op. MText -> Value' op
ValueString (m MText -> m (Value' op))
-> (Range Length -> m MText) -> Range Length -> m (Value' op)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Range Length -> m MText
forall (m :: * -> *). MonadGen m => Range Length -> m MText
genMText

genValueBytes :: MonadGen m => Range Length -> m (Value' op)
genValueBytes :: forall (m :: * -> *) op.
MonadGen m =>
Range Length -> m (Value' op)
genValueBytes = (InternalByteString -> Value' op)
-> m InternalByteString -> m (Value' op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap InternalByteString -> Value' op
forall op. InternalByteString -> Value' op
ValueBytes (m InternalByteString -> m (Value' op))
-> (Range Length -> m InternalByteString)
-> Range Length
-> m (Value' op)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Range Length -> m InternalByteString
forall (m :: * -> *).
MonadGen m =>
Range Length -> m InternalByteString
genInternalByteString

genValue' :: MonadGen m => m op -> m (Value' op)
genValue' :: forall (m :: * -> *) op. MonadGen m => m op -> m (Value' op)
genValue' 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
  [ Range ValueInt -> m (Value' op)
forall (m :: * -> *) op.
MonadGen m =>
Range ValueInt -> m (Value' op)
genValueInt Range ValueInt
forall a. Default a => a
def
  , Range Length -> m (Value' op)
forall (m :: * -> *) op.
MonadGen m =>
Range Length -> m (Value' op)
genValueString Range Length
forall a. Default a => a
def
  , Range Length -> m (Value' op)
forall (m :: * -> *) op.
MonadGen m =>
Range Length -> m (Value' op)
genValueBytes Range Length
forall a. Default a => a
def
  , 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 :: forall (m :: * -> *) op. MonadGen m => m op -> m (Elt op)
genElt 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 :: forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
m ParameterType
genParameterType = Ty -> FieldAnn -> ParameterType
ParameterType (Ty -> FieldAnn -> ParameterType)
-> m Ty -> m (FieldAnn -> ParameterType)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType m (FieldAnn -> ParameterType) -> m FieldAnn -> m ParameterType
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

-- | Generate a 'Ty'.
genType :: (MonadGen m, GenBase m ~ Identity) => m Ty
genType :: forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType = T -> TypeAnn -> Ty
Ty (T -> TypeAnn -> Ty) -> m T -> m (TypeAnn -> Ty)
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 -> Ty) -> m TypeAnn -> m Ty
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

genComparableType :: (MonadGen m, GenBase m ~ Identity) => m Ty
genComparableType :: forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genComparableType = T -> TypeAnn -> Ty
Ty (T -> TypeAnn -> Ty) -> m T -> m (TypeAnn -> Ty)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m T
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m T
genComparableT m (TypeAnn -> Ty) -> m TypeAnn -> m Ty
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 :: forall (m :: * -> *).
(MonadGen m, GenBase m ~ Identity) =>
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 :: forall {k} (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
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
      [ (Int
1, Text -> m Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"")
      , (Int
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 Int
0 Int
100) m Char
annBodyChar)
      , (Int
1, Text -> m Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
specialFieldAnn)
      , (Int
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 Char
'_', 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 ([Char]
".%@" :: String) ]

-- | Generate a 'T'.
genT :: (MonadGen m, GenBase m ~ Identity) => m T
genT :: forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => 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
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TChest
    , T -> m T
forall (f :: * -> *) a. Applicative f => a -> f a
pure T
TChestKey
    ]
    -- recursive constructors
    [ Ty -> T
TOption (Ty -> T) -> m Ty -> m T
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
    , Ty -> T
TList (Ty -> T) -> m Ty -> m T
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
    , Ty -> T
TSet (Ty -> T) -> m Ty -> m T
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genComparableType
    , Ty -> T
TContract (Ty -> T) -> m Ty -> m T
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
    , FieldAnn -> FieldAnn -> VarAnn -> VarAnn -> Ty -> Ty -> T
TPair (FieldAnn -> FieldAnn -> VarAnn -> VarAnn -> Ty -> Ty -> T)
-> m FieldAnn -> m (FieldAnn -> VarAnn -> VarAnn -> Ty -> Ty -> 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 -> VarAnn -> VarAnn -> Ty -> Ty -> T)
-> m FieldAnn -> m (VarAnn -> VarAnn -> Ty -> Ty -> 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 (VarAnn -> VarAnn -> Ty -> Ty -> T)
-> m VarAnn -> m (VarAnn -> Ty -> Ty -> T)
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 (VarAnn -> Ty -> Ty -> T) -> m VarAnn -> m (Ty -> Ty -> T)
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 (Ty -> Ty -> T) -> m Ty -> m (Ty -> T)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType m (Ty -> T) -> m Ty -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
    , FieldAnn -> FieldAnn -> Ty -> Ty -> T
TOr (FieldAnn -> FieldAnn -> Ty -> Ty -> T)
-> m FieldAnn -> m (FieldAnn -> Ty -> Ty -> 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 -> Ty -> Ty -> T) -> m FieldAnn -> m (Ty -> Ty -> 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 (Ty -> Ty -> T) -> m Ty -> m (Ty -> T)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType m (Ty -> T) -> m Ty -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
    , Ty -> Ty -> T
TLambda (Ty -> Ty -> T) -> m Ty -> m (Ty -> T)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType m (Ty -> T) -> m Ty -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
    , Ty -> Ty -> T
TMap (Ty -> Ty -> T) -> m Ty -> m (Ty -> T)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genComparableType m (Ty -> T) -> m Ty -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
    , Ty -> Ty -> T
TBigMap (Ty -> Ty -> T) -> m Ty -> m (Ty -> T)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genComparableType m (Ty -> T) -> m Ty -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genType
    ]

-- We don't need to pass @mustBeValid@ here because comparable types are always valid.
genComparableT :: (MonadGen m, GenBase m ~ Identity) => m T
genComparableT :: forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m T
genComparableT =
  ([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
    [ 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
    ]
    [ FieldAnn -> FieldAnn -> VarAnn -> VarAnn -> Ty -> Ty -> T
TPair (FieldAnn -> FieldAnn -> VarAnn -> VarAnn -> Ty -> Ty -> T)
-> m FieldAnn -> m (FieldAnn -> VarAnn -> VarAnn -> Ty -> Ty -> 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 -> VarAnn -> VarAnn -> Ty -> Ty -> T)
-> m FieldAnn -> m (VarAnn -> VarAnn -> Ty -> Ty -> 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 (VarAnn -> VarAnn -> Ty -> Ty -> T)
-> m VarAnn -> m (VarAnn -> Ty -> Ty -> T)
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 (VarAnn -> Ty -> Ty -> T) -> m VarAnn -> m (Ty -> Ty -> T)
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 (Ty -> Ty -> T) -> m Ty -> m (Ty -> T)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genComparableType m (Ty -> T) -> m Ty -> m T
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Ty
forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Ty
genComparableType
    ]

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

genSmallList :: MonadGen m => m a -> m [a]
genSmallList :: forall (m :: * -> *) a. MonadGen m => 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 :: forall (m :: * -> *) a. MonadGen m => 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 :: forall (m :: * -> *). MonadGen m => 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 Int
0 Int
10) m Char
forall (m :: * -> *). MonadGen m => m Char
Gen.unicodeAll