-- 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
  , genMacro
  ) 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.Macro
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 (f :: * -> *) op. StackTypePattern -> ExtInstrAbstract f 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 (f :: * -> *) op. TestAssert f op -> ExtInstrAbstract f 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 (f :: * -> *) op. PrintComment -> ExtInstrAbstract f 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 (f :: * -> *) op. Text -> ExtInstrAbstract f 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 (f :: * -> *) op.
Text -> PrintComment -> f op -> TestAssert f 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 (f :: * -> *) op.
ExtInstrAbstract f op -> InstrAbstract f 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 (f :: * -> *) op.
VarAnn -> Ty -> Value' f op -> InstrAbstract f 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 (f :: * -> *) op. f op -> f op -> InstrAbstract f 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 (f :: * -> *) op. f op -> f op -> InstrAbstract f 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 (f :: * -> *) op. f op -> f op -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> f op -> InstrAbstract f 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 (f :: * -> *) op. f op -> InstrAbstract f 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 (f :: * -> *) op. f op -> f op -> InstrAbstract f 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 (f :: * -> *) op. f op -> InstrAbstract f 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 (f :: * -> *) op. f op -> InstrAbstract f 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 (f :: * -> *) op.
VarAnn -> Ty -> Ty -> f op -> InstrAbstract f 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 (f :: * -> *) op. f op -> InstrAbstract f 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 (f :: * -> *) op. Word -> f op -> InstrAbstract f 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 (f :: * -> *) op.
VarAnn -> VarAnn -> Contract' op -> InstrAbstract f 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 (f :: * -> *) op. Word -> InstrAbstract f 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 (f :: * -> *) op. InstrAbstract f op
DROP
  , VarAnn -> InstrAbstract [] op
