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

-- | Parsing of Michelson instructions.

module Morley.Michelson.Parser.Instr
  ( primInstr
  -- * These are handled separately to have better error messages
  , mapOp
  , pairOp
  , unpairOp
  , pairNOp
  , cmpOp
  , dupOp
  , dipOp
  , carOp
  , cdrOp
  , viewOp
  ) where

import Prelude hiding (EQ, GT, LT, many, note, some, try)

import Text.Megaparsec (choice, label, many, notFollowedBy, try)
import Text.Megaparsec.Char.Lexer qualified as L

import Morley.Michelson.Macro (ParsedInstr, ParsedOp(..), ParsedSeq(..))
import Morley.Michelson.Parser.Annotations
import Morley.Michelson.Parser.Common
import Morley.Michelson.Parser.Lexer
import Morley.Michelson.Parser.Type
import Morley.Michelson.Parser.Types (Parser)
import Morley.Michelson.Parser.Value
import Morley.Michelson.Untyped

-- | Parser for primitive Michelson instruction (no macros and extensions).
primInstr :: Parser (Contract' ParsedOp) -> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
primInstr :: Parser (Contract' ParsedOp)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
primInstr Parser (Contract' ParsedOp)
contractParser Parser (ParsedSeq ParsedOp)
opsParser = String -> Parser ParsedInstr -> Parser ParsedInstr
forall a.
String
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"primitive instruction" (Parser ParsedInstr -> Parser ParsedInstr)
-> Parser ParsedInstr -> Parser ParsedInstr
forall a b. (a -> b) -> a -> b
$ [Parser ParsedInstr] -> Parser ParsedInstr
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice
  [ Parser ParsedInstr
dropOp, Parser ParsedInstr
swapOp, Parser ParsedInstr
digOp, Parser ParsedInstr
dugOp, Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
pushOp Parser (ParsedSeq ParsedOp)
opsParser, Parser ParsedInstr
someOp, Parser ParsedInstr
noneOp, Parser ParsedInstr
unitOp
  , Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
ifNoneOp Parser (ParsedSeq ParsedOp)
opsParser, Parser ParsedInstr
leftOp, Parser ParsedInstr
rightOp, Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
ifLeftOp Parser (ParsedSeq ParsedOp)
opsParser, Parser ParsedInstr
nilOp
  , Parser ParsedInstr
consOp, Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
ifConsOp Parser (ParsedSeq ParsedOp)
opsParser, Parser ParsedInstr
sizeOp, Parser ParsedInstr
emptySetOp, Parser ParsedInstr
emptyMapOp, Parser ParsedInstr
emptyBigMapOp, Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
iterOp Parser (ParsedSeq ParsedOp)
opsParser
  , Parser ParsedInstr
memOp, Parser ParsedInstr
getAndUpdateOp, Parser ParsedInstr
getOp, Parser ParsedInstr
updateOp, Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
loopLOp Parser (ParsedSeq ParsedOp)
opsParser, Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
loopOp Parser (ParsedSeq ParsedOp)
opsParser
  , Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
lambdaOp Parser (ParsedSeq ParsedOp)
opsParser, Parser ParsedInstr
execOp, Parser ParsedInstr
applyOp, Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
dipOp Parser (ParsedSeq ParsedOp)
opsParser, Parser ParsedInstr
failWithOp, Parser ParsedInstr
castOp, Parser ParsedInstr
renameOp, Parser ParsedInstr
levelOp
  , Parser ParsedInstr
concatOp, Parser ParsedInstr
packOp, Parser ParsedInstr
unpackOp, Parser ParsedInstr
sliceOp, Parser ParsedInstr
isNatOp, Parser ParsedInstr
addressOp, Parser ParsedInstr
selfAddressOp, Parser ParsedInstr
addOp, Parser ParsedInstr
subOp
  , Parser ParsedInstr
subMutezOp, Parser ParsedInstr
mulOp, Parser ParsedInstr
edivOp, Parser ParsedInstr
absOp, Parser ParsedInstr
negOp, Parser ParsedInstr
lslOp, Parser ParsedInstr
lsrOp, Parser ParsedInstr
orOp, Parser ParsedInstr
andOp, Parser ParsedInstr
xorOp, Parser ParsedInstr
notOp
  , Parser ParsedInstr
compareOp, Parser VarAnn -> Parser ParsedInstr
cmpOp Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef, Parser ParsedInstr
intOp, Parser ParsedInstr
viewOp, Parser ParsedInstr
selfOp, Parser ParsedInstr
contractOp
  , Parser ParsedInstr
transferTokensOp, Parser ParsedInstr
setDelegateOp
  , Parser (Contract' ParsedOp) -> Parser ParsedInstr
createContractOp Parser (Contract' ParsedOp)
contractParser, Parser ParsedInstr
implicitAccountOp, Parser ParsedInstr
nowOp, Parser ParsedInstr
amountOp
  , Parser ParsedInstr
balanceOp, Parser ParsedInstr
checkSigOp, Parser ParsedInstr
sha256Op, Parser ParsedInstr
sha512Op, Parser ParsedInstr
blake2BOp, Parser ParsedInstr
hashKeyOp, Parser ParsedInstr
pairingCheckOp
  , Parser ParsedInstr
sourceOp, Parser ParsedInstr
senderOp, Parser ParsedInstr
chainIdOp, Parser ParsedInstr
sha3Op, Parser ParsedInstr
keccakOp, Parser ParsedInstr
neverOp
  , Parser ParsedInstr
votingPowerOp, Parser ParsedInstr
totalVotingPowerOp, Parser ParsedInstr -> Parser ParsedInstr
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser ParsedInstr
unpairNOp
  , Parser ParsedInstr
unpairOp
  , Parser ParsedInstr
ticketOp, Parser ParsedInstr
ticketDeprecatedOp, Parser ParsedInstr
readTicketOp, Parser ParsedInstr
splitTicketOp, Parser ParsedInstr
joinTicketsOp
  , Parser ParsedInstr
openChestOp
  , Parser ParsedInstr
saplingEmptyStateOp, Parser ParsedInstr
saplingVerifyUpdateOp, Parser ParsedInstr
minBlockTimeOp
  , Parser ParsedInstr
emitOp
  , Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
lambdaRecOp Parser (ParsedSeq ParsedOp)
opsParser
  , Parser ParsedInstr
natOp, Parser ParsedInstr
bytesOp
  ]

-- Control Structures

failWithOp :: Parser ParsedInstr
failWithOp :: Parser ParsedInstr
failWithOp = Tokens Text -> ParsedInstr -> Parser ParsedInstr
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"FAILWITH" ParsedInstr
forall (f :: * -> *) op. InstrAbstract f op
FAILWITH

loopOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
loopOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
loopOp Parser (ParsedSeq ParsedOp)
opsParser = Tokens Text
-> (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"LOOP" ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op. f op -> InstrAbstract f op
LOOP Parser (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser

loopLOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
loopLOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
loopLOp Parser (ParsedSeq ParsedOp)
opsParser = Tokens Text
-> (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"LOOP_LEFT" ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op. f op -> InstrAbstract f op
LOOP_LEFT Parser (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser

execOp :: Parser ParsedInstr
execOp :: Parser ParsedInstr
execOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"EXEC" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
EXEC Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

applyOp :: Parser ParsedInstr
applyOp :: Parser ParsedInstr
applyOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"APPLY" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
APPLY Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Parses both `DIP` and `DIP n`.
dipOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
dipOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
dipOp Parser (ParsedSeq ParsedOp)
opsParser = Text
-> (Word -> ParsedSeq ParsedOp -> ParsedInstr)
-> (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp -> ParsedInstr)
forall instr. Text -> (Word -> instr) -> instr -> Parser instr
parseWithOptionalParameter Text
"DIP" Word -> ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op. Word -> f op -> InstrAbstract f op
DIPN ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op. f op -> InstrAbstract f op
DIP Parser (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser

-- Helper for instructions which have optional numeric non-negative parameter.
parseWithOptionalParameter :: Text -> (Word -> instr) -> instr -> Parser instr
parseWithOptionalParameter :: forall instr. Text -> (Word -> instr) -> instr -> Parser instr
parseWithOptionalParameter Text
instrName Word -> instr
constructorWithParam instr
constructorNoParam =
  Tokens Text -> Parser ()
symbol1 Text
Tokens Text
instrName Parser ()
-> ParsecT CustomParserException Text Identity instr
-> ParsecT CustomParserException Text Identity instr
forall a b.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
  (ParsecT CustomParserException Text Identity instr
-> ParsecT CustomParserException Text Identity instr
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Word -> instr
constructorWithParam (Word -> instr)
-> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity instr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal) ParsecT CustomParserException Text Identity instr
-> ParsecT CustomParserException Text Identity instr
-> ParsecT CustomParserException Text Identity instr
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> instr -> ParsecT CustomParserException Text Identity instr
forall a. a -> ParsecT CustomParserException Text Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure instr
constructorNoParam)

-- Stack Operations

-- Parses both `DROP` and `DROP n`.
dropOp :: Parser ParsedInstr
dropOp :: Parser ParsedInstr
dropOp = Text -> (Word -> ParsedInstr) -> ParsedInstr -> Parser ParsedInstr
forall instr. Text -> (Word -> instr) -> instr -> Parser instr
parseWithOptionalParameter Text
"DROP" Word -> ParsedInstr
forall (f :: * -> *) op. Word -> InstrAbstract f op
DROPN ParsedInstr
forall (f :: * -> *) op. InstrAbstract f op
DROP

dupOp :: Parser ParsedInstr
dupOp :: Parser ParsedInstr
dupOp = do
  Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"DUP"
  VarAnn
varAnn <- Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef
  ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity (Maybe Word)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal) ParsecT CustomParserException Text Identity (Maybe Word)
-> (Maybe Word -> ParsedInstr) -> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> ParsedInstr -> (Word -> ParsedInstr) -> Maybe Word -> ParsedInstr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
DUP VarAnn
varAnn) (VarAnn -> Word -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> Word -> InstrAbstract f op
DUPN VarAnn
varAnn)

swapOp :: Parser ParsedInstr
swapOp :: Parser ParsedInstr
swapOp = Tokens Text -> ParsedInstr -> Parser ParsedInstr
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SWAP" ParsedInstr
forall (f :: * -> *) op. InstrAbstract f op
SWAP

digOp :: Parser ParsedInstr
digOp :: Parser ParsedInstr
digOp = Tokens Text
-> (Word -> ParsedInstr) -> Parser (Word -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"DIG" Word -> ParsedInstr
forall (f :: * -> *) op. Word -> InstrAbstract f op
DIG Parser (Word -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Word
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

dugOp :: Parser ParsedInstr
dugOp :: Parser ParsedInstr
dugOp = Tokens Text
-> (Word -> ParsedInstr) -> Parser (Word -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"DUG" Word -> ParsedInstr
forall (f :: * -> *) op. Word -> InstrAbstract f op
DUG Parser (Word -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Word
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

pushOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
pushOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
pushOp Parser (ParsedSeq ParsedOp)
opsParser = do
  Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"PUSH"
  VarAnn
v <- Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef
  VarAnn -> Parser ParsedInstr
push' VarAnn
v
  where
    push' :: VarAnn -> Parser ParsedInstr
    push' :: VarAnn -> Parser ParsedInstr
push' VarAnn
v = VarAnn -> Ty -> Value' ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op.
VarAnn -> Ty -> Value' f op -> InstrAbstract f op
PUSH VarAnn
v (Ty -> Value' ParsedSeq ParsedOp -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> ParsecT
     CustomParserException
     Text
     Identity
     (Value' ParsedSeq ParsedOp -> ParsedInstr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_ ParsecT
  CustomParserException
  Text
  Identity
  (Value' ParsedSeq ParsedOp -> ParsedInstr)
-> ParsecT
     CustomParserException Text Identity (Value' ParsedSeq ParsedOp)
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
-> ParsecT
     CustomParserException Text Identity (Value' ParsedSeq ParsedOp)
value' Parser (ParsedSeq ParsedOp)
opsParser

unitOp :: Parser ParsedInstr
unitOp :: Parser ParsedInstr
unitOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"UNIT"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; return $ TypeAnn -> VarAnn -> ParsedInstr
forall (f :: * -> *) op. TypeAnn -> VarAnn -> InstrAbstract f op
UNIT TypeAnn
t VarAnn
v

lambdaOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
lambdaOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
lambdaOp Parser (ParsedSeq ParsedOp)
opsParser =
  Tokens Text
-> (VarAnn -> Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (VarAnn -> Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"LAMBDA" VarAnn -> Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op.
VarAnn -> Ty -> Ty -> f op -> InstrAbstract f op
LAMBDA Parser (VarAnn -> Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser VarAnn
-> ParsecT
     CustomParserException
     Text
     Identity
     (Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException
  Text
  Identity
  (Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> ParsecT
     CustomParserException
     Text
     Identity
     (Ty -> ParsedSeq ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_ ParsecT
  CustomParserException
  Text
  Identity
  (Ty -> ParsedSeq ParsedOp -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser (ParsedSeq ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_ Parser (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser

lambdaRecOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
lambdaRecOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
lambdaRecOp Parser (ParsedSeq ParsedOp)
opsParser =
  Tokens Text
-> (VarAnn -> Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (VarAnn -> Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"LAMBDA_REC" VarAnn -> Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op.
VarAnn -> Ty -> Ty -> f op -> InstrAbstract f op
LAMBDA_REC Parser (VarAnn -> Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser VarAnn
-> ParsecT
     CustomParserException
     Text
     Identity
     (Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException
  Text
  Identity
  (Ty -> Ty -> ParsedSeq ParsedOp -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> ParsecT
     CustomParserException
     Text
     Identity
     (Ty -> ParsedSeq ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_ ParsecT
  CustomParserException
  Text
  Identity
  (Ty -> ParsedSeq ParsedOp -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser (ParsedSeq ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_ Parser (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser

neverOp :: Parser ParsedInstr
neverOp :: Parser ParsedInstr
neverOp = Tokens Text -> ParsedInstr -> Parser ParsedInstr
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"NEVER" ParsedInstr
forall (f :: * -> *) op. InstrAbstract f op
NEVER
-- Generic comparison

cmpOp :: Parser VarAnn -> Parser ParsedInstr
cmpOp :: Parser VarAnn -> Parser ParsedInstr
cmpOp Parser VarAnn
ann = (Parser (VarAnn -> ParsedInstr)
eqOp Parser (VarAnn -> ParsedInstr)
-> Parser (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (VarAnn -> ParsedInstr)
neqOp Parser (VarAnn -> ParsedInstr)
-> Parser (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (VarAnn -> ParsedInstr)
ltOp Parser (VarAnn -> ParsedInstr)
-> Parser (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (VarAnn -> ParsedInstr)
gtOp Parser (VarAnn -> ParsedInstr)
-> Parser (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (VarAnn -> ParsedInstr)
leOp Parser (VarAnn -> ParsedInstr)
-> Parser (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (VarAnn -> ParsedInstr)
gtOp Parser (VarAnn -> ParsedInstr)
-> Parser (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (VarAnn -> ParsedInstr)
geOp) Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
ann

eqOp :: Parser (VarAnn -> ParsedInstr)
eqOp :: Parser (VarAnn -> ParsedInstr)
eqOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"EQ" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
EQ

neqOp :: Parser (VarAnn -> ParsedInstr)
neqOp :: Parser (VarAnn -> ParsedInstr)
neqOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"NEQ" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
NEQ

ltOp :: Parser (VarAnn -> ParsedInstr)
ltOp :: Parser (VarAnn -> ParsedInstr)
ltOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"LT" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
LT

gtOp :: Parser (VarAnn -> ParsedInstr)
gtOp :: Parser (VarAnn -> ParsedInstr)
gtOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"GT" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
GT

leOp :: Parser (VarAnn -> ParsedInstr)
leOp :: Parser (VarAnn -> ParsedInstr)
leOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"LE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
LE

geOp :: Parser (VarAnn -> ParsedInstr)
geOp :: Parser (VarAnn -> ParsedInstr)
geOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"GE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
GE

-- ad-hoc comparison

compareOp :: Parser ParsedInstr
compareOp :: Parser ParsedInstr
compareOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"COMPARE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
COMPARE Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Operations on booleans

orOp :: Parser ParsedInstr
orOp :: Parser ParsedInstr
orOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"OR"  VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
OR Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

andOp :: Parser ParsedInstr
andOp :: Parser ParsedInstr
andOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"AND" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
AND Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

xorOp :: Parser ParsedInstr
xorOp :: Parser ParsedInstr
xorOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"XOR" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
XOR Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

notOp :: Parser ParsedInstr
notOp :: Parser ParsedInstr
notOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"NOT" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
NOT Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Operations on integers and natural numbers

addOp :: Parser ParsedInstr
addOp :: Parser ParsedInstr
addOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"ADD" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
ADD Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

saplingEmptyStateOp :: Parser ParsedInstr
saplingEmptyStateOp :: Parser ParsedInstr
saplingEmptyStateOp = Tokens Text
-> (VarAnn -> Natural -> ParsedInstr)
-> Parser (VarAnn -> Natural -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SAPLING_EMPTY_STATE" VarAnn -> Natural -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> Natural -> InstrAbstract f op
SAPLING_EMPTY_STATE Parser (VarAnn -> Natural -> ParsedInstr)
-> Parser VarAnn
-> ParsecT
     CustomParserException Text Identity (Natural -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException Text Identity (Natural -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Natural
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Natural
-> ParsecT CustomParserException Text Identity Natural
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Natural
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

saplingVerifyUpdateOp :: Parser ParsedInstr
saplingVerifyUpdateOp :: Parser ParsedInstr
saplingVerifyUpdateOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SAPLING_VERIFY_UPDATE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SAPLING_VERIFY_UPDATE Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

minBlockTimeOp :: Parser ParsedInstr
minBlockTimeOp :: Parser ParsedInstr
minBlockTimeOp = Tokens Text
-> ([AnyAnn] -> ParsedInstr) -> Parser ([AnyAnn] -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"MIN_BLOCK_TIME" [AnyAnn] -> ParsedInstr
forall (f :: * -> *) op. [AnyAnn] -> InstrAbstract f op
MIN_BLOCK_TIME Parser ([AnyAnn] -> ParsedInstr)
-> ParsecT CustomParserException Text Identity [AnyAnn]
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity AnyAnn
-> ParsecT CustomParserException Text Identity [AnyAnn]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many ParsecT CustomParserException Text Identity AnyAnn
anyNote

subOp :: Parser ParsedInstr
subOp :: Parser ParsedInstr
subOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SUB" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SUB Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

subMutezOp :: Parser ParsedInstr
subMutezOp :: Parser ParsedInstr
subMutezOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SUB_MUTEZ" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SUB_MUTEZ Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

mulOp :: Parser ParsedInstr
mulOp :: Parser ParsedInstr
mulOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"MUL" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
MUL Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

edivOp :: Parser ParsedInstr
edivOp :: Parser ParsedInstr
edivOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"EDIV" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
EDIV Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

absOp :: Parser ParsedInstr
absOp :: Parser ParsedInstr
absOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"ABS" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
ABS Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

negOp :: Parser ParsedInstr
negOp :: Parser ParsedInstr
negOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"NEG" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
NEG Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Bitwise logical operators

lslOp :: Parser ParsedInstr
lslOp :: Parser ParsedInstr
lslOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"LSL" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
LSL Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

lsrOp :: Parser ParsedInstr
lsrOp :: Parser ParsedInstr
lsrOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"LSR" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
LSR Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Operations on string's

concatOp :: Parser ParsedInstr
concatOp :: Parser ParsedInstr
concatOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"CONCAT" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
CONCAT Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

sliceOp :: Parser ParsedInstr
sliceOp :: Parser ParsedInstr
sliceOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SLICE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SLICE Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Operations on pairs
pairOp :: Parser ParsedInstr
pairOp :: Parser ParsedInstr
pairOp = do
  Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"PAIR"
  (TypeAnn
t, VarAnn
v, (FieldAnn
p, FieldAnn
q)) <- Parser (TypeAnn, VarAnn, (FieldAnn, FieldAnn))
notesTVF2Def

  -- Make sure this is a `PAIR` instruction,
  -- and not a `PAIR n` instruction.
  ParsecT CustomParserException Text Identity Word -> Parser ()
forall a.
ParsecT CustomParserException Text Identity a -> Parser ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal :: Parser Word)

  return $ TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> ParsedInstr
forall (f :: * -> *) op.
TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> InstrAbstract f op
PAIR TypeAnn
t VarAnn
v FieldAnn
p FieldAnn
q

unpairOp :: Parser ParsedInstr
unpairOp :: Parser ParsedInstr
unpairOp = do
  Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"UNPAIR"
  ((VarAnn
vn1, VarAnn
vn2), (FieldAnn
fn1, FieldAnn
fn2)) <- Parser ((VarAnn, VarAnn), (FieldAnn, FieldAnn))
notesVVFF

  -- Make sure this is an `UNPAIR` instruction,
  -- and not an `UNPAIR n` instruction.
  ParsecT CustomParserException Text Identity Word -> Parser ()
forall a.
ParsecT CustomParserException Text Identity a -> Parser ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal :: Parser Word)

  return $ VarAnn -> VarAnn -> FieldAnn -> FieldAnn -> ParsedInstr
forall (f :: * -> *) op.
VarAnn -> VarAnn -> FieldAnn -> FieldAnn -> InstrAbstract f op
UNPAIR VarAnn
vn1 VarAnn
vn2 FieldAnn
fn1 FieldAnn
fn2

pairNOp :: Parser ParsedInstr
pairNOp :: Parser ParsedInstr
pairNOp = do
  Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"PAIR"
  VarAnn -> Word -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> Word -> InstrAbstract f op
PAIRN
    (VarAnn -> Word -> ParsedInstr)
-> Parser VarAnn -> Parser (Word -> ParsedInstr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef
    Parser (Word -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Word
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

unpairNOp :: Parser ParsedInstr
unpairNOp :: Parser ParsedInstr
unpairNOp =
  Tokens Text
-> (Word -> ParsedInstr) -> Parser (Word -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"UNPAIR" Word -> ParsedInstr
forall (f :: * -> *) op. Word -> InstrAbstract f op
UNPAIRN Parser (Word -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Word
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

carOp :: Parser ParsedInstr
carOp :: Parser ParsedInstr
carOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"CAR"; (VarAnn
v, FieldAnn
f) <- Parser (VarAnn, FieldAnn)
notesVF; return $ VarAnn -> FieldAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> FieldAnn -> InstrAbstract f op
CAR VarAnn
v FieldAnn
f

cdrOp :: Parser ParsedInstr
cdrOp :: Parser ParsedInstr
cdrOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"CDR"; (VarAnn
v, FieldAnn
f) <- Parser (VarAnn, FieldAnn)
notesVF; return $ VarAnn -> FieldAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> FieldAnn -> InstrAbstract f op
CDR VarAnn
v FieldAnn
f

-- Operations on collections (sets, maps, lists)

emptySetOp :: Parser ParsedInstr
emptySetOp :: Parser ParsedInstr
emptySetOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"EMPTY_SET"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV;
                TypeAnn -> VarAnn -> Ty -> ParsedInstr
forall (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> InstrAbstract f op
EMPTY_SET TypeAnn
t VarAnn
v (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

emptyMapOp :: Parser ParsedInstr
emptyMapOp :: Parser ParsedInstr
emptyMapOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"EMPTY_MAP"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; Ty
a <- ParsecT CustomParserException Text Identity Ty
type_;
                TypeAnn -> VarAnn -> Ty -> Ty -> ParsedInstr
forall (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract f op
EMPTY_MAP TypeAnn
t VarAnn
v Ty
a (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

emptyBigMapOp :: Parser ParsedInstr
emptyBigMapOp :: Parser ParsedInstr
emptyBigMapOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"EMPTY_BIG_MAP"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; Ty
a <- ParsecT CustomParserException Text Identity Ty
type_;
                   TypeAnn -> VarAnn -> Ty -> Ty -> ParsedInstr
forall (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract f op
EMPTY_BIG_MAP TypeAnn
t VarAnn
v Ty
a (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

memOp :: Parser ParsedInstr
memOp :: Parser ParsedInstr
memOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"MEM" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
MEM Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

updateOp :: Parser ParsedInstr
updateOp :: Parser ParsedInstr
updateOp = do
  Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"UPDATE"
  VarAnn
varAnn <- Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef
  Maybe Word
ix <- ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity (Maybe Word)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal)
  pure $ ParsedInstr -> (Word -> ParsedInstr) -> Maybe Word -> ParsedInstr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
UPDATE VarAnn
varAnn) (VarAnn -> Word -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> Word -> InstrAbstract f op
UPDATEN VarAnn
varAnn) Maybe Word
ix

getAndUpdateOp :: Parser ParsedInstr
getAndUpdateOp :: Parser ParsedInstr
getAndUpdateOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"GET_AND_UPDATE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
GET_AND_UPDATE Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

iterOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
iterOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
iterOp Parser (ParsedSeq ParsedOp)
opsParser = Tokens Text
-> (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"ITER" ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op. f op -> InstrAbstract f op
ITER Parser (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser

sizeOp :: Parser ParsedInstr
sizeOp :: Parser ParsedInstr
sizeOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SIZE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SIZE Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

mapOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
mapOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
mapOp Parser (ParsedSeq ParsedOp)
opsParser = Tokens Text
-> (VarAnn -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (VarAnn -> ParsedSeq ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"MAP" VarAnn -> ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> f op -> InstrAbstract f op
MAP Parser (VarAnn -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser VarAnn -> Parser (ParsedSeq ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef Parser (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser

getOp :: Parser ParsedInstr
getOp :: Parser ParsedInstr
getOp = do
  Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"GET"
  VarAnn
varAnn <- Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef
  Maybe Word
ix <- ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity (Maybe Word)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal)
  pure $ ParsedInstr -> (Word -> ParsedInstr) -> Maybe Word -> ParsedInstr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
GET VarAnn
varAnn) (VarAnn -> Word -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> Word -> InstrAbstract f op
GETN VarAnn
varAnn) Maybe Word
ix

nilOp :: Parser ParsedInstr
nilOp :: Parser ParsedInstr
nilOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"NIL"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; TypeAnn -> VarAnn -> Ty -> ParsedInstr
forall (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> InstrAbstract f op
NIL TypeAnn
t VarAnn
v (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

consOp :: Parser ParsedInstr
consOp :: Parser ParsedInstr
consOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"CONS" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
CONS Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

ifConsOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
ifConsOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
ifConsOp Parser (ParsedSeq ParsedOp)
opsParser = Tokens Text
-> (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"IF_CONS" ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op. f op -> f op -> InstrAbstract f op
IF_CONS Parser (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp)
-> Parser (ParsedSeq ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser Parser (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser

-- Operations on options

someOp :: Parser ParsedInstr
someOp :: Parser ParsedInstr
someOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"SOME"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; return $ TypeAnn -> VarAnn -> ParsedInstr
forall (f :: * -> *) op. TypeAnn -> VarAnn -> InstrAbstract f op
SOME TypeAnn
t VarAnn
v

noneOp :: Parser ParsedInstr
noneOp :: Parser ParsedInstr
noneOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"NONE"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; TypeAnn -> VarAnn -> Ty -> ParsedInstr
forall (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> InstrAbstract f op
NONE TypeAnn
t VarAnn
v (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

ifNoneOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
ifNoneOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
ifNoneOp Parser (ParsedSeq ParsedOp)
opsParser = Tokens Text
-> (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"IF_NONE" ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op. f op -> f op -> InstrAbstract f op
IF_NONE Parser (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp)
-> Parser (ParsedSeq ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser Parser (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser

-- Operations on unions

leftOp :: Parser ParsedInstr
leftOp :: Parser ParsedInstr
leftOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"LEFT"; (TypeAnn
t, VarAnn
v, (FieldAnn
f, FieldAnn
f')) <- Parser (TypeAnn, VarAnn, (FieldAnn, FieldAnn))
notesTVF2Def;
               TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> ParsedInstr
forall (f :: * -> *) op.
TypeAnn
-> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract f op
LEFT TypeAnn
t VarAnn
v FieldAnn
f FieldAnn
f' (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

rightOp :: Parser ParsedInstr
rightOp :: Parser ParsedInstr
rightOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"RIGHT"; (TypeAnn
t, VarAnn
v, (FieldAnn
f, FieldAnn
f')) <- Parser (TypeAnn, VarAnn, (FieldAnn, FieldAnn))
notesTVF2Def;
               TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> ParsedInstr
forall (f :: * -> *) op.
TypeAnn
-> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract f op
RIGHT TypeAnn
t VarAnn
v FieldAnn
f FieldAnn
f' (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

ifLeftOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
ifLeftOp :: Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
ifLeftOp Parser (ParsedSeq ParsedOp)
opsParser = Tokens Text
-> (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"IF_LEFT" ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr
forall (f :: * -> *) op. f op -> f op -> InstrAbstract f op
IF_LEFT Parser (ParsedSeq ParsedOp -> ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp)
-> Parser (ParsedSeq ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser Parser (ParsedSeq ParsedOp -> ParsedInstr)
-> Parser (ParsedSeq ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (ParsedSeq ParsedOp)
opsParser

-- Operations on contracts

createContractOp :: Parser (Contract' ParsedOp) -> Parser ParsedInstr
createContractOp :: Parser (Contract' ParsedOp) -> Parser ParsedInstr
createContractOp Parser (Contract' ParsedOp)
contractParser =
  Tokens Text
-> (VarAnn -> VarAnn -> Contract' ParsedOp -> ParsedInstr)
-> Parser (VarAnn -> VarAnn -> Contract' ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"CREATE_CONTRACT" VarAnn -> VarAnn -> Contract' ParsedOp -> ParsedInstr
forall (f :: * -> *) op.
VarAnn -> VarAnn -> Contract' op -> InstrAbstract f op
CREATE_CONTRACT
    Parser (VarAnn -> VarAnn -> Contract' ParsedOp -> ParsedInstr)
-> Parser VarAnn
-> ParsecT
     CustomParserException
     Text
     Identity
     (VarAnn -> Contract' ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException
  Text
  Identity
  (VarAnn -> Contract' ParsedOp -> ParsedInstr)
-> Parser VarAnn
-> ParsecT
     CustomParserException
     Text
     Identity
     (Contract' ParsedOp -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException
  Text
  Identity
  (Contract' ParsedOp -> ParsedInstr)
-> Parser (Contract' ParsedOp) -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Contract' ParsedOp) -> Parser (Contract' ParsedOp)
forall a.
ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity a
braces Parser (Contract' ParsedOp)
contractParser

transferTokensOp :: Parser ParsedInstr
transferTokensOp :: Parser ParsedInstr
transferTokensOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"TRANSFER_TOKENS" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
TRANSFER_TOKENS Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

setDelegateOp :: Parser ParsedInstr
setDelegateOp :: Parser ParsedInstr
setDelegateOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SET_DELEGATE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SET_DELEGATE Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

balanceOp :: Parser ParsedInstr
balanceOp :: Parser ParsedInstr
balanceOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"BALANCE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
BALANCE Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

contractOp :: Parser ParsedInstr
contractOp :: Parser ParsedInstr
contractOp = Tokens Text
-> (VarAnn -> FieldAnn -> Ty -> ParsedInstr)
-> Parser (VarAnn -> FieldAnn -> Ty -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"CONTRACT" VarAnn -> FieldAnn -> Ty -> ParsedInstr
forall (f :: * -> *) op.
VarAnn -> FieldAnn -> Ty -> InstrAbstract f op
CONTRACT Parser (VarAnn -> FieldAnn -> Ty -> ParsedInstr)
-> Parser VarAnn
-> ParsecT
     CustomParserException Text Identity (FieldAnn -> Ty -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException Text Identity (FieldAnn -> Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity FieldAnn
-> ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity FieldAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_

sourceOp :: Parser ParsedInstr
sourceOp :: Parser ParsedInstr
sourceOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SOURCE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SOURCE Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

senderOp :: Parser ParsedInstr
senderOp :: Parser ParsedInstr
senderOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SENDER" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SENDER Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

amountOp :: Parser ParsedInstr
amountOp :: Parser ParsedInstr
amountOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"AMOUNT" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
AMOUNT Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

votingPowerOp :: Parser ParsedInstr
votingPowerOp :: Parser ParsedInstr
votingPowerOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"VOTING_POWER" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
VOTING_POWER Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

totalVotingPowerOp :: Parser ParsedInstr
totalVotingPowerOp :: Parser ParsedInstr
totalVotingPowerOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"TOTAL_VOTING_POWER" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
TOTAL_VOTING_POWER Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

implicitAccountOp :: Parser ParsedInstr
implicitAccountOp :: Parser ParsedInstr
implicitAccountOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"IMPLICIT_ACCOUNT" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
IMPLICIT_ACCOUNT Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

viewOp :: Parser ParsedInstr
viewOp :: Parser ParsedInstr
viewOp =
  -- @VIEW_@ A1 macro should not be parsed by this
  Tokens Text
-> (VarAnn -> ViewName -> Ty -> ParsedInstr)
-> Parser (VarAnn -> ViewName -> Ty -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"VIEW" VarAnn -> ViewName -> Ty -> ParsedInstr
forall (f :: * -> *) op.
VarAnn -> ViewName -> Ty -> InstrAbstract f op
VIEW Parser (VarAnn -> ViewName -> Ty -> ParsedInstr)
-> Parser VarAnn
-> ParsecT
     CustomParserException Text Identity (ViewName -> Ty -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException Text Identity (ViewName -> Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity ViewName
-> ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity ViewName
viewName_ ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_

selfOp :: Parser ParsedInstr
selfOp :: Parser ParsedInstr
selfOp = Tokens Text
-> (VarAnn -> FieldAnn -> ParsedInstr)
-> Parser (VarAnn -> FieldAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SELF" VarAnn -> FieldAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> FieldAnn -> InstrAbstract f op
SELF Parser (VarAnn -> FieldAnn -> ParsedInstr)
-> Parser VarAnn
-> ParsecT
     CustomParserException Text Identity (FieldAnn -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException Text Identity (FieldAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity FieldAnn
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity FieldAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

addressOp :: Parser ParsedInstr
addressOp :: Parser ParsedInstr
addressOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"ADDRESS" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
ADDRESS Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

selfAddressOp :: Parser ParsedInstr
selfAddressOp :: Parser ParsedInstr
selfAddressOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SELF_ADDRESS" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SELF_ADDRESS Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Special Operations

nowOp :: Parser ParsedInstr
nowOp :: Parser ParsedInstr
nowOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"NOW" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
NOW Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

levelOp :: Parser ParsedInstr
levelOp :: Parser ParsedInstr
levelOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"LEVEL" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
LEVEL Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

chainIdOp :: Parser ParsedInstr
chainIdOp :: Parser ParsedInstr
chainIdOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"CHAIN_ID" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
CHAIN_ID Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Operations on bytes

packOp :: Parser ParsedInstr
packOp :: Parser ParsedInstr
packOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"PACK" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
PACK Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

unpackOp :: Parser ParsedInstr
unpackOp :: Parser ParsedInstr
unpackOp = do Tokens Text -> Parser ()
symbol1 Text
Tokens Text
"UNPACK"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; TypeAnn -> VarAnn -> Ty -> ParsedInstr
forall (f :: * -> *) op.
TypeAnn -> VarAnn -> Ty -> InstrAbstract f op
UNPACK TypeAnn
t VarAnn
v (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

-- Cryptographic Primitives

checkSigOp :: Parser ParsedInstr
checkSigOp :: Parser ParsedInstr
checkSigOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"CHECK_SIGNATURE" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
CHECK_SIGNATURE Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

blake2BOp :: Parser ParsedInstr
blake2BOp :: Parser ParsedInstr
blake2BOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"BLAKE2B" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
BLAKE2B Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

sha256Op :: Parser ParsedInstr
sha256Op :: Parser ParsedInstr
sha256Op = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SHA256" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SHA256 Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

sha512Op :: Parser ParsedInstr
sha512Op :: Parser ParsedInstr
sha512Op = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SHA512" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SHA512 Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

sha3Op :: Parser ParsedInstr
sha3Op :: Parser ParsedInstr
sha3Op = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SHA3" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SHA3 Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

keccakOp :: Parser ParsedInstr
keccakOp :: Parser ParsedInstr
keccakOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"KECCAK" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
KECCAK Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

hashKeyOp :: Parser ParsedInstr
hashKeyOp :: Parser ParsedInstr
hashKeyOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"HASH_KEY" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
HASH_KEY Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

pairingCheckOp :: Parser ParsedInstr
pairingCheckOp :: Parser ParsedInstr
pairingCheckOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"PAIRING_CHECK" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
PAIRING_CHECK Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Type operations

castOp :: Parser ParsedInstr
castOp :: Parser ParsedInstr
castOp = Tokens Text
-> (VarAnn -> Ty -> ParsedInstr)
-> Parser (VarAnn -> Ty -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"CAST" VarAnn -> Ty -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> Ty -> InstrAbstract f op
CAST Parser (VarAnn -> Ty -> ParsedInstr)
-> Parser VarAnn
-> ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_

renameOp :: Parser ParsedInstr
renameOp :: Parser ParsedInstr
renameOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"RENAME" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
RENAME Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

isNatOp :: Parser ParsedInstr
isNatOp :: Parser ParsedInstr
isNatOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"ISNAT" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
ISNAT Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

intOp :: Parser ParsedInstr
intOp :: Parser ParsedInstr
intOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"INT" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
INT Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

natOp :: Parser ParsedInstr
natOp :: Parser ParsedInstr
natOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"NAT" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
NAT Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

bytesOp :: Parser ParsedInstr
bytesOp :: Parser ParsedInstr
bytesOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"BYTES" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
BYTES Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Ticket Operations

ticketOp :: Parser ParsedInstr
ticketOp :: Parser ParsedInstr
ticketOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"TICKET" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
TICKET Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

ticketDeprecatedOp :: Parser ParsedInstr
ticketDeprecatedOp :: Parser ParsedInstr
ticketDeprecatedOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"TICKET_DEPRECATED" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
TICKET_DEPRECATED Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

readTicketOp :: Parser ParsedInstr
readTicketOp :: Parser ParsedInstr
readTicketOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"READ_TICKET" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
READ_TICKET Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

splitTicketOp :: Parser ParsedInstr
splitTicketOp :: Parser ParsedInstr
splitTicketOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"SPLIT_TICKET" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
SPLIT_TICKET Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

joinTicketsOp :: Parser ParsedInstr
joinTicketsOp :: Parser ParsedInstr
joinTicketsOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"JOIN_TICKETS" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
JOIN_TICKETS Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

openChestOp :: Parser ParsedInstr
openChestOp :: Parser ParsedInstr
openChestOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"OPEN_CHEST" VarAnn -> ParsedInstr
forall (f :: * -> *) op. VarAnn -> InstrAbstract f op
OPEN_CHEST Parser (VarAnn -> ParsedInstr)
-> Parser VarAnn -> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

emitOp :: Parser ParsedInstr
emitOp :: Parser ParsedInstr
emitOp = Tokens Text
-> ((VarAnn, FieldAnn) -> Maybe Ty -> ParsedInstr)
-> Parser ((VarAnn, FieldAnn) -> Maybe Ty -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Text
Tokens Text
"EMIT" ((VarAnn -> FieldAnn -> Maybe Ty -> ParsedInstr)
-> (VarAnn, FieldAnn) -> Maybe Ty -> ParsedInstr
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry VarAnn -> FieldAnn -> Maybe Ty -> ParsedInstr
forall (f :: * -> *) op.
VarAnn -> FieldAnn -> Maybe Ty -> InstrAbstract f op
EMIT) Parser ((VarAnn, FieldAnn) -> Maybe Ty -> ParsedInstr)
-> Parser (VarAnn, FieldAnn)
-> ParsecT
     CustomParserException Text Identity (Maybe Ty -> ParsedInstr)
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (VarAnn, FieldAnn)
notesVF ParsecT
  CustomParserException Text Identity (Maybe Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity (Maybe Ty)
-> Parser ParsedInstr
forall a b.
ParsecT CustomParserException Text Identity (a -> b)
-> ParsecT CustomParserException Text Identity a
-> ParsecT CustomParserException Text Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
-> ParsecT CustomParserException Text Identity (Maybe Ty)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT CustomParserException Text Identity Ty
type_