Safe Haskell	None
Language	Haskell2010

Michelson.Typed.Instr

Description

Module, containing data types for Michelson value.

Synopsis

data Instr (inp :: [T]) (out :: [T]) where
- WithLoc :: InstrCallStack -> Instr a b -> Instr a b
- InstrWithNotes :: PackedNotes b -> Instr a b -> Instr a b
- InstrWithVarNotes :: NonEmpty VarAnn -> Instr a b -> Instr a b
- FrameInstr :: forall a b s. (KnownList a, KnownList b) => Proxy s -> Instr a b -> Instr (a ++ s) (b ++ s)
- Seq :: Instr a b -> Instr b c -> Instr a c
- Nop :: Instr s s
- Ext :: ExtInstr s -> Instr s s
- Nested :: Instr inp out -> Instr inp out
- DocGroup :: DocGrouping -> Instr inp out -> Instr inp out
- AnnCAR :: FieldAnn -> Instr ('TPair a b ': s) (a ': s)
- AnnCDR :: FieldAnn -> Instr ('TPair a b ': s) (b ': s)
- DROP :: Instr (a ': s) s
- DROPN :: forall (n :: Peano) s. (SingI n, KnownPeano n, RequireLongerOrSameLength s n, NFData (Sing n)) => Sing n -> Instr s (Drop n s)
- DUP :: Instr (a ': s) (a ': (a ': s))
- SWAP :: Instr (a ': (b ': s)) (b ': (a ': s))
- DIG :: forall (n :: Peano) inp out a. (ConstraintDIG n inp out a, NFData (Sing n)) => Sing n -> Instr inp out
- DUG :: forall (n :: Peano) inp out a. (ConstraintDUG n inp out a, NFData (Sing n)) => Sing n -> Instr inp out
- PUSH :: forall t s. ConstantScope t => Value' Instr t -> Instr s (t ': s)
- SOME :: Instr (a ': s) ('TOption a ': s)
- NONE :: forall a s. KnownT a => Instr s ('TOption a ': s)
- UNIT :: Instr s ('TUnit ': s)
- IF_NONE :: Instr s s' -> Instr (a ': s) s' -> Instr ('TOption a ': s) s'
- AnnPAIR :: TypeAnn -> FieldAnn -> FieldAnn -> Instr (a ': (b ': s)) ('TPair a b ': s)
- LEFT :: forall b a s. KnownT b => Instr (a ': s) ('TOr a b ': s)
- RIGHT :: forall a b s. KnownT a => Instr (b ': s) ('TOr a b ': s)
- IF_LEFT :: Instr (a ': s) s' -> Instr (b ': s) s' -> Instr ('TOr a b ': s) s'
- NIL :: KnownT p => Instr s ('TList p ': s)
- CONS :: Instr (a ': ('TList a ': s)) ('TList a ': s)
- IF_CONS :: Instr (a ': ('TList a ': s)) s' -> Instr s s' -> Instr ('TList a ': s) s'
- SIZE :: SizeOp c => Instr (c ': s) ('TNat ': s)
- EMPTY_SET :: (KnownT e, Comparable e) => Instr s ('TSet e ': s)
- EMPTY_MAP :: (KnownT a, KnownT b, Comparable a) => Instr s ('TMap a b ': s)
- EMPTY_BIG_MAP :: (KnownT a, KnownT b, Comparable a) => Instr s ('TBigMap a b ': s)
- MAP :: (MapOp c, KnownT b) => Instr (MapOpInp c ': s) (b ': s) -> Instr (c ': s) (MapOpRes c b ': s)
- ITER :: IterOp c => Instr (IterOpEl c ': s) s -> Instr (c ': s) s
- MEM :: MemOp c => Instr (MemOpKey c ': (c ': s)) ('TBool ': s)
- GET :: (GetOp c, KnownT (GetOpVal c)) => Instr (GetOpKey c ': (c ': s)) ('TOption (GetOpVal c) ': s)
- UPDATE :: UpdOp c => Instr (UpdOpKey c ': (UpdOpParams c ': (c ': s))) (c ': s)
- IF :: Instr s s' -> Instr s s' -> Instr ('TBool ': s) s'
- LOOP :: Instr s ('TBool ': s) -> Instr ('TBool ': s) s
- LOOP_LEFT :: Instr (a ': s) ('TOr a b ': s) -> Instr ('TOr a b ': s) (b ': s)
- LAMBDA :: forall i o s. (KnownT i, KnownT o) => Value' Instr ('TLambda i o) -> Instr s ('TLambda i o ': s)
- EXEC :: Instr (t1 ': ('TLambda t1 t2 ': s)) (t2 ': s)
- APPLY :: forall a b c s. (ConstantScope a, KnownT b) => Instr (a ': ('TLambda ('TPair a b) c ': s)) ('TLambda b c ': s)
- DIP :: Instr a c -> Instr (b ': a) (b ': c)
- DIPN :: forall (n :: Peano) inp out s s'. (ConstraintDIPN n inp out s s', NFData (Sing n)) => Sing n -> Instr s s' -> Instr inp out
- FAILWITH :: KnownT a => Instr (a ': s) t
- CAST :: forall a s. SingI a => Instr (a ': s) (a ': s)
- RENAME :: Instr (a ': s) (a ': s)
- PACK :: PackedValScope a => Instr (a ': s) ('TBytes ': s)
- UNPACK :: (UnpackedValScope a, KnownT a) => Instr ('TBytes ': s) ('TOption a ': s)
- CONCAT :: ConcatOp c => Instr (c ': (c ': s)) (c ': s)
- CONCAT' :: ConcatOp c => Instr ('TList c ': s) (c ': s)
- SLICE :: (SliceOp c, KnownT c) => Instr ('TNat ': ('TNat ': (c ': s))) ('TOption c ': s)
- ISNAT :: Instr ('TInt ': s) ('TOption 'TNat ': s)
- ADD :: (ArithOp Add n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Add n m ': s)
- SUB :: (ArithOp Sub n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Sub n m ': s)
- MUL :: (ArithOp Mul n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Mul n m ': s)
- EDIV :: EDivOp n m => Instr (n ': (m ': s)) ('TOption ('TPair (EDivOpRes n m) (EModOpRes n m)) ': s)
- ABS :: UnaryArithOp Abs n => Instr (n ': s) (UnaryArithRes Abs n ': s)
- NEG :: UnaryArithOp Neg n => Instr (n ': s) (UnaryArithRes Neg n ': s)
- LSL :: (ArithOp Lsl n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Lsl n m ': s)
- LSR :: (ArithOp Lsr n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Lsr n m ': s)
- OR :: (ArithOp Or n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Or n m ': s)
- AND :: (ArithOp And n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes And n m ': s)
- XOR :: (ArithOp Xor n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Xor n m ': s)
- NOT :: UnaryArithOp Not n => Instr (n ': s) (UnaryArithRes Not n ': s)
- COMPARE :: (Comparable n, KnownT n) => Instr (n ': (n ': s)) ('TInt ': s)
- EQ :: UnaryArithOp Eq' n => Instr (n ': s) (UnaryArithRes Eq' n ': s)
- NEQ :: UnaryArithOp Neq n => Instr (n ': s) (UnaryArithRes Neq n ': s)
- LT :: UnaryArithOp Lt n => Instr (n ': s) (UnaryArithRes Lt n ': s)
- GT :: UnaryArithOp Gt n => Instr (n ': s) (UnaryArithRes Gt n ': s)
- LE :: UnaryArithOp Le n => Instr (n ': s) (UnaryArithRes Le n ': s)
- GE :: UnaryArithOp Ge n => Instr (n ': s) (UnaryArithRes Ge n ': s)
- INT :: Instr ('TNat ': s) ('TInt ': s)
- SELF :: forall (arg :: T) s. ParameterScope arg => SomeEntrypointCallT arg -> Instr s ('TContract arg ': s)
- CONTRACT :: ParameterScope p => Notes p -> EpName -> Instr ('TAddress ': s) ('TOption ('TContract p) ': s)
- TRANSFER_TOKENS :: ParameterScope p => Instr (p ': ('TMutez ': ('TContract p ': s))) ('TOperation ': s)
- SET_DELEGATE :: Instr ('TOption 'TKeyHash ': s) ('TOperation ': s)
- CREATE_CONTRACT :: (ParameterScope p, StorageScope g) => Contract p g -> Instr ('TOption 'TKeyHash ': ('TMutez ': (g ': s))) ('TOperation ': ('TAddress ': s))
- IMPLICIT_ACCOUNT :: Instr ('TKeyHash ': s) ('TContract 'TUnit ': s)
- NOW :: Instr s ('TTimestamp ': s)
- AMOUNT :: Instr s ('TMutez ': s)
- BALANCE :: Instr s ('TMutez ': s)
- CHECK_SIGNATURE :: Instr ('TKey ': ('TSignature ': ('TBytes ': s))) ('TBool ': s)
- SHA256 :: Instr ('TBytes ': s) ('TBytes ': s)
- SHA512 :: Instr ('TBytes ': s) ('TBytes ': s)
- BLAKE2B :: Instr ('TBytes ': s) ('TBytes ': s)
- HASH_KEY :: Instr ('TKey ': s) ('TKeyHash ': s)
- SOURCE :: Instr s ('TAddress ': s)
- SENDER :: Instr s ('TAddress ': s)
- ADDRESS :: Instr ('TContract a ': s) ('TAddress ': s)
- CHAIN_ID :: Instr s ('TChainId ': s)
data ExtInstr s
- = TEST_ASSERT (TestAssert s)
- | PRINT (PrintComment s)
- | DOC_ITEM SomeDocItem
- | COMMENT_ITEM CommentType
data CommentType
- = FunctionStarts Text
- | FunctionEnds Text
- | StatementStarts Text
- | StatementEnds Text
- | JustComment Text
data StackRef (st :: [T]) where
- StackRef :: (KnownPeano idx, SingI idx, RequireLongerThan st idx) => Sing (idx :: Peano) -> StackRef st
mkStackRef :: forall (gn :: Nat) st n. (n ~ ToPeano gn, SingI n, KnownPeano n, RequireLongerThan st n) => StackRef st
newtype PrintComment (st :: [T]) = PrintComment {
- unPrintComment :: [Either Text (StackRef st)]
}
data TestAssert (s :: [T]) where
- TestAssert :: Typeable out => Text -> PrintComment inp -> Instr inp ('TBool ': out) -> TestAssert inp
type ContractCode cp st = Instr (ContractInp cp st) (ContractOut st)
data Contract cp st = (ParameterScope cp, StorageScope st) => Contract {
- cCode :: ContractCode cp st
- cParamNotes :: ParamNotes cp
- cStoreNotes :: Notes st
- cEntriesOrder :: EntriesOrder
}
mapContractCode :: (ContractCode cp st -> ContractCode cp st) -> Contract cp st -> Contract cp st
mapEntriesOrdered :: Contract cp st -> (ParamNotes cp -> a) -> (Notes st -> a) -> (ContractCode cp st -> a) -> [a]
pattern CAR :: () => (i ~ ('TPair a b ': s), o ~ (a ': s)) => Instr i o
pattern CDR :: () => (i ~ ('TPair a b ': s), o ~ (b ': s)) => Instr i o
pattern PAIR :: () => (i ~ (a ': (b ': s)), o ~ ('TPair a b ': s)) => Instr i o
pattern UNPAIR :: () => (i ~ ('TPair a b ': s), o ~ (a ': (b ': s))) => Instr i o
data PackedNotes a where
- PackedNotes :: SingI a => Notes a -> PackedNotes (a ': s)
type ConstraintDIPN n inp out s s' = ConstraintDIPN' T n inp out s s'
type ConstraintDIPN' kind (n :: Peano) (inp :: [kind]) (out :: [kind]) (s :: [kind]) (s' :: [kind]) = (SingI n, KnownPeano n, RequireLongerOrSameLength inp n, (Take n inp ++ s) ~ inp, (Take n inp ++ s') ~ out)
type ConstraintDIG n inp out a = ConstraintDIG' T n inp out a
type ConstraintDIG' kind (n :: Peano) (inp :: [kind]) (out :: [kind]) (a :: kind) = (SingI n, KnownPeano n, RequireLongerThan inp n, inp ~ (Take n inp ++ (a ': Drop ('S n) inp)), out ~ (a ': (Take n inp ++ Drop ('S n) inp)))
type ConstraintDUG n inp out a = ConstraintDUG' T n inp out a
type ConstraintDUG' kind (n :: Peano) (inp :: [kind]) (out :: [kind]) (a :: kind) = (SingI n, KnownPeano n, RequireLongerThan out n, inp ~ (a ': Drop ('S 'Z) inp), out ~ (Take n (Drop ('S 'Z) inp) ++ (a ': Drop ('S n) inp)))

Documentation

data Instr (inp :: [T]) (out :: [T]) where Source #

Representation of Michelson instruction or sequence of instructions.

Each Michelson instruction is represented by exactly one constructor of this data type. Sequence of instructions is represented with use of Seq constructor in following way: SWAP; DROP ; DUP; -> SWAP Seq DROP Seq DUP. Special case where there are no instructions is represented by constructor Nop, e.g. IF_NONE {} { SWAP; DROP; } -> IF_NONE Nop (SWAP Seq DROP).

Type parameter inp states for input stack type. That is, type of the stack that is required for operation to execute.

Type parameter out states for output stack type or type of stack that will be left after instruction's execution.

Constructors

WithLoc :: InstrCallStack -> Instr a b -> Instr a b	A wrapper carrying original source location of the instruction. TODO [#283]: replace this wrapper with something more clever and abstract.
InstrWithNotes :: PackedNotes b -> Instr a b -> Instr a b	A wrapper for instruction that also contain annotations for the top type on the result stack. As of now, when converting from untyped representation, we only preserve field annotations and type annotations. Variable annotations are not preserved. This can wrap only instructions with at least one non-failing execution branch.
InstrWithVarNotes :: NonEmpty VarAnn -> Instr a b -> Instr a b	A wrapper for instruction with variable annotations.
FrameInstr :: forall a b s. (KnownList a, KnownList b) => Proxy s -> Instr a b -> Instr (a ++ s) (b ++ s)	Execute given instruction on truncated stack. This can wrap only instructions with at least one non-failing execution branch. Morley has no such instruction, it is used solely in eDSLs. This instruction is sound because for all Michelson instructions the following property holds: if some code accepts stack `i` and produces stack `o`, when it can also be run on stack `i + s` producing stack `o + s`; and also because Michelson never makes implicit assumptions on types, rather you have to express all "yet ambiguous" type information in code. We could make this not an instruction but rather a function which modifies an instruction (this would also automatically prove soundness of used transformation), but it occured to be tricky (in particular for TestAssert and DipN and family), so let's leave this for future work.
Seq :: Instr a b -> Instr b c -> Instr a c
Nop :: Instr s s	Nop operation. Missing in Michelson spec, added to parse construction like `IF {} { SWAP; DROP; }`.
Ext :: ExtInstr s -> Instr s s
Nested :: Instr inp out -> Instr inp out	Nested wrapper is going to wrap a sequence of instructions with { }. It is crucial because serialisation of a contract depends on precise structure of its code.
DocGroup :: DocGrouping -> Instr inp out -> Instr inp out	Places documentation generated for given instruction under some group. This is not part of `ExtInstr` because it does not behave like `Nop`; instead, it inherits behaviour of instruction put within it.
AnnCAR :: FieldAnn -> Instr ('TPair a b ': s) (a ': s)	Variants of CAR/CDR to retain field annotations as they relate to the input stack, and hence won't be available from the annotation notes from the result stack we pack with the instructions during type check.
AnnCDR :: FieldAnn -> Instr ('TPair a b ': s) (b ': s)
DROP :: Instr (a ': s) s
DROPN :: forall (n :: Peano) s. (SingI n, KnownPeano n, RequireLongerOrSameLength s n, NFData (Sing n)) => Sing n -> Instr s (Drop n s)
DUP :: Instr (a ': s) (a ': (a ': s))
SWAP :: Instr (a ': (b ': s)) (b ': (a ': s))
DIG :: forall (n :: Peano) inp out a. (ConstraintDIG n inp out a, NFData (Sing n)) => Sing n -> Instr inp out
DUG :: forall (n :: Peano) inp out a. (ConstraintDUG n inp out a, NFData (Sing n)) => Sing n -> Instr inp out
PUSH :: forall t s. ConstantScope t => Value' Instr t -> Instr s (t ': s)
SOME :: Instr (a ': s) ('TOption a ': s)
NONE :: forall a s. KnownT a => Instr s ('TOption a ': s)
UNIT :: Instr s ('TUnit ': s)
IF_NONE :: Instr s s' -> Instr (a ': s) s' -> Instr ('TOption a ': s) s'
AnnPAIR :: TypeAnn -> FieldAnn -> FieldAnn -> Instr (a ': (b ': s)) ('TPair a b ': s)	Annotations for PAIR instructions can be different from notes presented on the stack in case of special field annotations, so we carry annotations for instruction separately from notes.
LEFT :: forall b a s. KnownT b => Instr (a ': s) ('TOr a b ': s)
RIGHT :: forall a b s. KnownT a => Instr (b ': s) ('TOr a b ': s)
IF_LEFT :: Instr (a ': s) s' -> Instr (b ': s) s' -> Instr ('TOr a b ': s) s'
NIL :: KnownT p => Instr s ('TList p ': s)
CONS :: Instr (a ': ('TList a ': s)) ('TList a ': s)
IF_CONS :: Instr (a ': ('TList a ': s)) s' -> Instr s s' -> Instr ('TList a ': s) s'
SIZE :: SizeOp c => Instr (c ': s) ('TNat ': s)
EMPTY_SET :: (KnownT e, Comparable e) => Instr s ('TSet e ': s)
EMPTY_MAP :: (KnownT a, KnownT b, Comparable a) => Instr s ('TMap a b ': s)
EMPTY_BIG_MAP :: (KnownT a, KnownT b, Comparable a) => Instr s ('TBigMap a b ': s)
MAP :: (MapOp c, KnownT b) => Instr (MapOpInp c ': s) (b ': s) -> Instr (c ': s) (MapOpRes c b ': s)
ITER :: IterOp c => Instr (IterOpEl c ': s) s -> Instr (c ': s) s
MEM :: MemOp c => Instr (MemOpKey c ': (c ': s)) ('TBool ': s)
GET :: (GetOp c, KnownT (GetOpVal c)) => Instr (GetOpKey c ': (c ': s)) ('TOption (GetOpVal c) ': s)
UPDATE :: UpdOp c => Instr (UpdOpKey c ': (UpdOpParams c ': (c ': s))) (c ': s)
IF :: Instr s s' -> Instr s s' -> Instr ('TBool ': s) s'
LOOP :: Instr s ('TBool ': s) -> Instr ('TBool ': s) s
LOOP_LEFT :: Instr (a ': s) ('TOr a b ': s) -> Instr ('TOr a b ': s) (b ': s)
LAMBDA :: forall i o s. (KnownT i, KnownT o) => Value' Instr ('TLambda i o) -> Instr s ('TLambda i o ': s)
EXEC :: Instr (t1 ': ('TLambda t1 t2 ': s)) (t2 ': s)
APPLY :: forall a b c s. (ConstantScope a, KnownT b) => Instr (a ': ('TLambda ('TPair a b) c ': s)) ('TLambda b c ': s)
DIP :: Instr a c -> Instr (b ': a) (b ': c)
DIPN :: forall (n :: Peano) inp out s s'. (ConstraintDIPN n inp out s s', NFData (Sing n)) => Sing n -> Instr s s' -> Instr inp out
FAILWITH :: KnownT a => Instr (a ': s) t
CAST :: forall a s. SingI a => Instr (a ': s) (a ': s)
RENAME :: Instr (a ': s) (a ': s)
PACK :: PackedValScope a => Instr (a ': s) ('TBytes ': s)
UNPACK :: (UnpackedValScope a, KnownT a) => Instr ('TBytes ': s) ('TOption a ': s)
CONCAT :: ConcatOp c => Instr (c ': (c ': s)) (c ': s)
CONCAT' :: ConcatOp c => Instr ('TList c ': s) (c ': s)
SLICE :: (SliceOp c, KnownT c) => Instr ('TNat ': ('TNat ': (c ': s))) ('TOption c ': s)
ISNAT :: Instr ('TInt ': s) ('TOption 'TNat ': s)
ADD :: (ArithOp Add n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Add n m ': s)
SUB :: (ArithOp Sub n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Sub n m ': s)
MUL :: (ArithOp Mul n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Mul n m ': s)
EDIV :: EDivOp n m => Instr (n ': (m ': s)) ('TOption ('TPair (EDivOpRes n m) (EModOpRes n m)) ': s)
ABS :: UnaryArithOp Abs n => Instr (n ': s) (UnaryArithRes Abs n ': s)
NEG :: UnaryArithOp Neg n => Instr (n ': s) (UnaryArithRes Neg n ': s)
LSL :: (ArithOp Lsl n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Lsl n m ': s)
LSR :: (ArithOp Lsr n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Lsr n m ': s)
OR :: (ArithOp Or n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Or n m ': s)
AND :: (ArithOp And n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes And n m ': s)
XOR :: (ArithOp Xor n m, Typeable n, Typeable m) => Instr (n ': (m ': s)) (ArithRes Xor n m ': s)
NOT :: UnaryArithOp Not n => Instr (n ': s) (UnaryArithRes Not n ': s)
COMPARE :: (Comparable n, KnownT n) => Instr (n ': (n ': s)) ('TInt ': s)
EQ :: UnaryArithOp Eq' n => Instr (n ': s) (UnaryArithRes Eq' n ': s)
NEQ :: UnaryArithOp Neq n => Instr (n ': s) (UnaryArithRes Neq n ': s)
LT :: UnaryArithOp Lt n => Instr (n ': s) (UnaryArithRes Lt n ': s)
GT :: UnaryArithOp Gt n => Instr (n ': s) (UnaryArithRes Gt n ': s)
LE :: UnaryArithOp Le n => Instr (n ': s) (UnaryArithRes Le n ': s)
GE :: UnaryArithOp Ge n => Instr (n ': s) (UnaryArithRes Ge n ': s)
INT :: Instr ('TNat ': s) ('TInt ': s)
SELF :: forall (arg :: T) s. ParameterScope arg => SomeEntrypointCallT arg -> Instr s ('TContract arg ': s)
CONTRACT :: ParameterScope p => Notes p -> EpName -> Instr ('TAddress ': s) ('TOption ('TContract p) ': s)
TRANSFER_TOKENS :: ParameterScope p => Instr (p ': ('TMutez ': ('TContract p ': s))) ('TOperation ': s)
SET_DELEGATE :: Instr ('TOption 'TKeyHash ': s) ('TOperation ': s)
CREATE_CONTRACT :: (ParameterScope p, StorageScope g) => Contract p g -> Instr ('TOption 'TKeyHash ': ('TMutez ': (g ': s))) ('TOperation ': ('TAddress ': s))
IMPLICIT_ACCOUNT :: Instr ('TKeyHash ': s) ('TContract 'TUnit ': s)
NOW :: Instr s ('TTimestamp ': s)
AMOUNT :: Instr s ('TMutez ': s)
BALANCE :: Instr s ('TMutez ': s)
CHECK_SIGNATURE :: Instr ('TKey ': ('TSignature ': ('TBytes ': s))) ('TBool ': s)
SHA256 :: Instr ('TBytes ': s) ('TBytes ': s)
SHA512 :: Instr ('TBytes ': s) ('TBytes ': s)
BLAKE2B :: Instr ('TBytes ': s) ('TBytes ': s)
HASH_KEY :: Instr ('TKey ': s) ('TKeyHash ': s)
SOURCE :: Instr s ('TAddress ': s)
SENDER :: Instr s ('TAddress ': s)
ADDRESS :: Instr ('TContract a ': s) ('TAddress ': s)
CHAIN_ID :: Instr s ('TChainId ': s)

Instances

Instances details

IsoValue Operation Source #
Instance details Defined in Michelson.Typed.Haskell.Value Associated Types type ToT Operation :: T Source # Methods toVal :: Operation -> Value (ToT Operation) Source # fromVal :: Value (ToT Operation) -> Operation Source #
TypeHasDoc Operation Source #
Instance details Defined in Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Operation :: FieldDescriptions Source # Methods typeDocName :: Proxy Operation -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Operation -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Operation -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Operation Source # typeDocMichelsonRep :: TypeDocMichelsonRep Operation Source #
UnpackedValScope t => FromExpression (Value t) Source #
Instance details Defined in Morley.Micheline.Class Methods fromExpression :: Expression -> Either FromExpressionError (Value t) Source #
(SingI t, HasNoOp t) => ToExpression (Value t) Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: Value t -> Expression Source #
Eq (Instr inp out) Source #
Instance details Defined in Michelson.Typed.Convert Methods (==) :: Instr inp out -> Instr inp out -> Bool # (/=) :: Instr inp out -> Instr inp out -> Bool #
Show (Instr inp out) Source #
Instance details Defined in Michelson.Typed.Instr Methods showsPrec :: Int -> Instr inp out -> ShowS # show :: Instr inp out -> String # showList :: [Instr inp out] -> ShowS #
Semigroup (Instr s s) Source #
Instance details Defined in Michelson.Typed.Instr Methods (<>) :: Instr s s -> Instr s s -> Instr s s # sconcat :: NonEmpty (Instr s s) -> Instr s s # stimes :: Integral b => b -> Instr s s -> Instr s s #
Monoid (Instr s s) Source #
Instance details Defined in Michelson.Typed.Instr Methods mempty :: Instr s s # mappend :: Instr s s -> Instr s s -> Instr s s # mconcat :: [Instr s s] -> Instr s s #
NFData (Instr out inp) Source #
Instance details Defined in Michelson.Typed.Instr Methods rnf :: Instr out inp -> () #
(SingI t, HasNoOp t) => Buildable (Value' Instr t) Source #
Instance details Defined in Michelson.Typed.Convert Methods build :: Value' Instr t -> Builder #
ToExpression (Instr inp out) Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: Instr inp out -> Expression Source #
type ToT Operation Source #
Instance details Defined in Michelson.Typed.Haskell.Value type ToT Operation = 'TOperation
type TypeDocFieldDescriptions Operation Source #
Instance details Defined in Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Operation = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]

data ExtInstr s Source #

Constructors

TEST_ASSERT (TestAssert s)
PRINT (PrintComment s)
DOC_ITEM SomeDocItem
COMMENT_ITEM CommentType

Instances

Instances details

Show (ExtInstr s) Source #
Instance details Defined in Michelson.Typed.Instr Methods showsPrec :: Int -> ExtInstr s -> ShowS # show :: ExtInstr s -> String # showList :: [ExtInstr s] -> ShowS #
Generic (ExtInstr s) Source #
Instance details Defined in Michelson.Typed.Instr Associated Types type Rep (ExtInstr s) :: Type -> Type # Methods from :: ExtInstr s -> Rep (ExtInstr s) x # to :: Rep (ExtInstr s) x -> ExtInstr s #
NFData (ExtInstr s) Source #
Instance details Defined in Michelson.Typed.Instr Methods rnf :: ExtInstr s -> () #
type Rep (ExtInstr s) Source #
Instance details Defined in Michelson.Typed.Instr type Rep (ExtInstr s) = D1 ('MetaData "ExtInstr" "Michelson.Typed.Instr" "morley-1.7.0-inplace" 'False) ((C1 ('MetaCons "TEST_ASSERT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (TestAssert s))) :+: C1 ('MetaCons "PRINT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (PrintComment s)))) :+: (C1 ('MetaCons "DOC_ITEM" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SomeDocItem)) :+: C1 ('MetaCons "COMMENT_ITEM" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 CommentType))))

data CommentType Source #

Constructors

FunctionStarts Text
FunctionEnds Text
StatementStarts Text
StatementEnds Text
JustComment Text

Instances

Instances details

Show CommentType Source #
Instance details Defined in Michelson.Typed.Instr Methods showsPrec :: Int -> CommentType -> ShowS # show :: CommentType -> String # showList :: [CommentType] -> ShowS #
Generic CommentType Source #
Instance details Defined in Michelson.Typed.Instr Associated Types type Rep CommentType :: Type -> Type # Methods from :: CommentType -> Rep CommentType x # to :: Rep CommentType x -> CommentType #
NFData CommentType Source #
Instance details Defined in Michelson.Typed.Instr Methods rnf :: CommentType -> () #
type Rep CommentType Source #
Instance details Defined in Michelson.Typed.Instr type Rep CommentType = D1 ('MetaData "CommentType" "Michelson.Typed.Instr" "morley-1.7.0-inplace" 'False) ((C1 ('MetaCons "FunctionStarts" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: C1 ('MetaCons "FunctionEnds" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text))) :+: (C1 ('MetaCons "StatementStarts" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: (C1 ('MetaCons "StatementEnds" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: C1 ('MetaCons "JustComment" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)))))

data StackRef (st :: [T]) where Source #

A reference into the stack of a given type.

Constructors

StackRef :: (KnownPeano idx, SingI idx, RequireLongerThan st idx) => Sing (idx :: Peano) -> StackRef st

Keeps 0-based index to a stack element counting from the top.

Instances

Instances details

Eq (StackRef st) Source #
Instance details Defined in Michelson.Typed.Instr Methods (==) :: StackRef st -> StackRef st -> Bool # (/=) :: StackRef st -> StackRef st -> Bool #
Show (StackRef st) Source #
Instance details Defined in Michelson.Typed.Instr Methods showsPrec :: Int -> StackRef st -> ShowS # show :: StackRef st -> String # showList :: [StackRef st] -> ShowS #
NFData (StackRef st) Source #
Instance details Defined in Michelson.Typed.Instr Methods rnf :: StackRef st -> () #

mkStackRef :: forall (gn :: Nat) st n. (n ~ ToPeano gn, SingI n, KnownPeano n, RequireLongerThan st n) => StackRef st Source #

Create a stack reference, performing checks at compile time.

newtype PrintComment (st :: [T]) Source #

A print format with references into the stack

Constructors

PrintComment
Fields unPrintComment :: [Either Text (StackRef st)]

Instances

Instances details

Eq (PrintComment st) Source #
Instance details Defined in Michelson.Typed.Instr Methods (==) :: PrintComment st -> PrintComment st -> Bool # (/=) :: PrintComment st -> PrintComment st -> Bool #
Show (PrintComment st) Source #
Instance details Defined in Michelson.Typed.Instr Methods showsPrec :: Int -> PrintComment st -> ShowS # show :: PrintComment st -> String # showList :: [PrintComment st] -> ShowS #
IsString (PrintComment st) Source #
Instance details Defined in Michelson.Typed.Instr Methods fromString :: String -> PrintComment st #
Generic (PrintComment st) Source #
Instance details Defined in Michelson.Typed.Instr Associated Types type Rep (PrintComment st) :: Type -> Type # Methods from :: PrintComment st -> Rep (PrintComment st) x # to :: Rep (PrintComment st) x -> PrintComment st #
Semigroup (PrintComment st) Source #
Instance details Defined in Michelson.Typed.Instr Methods (<>) :: PrintComment st -> PrintComment st -> PrintComment st # sconcat :: NonEmpty (PrintComment st) -> PrintComment st # stimes :: Integral b => b -> PrintComment st -> PrintComment st #
Monoid (PrintComment st) Source #
Instance details Defined in Michelson.Typed.Instr Methods mempty :: PrintComment st # mappend :: PrintComment st -> PrintComment st -> PrintComment st # mconcat :: [PrintComment st] -> PrintComment st #
NFData (PrintComment st) Source #
Instance details Defined in Michelson.Typed.Instr Methods rnf :: PrintComment st -> () #
type Rep (PrintComment st) Source #
Instance details Defined in Michelson.Typed.Instr type Rep (PrintComment st) = D1 ('MetaData "PrintComment" "Michelson.Typed.Instr" "morley-1.7.0-inplace" 'True) (C1 ('MetaCons "PrintComment" 'PrefixI 'True) (S1 ('MetaSel ('Just "unPrintComment") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Either Text (StackRef st)])))

data TestAssert (s :: [T]) where Source #

Constructors

TestAssert :: Typeable out => Text -> PrintComment inp -> Instr inp ('TBool ': out) -> TestAssert inp

Instances

Instances details

Typeable s => Eq (TestAssert s) Source #
Instance details Defined in Michelson.Typed.Convert Methods (==) :: TestAssert s -> TestAssert s -> Bool # (/=) :: TestAssert s -> TestAssert s -> Bool #
Show (TestAssert s) Source #
Instance details Defined in Michelson.Typed.Instr Methods showsPrec :: Int -> TestAssert s -> ShowS # show :: TestAssert s -> String # showList :: [TestAssert s] -> ShowS #
NFData (TestAssert s) Source #
Instance details Defined in Michelson.Typed.Instr Methods rnf :: TestAssert s -> () #

type ContractCode cp st = Instr (ContractInp cp st) (ContractOut st) Source #

data Contract cp st Source #

Typed contract and information about annotations which is not present in the contract code.

Constructors

(ParameterScope cp, StorageScope st) => Contract
Fields cCode :: ContractCode cp st cParamNotes :: ParamNotes cp cStoreNotes :: Notes st cEntriesOrder :: EntriesOrder

Instances

Instances details

Eq (ContractCode cp st) => Eq (Contract cp st) Source #
Instance details Defined in Michelson.Typed.Instr Methods (==) :: Contract cp st -> Contract cp st -> Bool # (/=) :: Contract cp st -> Contract cp st -> Bool #
Show (Contract cp st) Source #
Instance details Defined in Michelson.Typed.Instr Methods showsPrec :: Int -> Contract cp st -> ShowS # show :: Contract cp st -> String # showList :: [Contract cp st] -> ShowS #
NFData (Contract cp st) Source #
Instance details Defined in Michelson.Typed.Instr Methods rnf :: Contract cp st -> () #
ToExpression (Contract cp st) Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: Contract cp st -> Expression Source #

mapContractCode :: (ContractCode cp st -> ContractCode cp st) -> Contract cp st -> Contract cp st Source #

mapEntriesOrdered :: Contract cp st -> (ParamNotes cp -> a) -> (Notes st -> a) -> (ContractCode cp st -> a) -> [a] Source #

Map each typed contract fields by the given function and sort the output based on the EntriesOrder.

pattern CAR :: () => (i ~ ('TPair a b ': s), o ~ (a ': s)) => Instr i o Source #

pattern CDR :: () => (i ~ ('TPair a b ': s), o ~ (b ': s)) => Instr i o Source #

pattern PAIR :: () => (i ~ (a ': (b ': s)), o ~ ('TPair a b ': s)) => Instr i o Source #

pattern UNPAIR :: () => (i ~ ('TPair a b ': s), o ~ (a ': (b ': s))) => Instr i o Source #

data PackedNotes a where Source #

A wrapper to wrap annotations and corresponding singleton. Apart from packing notes along with the corresponding Singleton, this wrapper type, when included with Instr also helps to derive the Show instance for Instr as `Sing a` does not have a Show instance on its own.

Constructors

PackedNotes :: SingI a => Notes a -> PackedNotes (a ': s)

Instances

Instances details

Show (PackedNotes a) Source #
Instance details Defined in Michelson.Typed.Instr Methods showsPrec :: Int -> PackedNotes a -> ShowS # show :: PackedNotes a -> String # showList :: [PackedNotes a] -> ShowS #
NFData (PackedNotes a) Source #
Instance details Defined in Michelson.Typed.Instr Methods rnf :: PackedNotes a -> () #
Buildable (PackedNotes a) Source #
Instance details Defined in Michelson.Typed.Instr Methods build :: PackedNotes a -> Builder #
RenderDoc (PackedNotes a) Source #
Instance details Defined in Michelson.Typed.Instr Methods renderDoc :: RenderContext -> PackedNotes a -> Doc Source # isRenderable :: PackedNotes a -> Bool Source #

type ConstraintDIPN n inp out s s' = ConstraintDIPN' T n inp out s s' Source #

type ConstraintDIPN' kind (n :: Peano) (inp :: [kind]) (out :: [kind]) (s :: [kind]) (s' :: [kind]) = (SingI n, KnownPeano n, RequireLongerOrSameLength inp n, (Take n inp ++ s) ~ inp, (Take n inp ++ s') ~ out) Source #

Constraint that is used in DIPN, we want to share it with typechecking code and eDSL code.

type ConstraintDIG n inp out a = ConstraintDIG' T n inp out a Source #

type ConstraintDIG' kind (n :: Peano) (inp :: [kind]) (out :: [kind]) (a :: kind) = (SingI n, KnownPeano n, RequireLongerThan inp n, inp ~ (Take n inp ++ (a ': Drop ('S n) inp)), out ~ (a ': (Take n inp ++ Drop ('S n) inp))) Source #

type ConstraintDUG n inp out a = ConstraintDUG' T n inp out a Source #

type ConstraintDUG' kind (n :: Peano) (inp :: [kind]) (out :: [kind]) (a :: kind) = (SingI n, KnownPeano n, RequireLongerThan out n, inp ~ (a ': Drop ('S 'Z) inp), out ~ (Take n (Drop ('S 'Z) inp) ++ (a ': Drop ('S n) inp))) Source #