forall (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> Word -> InstrAbstract f 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 (f :: * -> *) op. InstrAbstract f op
SWAP
  , Word -> InstrAbstract [] op
forall (f :: * -> *) op. Word -> InstrAbstract f 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 (f :: * -> *) op. Word -> InstrAbstract f 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 (f :: * -> *) op. TypeAnn -> VarAnn -> InstrAbstract f 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 (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> InstrAbstract f 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 (f :: * -> *) op. TypeAnn -> VarAnn -> InstrAbstract f 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 (f :: * -> *) op.
TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> Word -> InstrAbstract f 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 (f :: * -> *) op. Word -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> FieldAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> FieldAnn -> InstrAbstract f 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 (f :: * -> *) op.
TypeAnn
-> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract f 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 (f :: * -> *) op.
TypeAnn
-> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract f 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 (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> InstrAbstract f 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 (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract f 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 (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> Word -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. InstrAbstract f op
FAILWITH
  , VarAnn -> Ty -> InstrAbstract [] op
forall (f :: * -> *) op. VarAnn -> Ty -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> FieldAnn -> InstrAbstract f 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 (f :: * -> *) op.
VarAnn -> FieldAnn -> Ty -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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
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
ViewsSet (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
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 {k} (f :: k -> *) (op :: k). Integer -> Value' f 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 {k} (f :: k -> *) (op :: k). MText -> Value' f 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 {k} (f :: k -> *) (op :: k).
InternalByteString -> Value' f 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 {k} (f :: k -> *) (op :: k). Value' f op
ValueUnit
  , Value' [] op -> m (Value' [] op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value' [] op
forall {k} (f :: k -> *) (op :: k). Value' f op
ValueTrue
  , Value' [] op -> m (Value' [] op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value' [] op
forall {k} (f :: k -> *) (op :: k). Value' f op
ValueFalse
  , Value' [] op -> m (Value' [] op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value' [] op
forall {k} (f :: k -> *) (op :: k). Value' f op
ValueNone
  , Value' [] op -> m (Value' [] op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value' [] op
forall {k} (f :: k -> *) (op :: k). Value' f 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 {k} (f :: k -> *) (op :: k).
Value' f op -> Value' f op -> Value' f 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 {k} (f :: k -> *) (op :: k). Value' f op -> Value' f 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 {k} (f :: k -> *) (op :: k). Value' f op -> Value' f 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 {k} (f :: k -> *) (op :: k). Value' f op -> Value' f op
ValueSome
  , (NonEmpty $ Value' [] op) -> Value' [] op
forall {k} (f :: k -> *) (op :: k).
(NonEmpty $ Value' f op) -> Value' f 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 {k} (f :: k -> *) (op :: k).
(NonEmpty $ Elt f op) -> Value' f 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)
  , [op] -> Value' [] op
forall {k} (f :: k -> *) (op :: k). f op -> Value' f op
ValueLambda ([op] -> Value' [] op)
-> (NonEmpty op -> [op]) -> NonEmpty op -> Value' [] op
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty op -> [op]
forall t. Container t => t -> [Element t]
toList (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 {k} (f :: k -> *) (op :: k).
Value' f op -> Value' f op -> Elt f 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

genMacro :: (MonadGen m, GenBase m ~ Identity) => m Macro
genMacro :: forall (m :: * -> *). (MonadGen m, GenBase m ~ Identity) => m Macro
genMacro = [m Macro] -> m Macro
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
  [ ParsedInstr -> Macro
CMP (ParsedInstr -> Macro) -> m ParsedInstr -> m Macro
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ParsedInstr
cmp
  , ParsedInstr -> ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro
IFX (ParsedInstr -> ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro)
-> m ParsedInstr
-> m (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ParsedInstr
cmp m (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro)
-> m (ParsedSeq ParsedOp) -> m (ParsedSeq ParsedOp -> Macro)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (ParsedSeq ParsedOp)
forall {op}. m (ParsedSeq op)
seq' m (ParsedSeq ParsedOp -> Macro)
-> m (ParsedSeq ParsedOp) -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (ParsedSeq ParsedOp)
forall {op}. m (ParsedSeq op)
seq'
  , ParsedInstr -> ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro
IFCMP (ParsedInstr -> ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro)
-> m ParsedInstr
-> m (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ParsedInstr
cmp m (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro)
-> m (ParsedSeq ParsedOp) -> m (ParsedSeq ParsedOp -> Macro)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (ParsedSeq ParsedOp)
forall {op}. m (ParsedSeq op)
seq' m (ParsedSeq ParsedOp -> Macro)
-> m (ParsedSeq ParsedOp) -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (ParsedSeq ParsedOp)
forall {op}. m (ParsedSeq op)
seq'
  , Macro -> m Macro
forall (f :: * -> *) a. Applicative f => a -> f a
pure Macro
FAIL
  , PairStruct -> TypeAnn -> VarAnn -> Macro
PAPAIR (PairStruct -> TypeAnn -> VarAnn -> Macro)
-> m PairStruct -> m (TypeAnn -> VarAnn -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m PairStruct
pair m (TypeAnn -> VarAnn -> Macro) -> m TypeAnn -> m (VarAnn -> Macro)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m TypeAnn
forall {k} {a :: k}. m (Annotation a)
ann m (VarAnn -> Macro) -> m VarAnn -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann
  , UnpairStruct -> Macro
UNPAPAIR (UnpairStruct -> Macro) -> m UnpairStruct -> m Macro
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m UnpairStruct
unpair
  , [CadrStruct] -> VarAnn -> FieldAnn -> Macro
CADR ([CadrStruct] -> VarAnn -> FieldAnn -> Macro)
-> m [CadrStruct] -> m (VarAnn -> FieldAnn -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m [CadrStruct]
cadr m (VarAnn -> FieldAnn -> Macro)
-> m VarAnn -> m (FieldAnn -> Macro)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann m (FieldAnn -> Macro) -> m FieldAnn -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall {k} {a :: k}. m (Annotation a)
ann
  , VarAnn -> Word -> Macro
CARN (VarAnn -> Word -> Macro) -> m VarAnn -> m (Word -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann m (Word -> Macro) -> m Word -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Word
word
  , VarAnn -> Word -> Macro
CDRN (VarAnn -> Word -> Macro) -> m VarAnn -> m (Word -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann m (Word -> Macro) -> m Word -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Word
word
  , [CadrStruct] -> VarAnn -> FieldAnn -> Macro
SET_CADR ([CadrStruct] -> VarAnn -> FieldAnn -> Macro)
-> m [CadrStruct] -> m (VarAnn -> FieldAnn -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m [CadrStruct]
cadr m (VarAnn -> FieldAnn -> Macro)
-> m VarAnn -> m (FieldAnn -> Macro)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann m (FieldAnn -> Macro) -> m FieldAnn -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall {k} {a :: k}. m (Annotation a)
ann
  , [CadrStruct] -> VarAnn -> FieldAnn -> ParsedSeq ParsedOp -> Macro
MAP_CADR ([CadrStruct] -> VarAnn -> FieldAnn -> ParsedSeq ParsedOp -> Macro)
-> m [CadrStruct]
-> m (VarAnn -> FieldAnn -> ParsedSeq ParsedOp -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m [CadrStruct]
cadr m (VarAnn -> FieldAnn -> ParsedSeq ParsedOp -> Macro)
-> m VarAnn -> m (FieldAnn -> ParsedSeq ParsedOp -> Macro)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann m (FieldAnn -> ParsedSeq ParsedOp -> Macro)
-> m FieldAnn -> m (ParsedSeq ParsedOp -> Macro)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m FieldAnn
forall {k} {a :: k}. m (Annotation a)
ann m (ParsedSeq ParsedOp -> Macro)
-> m (ParsedSeq ParsedOp) -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (ParsedSeq ParsedOp)
forall {op}. m (ParsedSeq op)
seq'
  , Word -> ParsedSeq ParsedOp -> Macro
DIIP (Word -> ParsedSeq ParsedOp -> Macro)
-> m Word -> m (ParsedSeq ParsedOp -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Word
word m (ParsedSeq ParsedOp -> Macro)
-> m (ParsedSeq ParsedOp) -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (ParsedSeq ParsedOp)
forall {op}. m (ParsedSeq op)
seq'
  , Word -> VarAnn -> Macro
DUUP (Word -> VarAnn -> Macro) -> m Word -> m (VarAnn -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Word
word m (VarAnn -> Macro) -> m VarAnn -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann
  , Macro -> m Macro
forall (f :: * -> *) a. Applicative f => a -> f a
pure Macro
ASSERT
  , ParsedInstr -> Macro
ASSERTX (ParsedInstr -> Macro) -> m ParsedInstr -> m Macro
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ParsedInstr
cmp
  , ParsedInstr -> Macro
ASSERT_CMP (ParsedInstr -> Macro) -> m ParsedInstr -> m Macro
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ParsedInstr
cmp
  , Macro -> m Macro
forall (f :: * -> *) a. Applicative f => a -> f a
pure Macro
ASSERT_NONE
  , Macro -> m Macro
forall (f :: * -> *) a. Applicative f => a -> f a
pure Macro
ASSERT_SOME
  , Macro -> m Macro
forall (f :: * -> *) a. Applicative f => a -> f a
pure Macro
ASSERT_LEFT
  , Macro -> m Macro
forall (f :: * -> *) a. Applicative f => a -> f a
pure Macro
ASSERT_RIGHT
  , ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro
IF_SOME (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro)
-> m (ParsedSeq ParsedOp) -> m (ParsedSeq ParsedOp -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (ParsedSeq ParsedOp)
forall {op}. m (ParsedSeq op)
seq' m (ParsedSeq ParsedOp -> Macro)
-> m (ParsedSeq ParsedOp) -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (ParsedSeq ParsedOp)
forall {op}. m (ParsedSeq op)
seq'
  , ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro
IF_RIGHT (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> Macro)
-> m (ParsedSeq ParsedOp) -> m (ParsedSeq ParsedOp -> Macro)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (ParsedSeq ParsedOp)
forall {op}. m (ParsedSeq op)
seq' m (ParsedSeq ParsedOp -> Macro)
-> m (ParsedSeq ParsedOp) -> m Macro
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (ParsedSeq ParsedOp)
forall {op}. m (ParsedSeq op)
seq'
  ]
  where
    seq' :: m (ParsedSeq op)
seq' = ParsedSeq op -> m (ParsedSeq op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ParsedSeq op -> m (ParsedSeq op))
-> ParsedSeq op -> m (ParsedSeq op)
forall a b. (a -> b) -> a -> b
$ [op] -> ParsedSeq op
forall op. [op] -> ParsedSeq op
PSSequence []
    cmp :: m ParsedInstr
cmp = [m ParsedInstr] -> m ParsedInstr
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
      [ VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
EQ (VarAnn -> ParsedInstr) -> m VarAnn -> m ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann
      , VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
NEQ (VarAnn -> ParsedInstr) -> m VarAnn -> m ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann
      , VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
LT (VarAnn -> ParsedInstr) -> m VarAnn -> m ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann
      , VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
GT (VarAnn -> ParsedInstr) -> m VarAnn -> m ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann
      , VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
LE (VarAnn -> ParsedInstr) -> m VarAnn -> m ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann
      , VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
GE (VarAnn -> ParsedInstr) -> m VarAnn -> m ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m VarAnn
forall {k} {a :: k}. m (Annotation a)
ann
      ]
    ann :: m (Annotation a)
ann = m (Annotation a)
forall {k} (m :: * -> *) (a :: k).
(MonadGen m, GenBase m ~ Identity) =>
m (Annotation a)
genAnnotation
    word :: m Word
word = Range Word -> m Word
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Range Word -> m Word) -> Range Word -> m Word
forall a b. (a -> b) -> a -> b
$ Word -> Word -> Range Word
forall a. Integral a => a -> a -> Range a
Range.linear Word
1 Word
10
    pair :: m PairStruct
pair = [m PairStruct] -> m PairStruct
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
      [ FieldAnn -> PairStruct
F (FieldAnn -> PairStruct) -> m FieldAnn -> m PairStruct
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m FieldAnn
forall {k} {a :: k}. m (Annotation a)
ann
      , PairStruct -> PairStruct -> PairStruct
P (PairStruct -> PairStruct -> PairStruct)
-> m PairStruct -> m (PairStruct -> PairStruct)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m PairStruct
pair m (PairStruct -> PairStruct) -> m PairStruct -> m PairStruct
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m PairStruct
pair
      ]
    unpair :: m UnpairStruct
unpair = [m UnpairStruct] -> m UnpairStruct
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
      [ UnpairStruct -> m UnpairStruct
forall (f :: * -> *) a. Applicative f => a -> f a
pure UnpairStruct
UF
      , UnpairStruct -> UnpairStruct -> UnpairStruct
UP (UnpairStruct -> UnpairStruct -> UnpairStruct)
-> m UnpairStruct -> m (UnpairStruct -> UnpairStruct)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m UnpairStruct
unpair m (UnpairStruct -> UnpairStruct)
-> m UnpairStruct -> m UnpairStruct
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m UnpairStruct
unpair
      ]
    cadr :: m [CadrStruct]
cadr = m CadrStruct -> m [CadrStruct]
forall (m :: * -> *) a. MonadGen m => m a -> m [a]
genSmallList m CadrStruct
cadr1
    cadr1 :: m CadrStruct
cadr1 = [m CadrStruct] -> m CadrStruct
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice [CadrStruct -> m CadrStruct
forall (f :: * -> *) a. Applicative f => a -> f a
pure CadrStruct
A, CadrStruct -> m CadrStruct
forall (f :: * -> *) a. Applicative f => a -> f a
pure CadrStruct
D]