Safe Haskell	None
Language	Haskell2010

Michelson.Typed.Instr

Description

Module, containing data types for Michelson value.

Synopsis

data Instr (inp :: [T]) (out :: [T]) where
- 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
- DROP :: Instr (a ': s) s
- DUP :: Instr (a ': s) (a ': (a ': s))
- SWAP :: Instr (a ': (b ': s)) (b ': (a ': s))
- PUSH :: forall t s. (SingI t, HasNoOp t, HasNoBigMap t) => Value' Instr t -> Instr s (t ': s)
- SOME :: Instr (a ': s) (TOption a ': s)
- NONE :: forall a s. SingI 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'
- PAIR :: Instr (a ': (b ': s)) (TPair a b ': s)
- CAR :: Instr (TPair a b ': s) (a ': s)
- CDR :: Instr (TPair a b ': s) (b ': s)
- LEFT :: forall b a s. SingI b => Instr (a ': s) (TOr a b ': s)
- RIGHT :: forall a b s. SingI 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 :: SingI 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) (Tc CNat ': s)
- EMPTY_SET :: (Typeable e, SingI e) => Instr s (TSet e ': s)
- EMPTY_MAP :: (Typeable a, Typeable b, SingI a, SingI b) => Instr s (TMap a b ': s)
- MAP :: MapOp c => 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 (Tc (MemOpKey c) ': (c ': s)) (Tc CBool ': s)
- GET :: GetOp c => Instr (Tc (GetOpKey c) ': (c ': s)) (TOption (GetOpVal c) ': s)
- UPDATE :: UpdOp c => Instr (Tc (UpdOpKey c) ': (UpdOpParams c ': (c ': s))) (c ': s)
- IF :: Instr s s' -> Instr s s' -> Instr (Tc CBool ': s) s'
- LOOP :: Instr s (Tc CBool ': s) -> Instr (Tc CBool ': s) s
- LOOP_LEFT :: Instr (a ': s) (TOr a b ': s) -> Instr (TOr a b ': s) (b ': s)
- LAMBDA :: forall i o s. Each [Typeable, SingI] [i, o] => Value' Instr (TLambda i o) -> Instr s (TLambda i o ': s)
- EXEC :: Instr (t1 ': (TLambda t1 t2 ': s)) (t2 ': s)
- DIP :: Instr a c -> Instr (b ': a) (b ': c)
- FAILWITH :: (Typeable a, SingI a) => Instr (a ': s) t
- CAST :: forall a s. SingI a => Instr (a ': s) (a ': s)
- RENAME :: Instr (a ': s) (a ': s)
- PACK :: (SingI a, HasNoOp a, HasNoBigMap a) => Instr (a ': s) (Tc CBytes ': s)
- UNPACK :: (SingI a, HasNoOp a, HasNoBigMap a) => Instr (Tc CBytes ': 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 => Instr (Tc CNat ': (Tc CNat ': (c ': s))) (TOption c ': s)
- ISNAT :: Instr (Tc CInt ': s) (TOption (Tc CNat) ': s)
- ADD :: (ArithOp Add n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Add n m) ': s)
- SUB :: (ArithOp Sub n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Sub n m) ': s)
- MUL :: (ArithOp Mul n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Mul n m) ': s)
- EDIV :: EDivOp n m => Instr (Tc n ': (Tc m ': s)) (TOption (TPair (Tc (EDivOpRes n m)) (Tc (EModOpRes n m))) ': s)
- ABS :: UnaryArithOp Abs n => Instr (Tc n ': s) (Tc (UnaryArithRes Abs n) ': s)
- NEG :: UnaryArithOp Neg n => Instr (Tc n ': s) (Tc (UnaryArithRes Neg n) ': s)
- LSL :: (ArithOp Lsl n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Lsl n m) ': s)
- LSR :: (ArithOp Lsr n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Lsr n m) ': s)
- OR :: (ArithOp Or n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Or n m) ': s)
- AND :: (ArithOp And n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes And n m) ': s)
- XOR :: (ArithOp Xor n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Xor n m) ': s)
- NOT :: UnaryArithOp Not n => Instr (Tc n ': s) (Tc (UnaryArithRes Not n) ': s)
- COMPARE :: (ArithOp Compare n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Compare n m) ': s)
- EQ :: UnaryArithOp Eq' n => Instr (Tc n ': s) (Tc (UnaryArithRes Eq' n) ': s)
- NEQ :: UnaryArithOp Neq n => Instr (Tc n ': s) (Tc (UnaryArithRes Neq n) ': s)
- LT :: UnaryArithOp Lt n => Instr (Tc n ': s) (Tc (UnaryArithRes Lt n) ': s)
- GT :: UnaryArithOp Gt n => Instr (Tc n ': s) (Tc (UnaryArithRes Gt n) ': s)
- LE :: UnaryArithOp Le n => Instr (Tc n ': s) (Tc (UnaryArithRes Le n) ': s)
- GE :: UnaryArithOp Ge n => Instr (Tc n ': s) (Tc (UnaryArithRes Ge n) ': s)
- INT :: Instr (Tc CNat ': s) (Tc CInt ': s)
- SELF :: forall (cp :: T) s. Instr s (TContract cp ': s)
- CONTRACT :: (SingI p, Typeable p) => Notes p -> Instr (Tc CAddress ': s) (TOption (TContract p) ': s)
- TRANSFER_TOKENS :: (Typeable p, SingI p, HasNoOp p, HasNoBigMap p) => Instr (p ': (Tc CMutez ': (TContract p ': s))) (TOperation ': s)
- SET_DELEGATE :: Instr (TOption (Tc CKeyHash) ': s) (TOperation ': s)
- CREATE_ACCOUNT :: Instr (Tc CKeyHash ': (TOption (Tc CKeyHash) ': (Tc CBool ': (Tc CMutez ': s)))) (TOperation ': (Tc CAddress ': s))
- CREATE_CONTRACT :: (Each [Typeable, SingI, HasNoOp] [p, g], HasNoBigMap p, BigMapConstraint g) => Instr '[TPair p g] '[TPair (TList TOperation) g] -> Instr (Tc CKeyHash ': (TOption (Tc CKeyHash) ': (Tc CBool ': (Tc CBool ': (Tc CMutez ': (g ': s)))))) (TOperation ': (Tc CAddress ': s))
- IMPLICIT_ACCOUNT :: Instr (Tc CKeyHash ': s) (TContract TUnit ': s)
- NOW :: Instr s (Tc CTimestamp ': s)
- AMOUNT :: Instr s (Tc CMutez ': s)
- BALANCE :: Instr s (Tc CMutez ': s)
- CHECK_SIGNATURE :: Instr (TKey ': (TSignature ': (Tc CBytes ': s))) (Tc CBool ': s)
- SHA256 :: Instr (Tc CBytes ': s) (Tc CBytes ': s)
- SHA512 :: Instr (Tc CBytes ': s) (Tc CBytes ': s)
- BLAKE2B :: Instr (Tc CBytes ': s) (Tc CBytes ': s)
- HASH_KEY :: Instr (TKey ': s) (Tc CKeyHash ': s)
- STEPS_TO_QUOTA :: Instr s (Tc CNat ': s)
- SOURCE :: Instr s (Tc CAddress ': s)
- SENDER :: Instr s (Tc CAddress ': s)
- ADDRESS :: Instr (TContract a ': s) (Tc CAddress ': s)
data ExtInstr s
- = TEST_ASSERT (TestAssert s)
- | PRINT (PrintComment s)
data StackRef (st :: [T]) where
- StackRef :: (KnownPeano idx, LongerThan 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 (Tc CBool ': out) -> TestAssert inp
type Contract cp st = Instr (ContractInp cp st) (ContractOut st)

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 Instr DROP Instr DUP. Special case where there are no instructions is represented by constructor Nop, e.g. IF_NONE {} { SWAP; DROP; } -> IF_NONE Nop (SWAP Instr 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

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.
DROP :: Instr (a ': s) s
DUP :: Instr (a ': s) (a ': (a ': s))
SWAP :: Instr (a ': (b ': s)) (b ': (a ': s))
PUSH :: forall t s. (SingI t, HasNoOp t, HasNoBigMap t) => Value' Instr t -> Instr s (t ': s)
SOME :: Instr (a ': s) (TOption a ': s)
NONE :: forall a s. SingI 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'
PAIR :: Instr (a ': (b ': s)) (TPair a b ': s)
CAR :: Instr (TPair a b ': s) (a ': s)
CDR :: Instr (TPair a b ': s) (b ': s)
LEFT :: forall b a s. SingI b => Instr (a ': s) (TOr a b ': s)
RIGHT :: forall a b s. SingI 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 :: SingI 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) (Tc CNat ': s)
EMPTY_SET :: (Typeable e, SingI e) => Instr s (TSet e ': s)
EMPTY_MAP :: (Typeable a, Typeable b, SingI a, SingI b) => Instr s (TMap a b ': s)
MAP :: MapOp c => 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 (Tc (MemOpKey c) ': (c ': s)) (Tc CBool ': s)
GET :: GetOp c => Instr (Tc (GetOpKey c) ': (c ': s)) (TOption (GetOpVal c) ': s)
UPDATE :: UpdOp c => Instr (Tc (UpdOpKey c) ': (UpdOpParams c ': (c ': s))) (c ': s)
IF :: Instr s s' -> Instr s s' -> Instr (Tc CBool ': s) s'
LOOP :: Instr s (Tc CBool ': s) -> Instr (Tc CBool ': s) s
LOOP_LEFT :: Instr (a ': s) (TOr a b ': s) -> Instr (TOr a b ': s) (b ': s)
LAMBDA :: forall i o s. Each [Typeable, SingI] [i, o] => Value' Instr (TLambda i o) -> Instr s (TLambda i o ': s)
EXEC :: Instr (t1 ': (TLambda t1 t2 ': s)) (t2 ': s)
DIP :: Instr a c -> Instr (b ': a) (b ': c)
FAILWITH :: (Typeable a, SingI a) => Instr (a ': s) t
CAST :: forall a s. SingI a => Instr (a ': s) (a ': s)
RENAME :: Instr (a ': s) (a ': s)
PACK :: (SingI a, HasNoOp a, HasNoBigMap a) => Instr (a ': s) (Tc CBytes ': s)
UNPACK :: (SingI a, HasNoOp a, HasNoBigMap a) => Instr (Tc CBytes ': 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 => Instr (Tc CNat ': (Tc CNat ': (c ': s))) (TOption c ': s)
ISNAT :: Instr (Tc CInt ': s) (TOption (Tc CNat) ': s)
ADD :: (ArithOp Add n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Add n m) ': s)
SUB :: (ArithOp Sub n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Sub n m) ': s)
MUL :: (ArithOp Mul n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Mul n m) ': s)
EDIV :: EDivOp n m => Instr (Tc n ': (Tc m ': s)) (TOption (TPair (Tc (EDivOpRes n m)) (Tc (EModOpRes n m))) ': s)
ABS :: UnaryArithOp Abs n => Instr (Tc n ': s) (Tc (UnaryArithRes Abs n) ': s)
NEG :: UnaryArithOp Neg n => Instr (Tc n ': s) (Tc (UnaryArithRes Neg n) ': s)
LSL :: (ArithOp Lsl n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Lsl n m) ': s)
LSR :: (ArithOp Lsr n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Lsr n m) ': s)
OR :: (ArithOp Or n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Or n m) ': s)
AND :: (ArithOp And n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes And n m) ': s)
XOR :: (ArithOp Xor n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Xor n m) ': s)
NOT :: UnaryArithOp Not n => Instr (Tc n ': s) (Tc (UnaryArithRes Not n) ': s)
COMPARE :: (ArithOp Compare n m, Typeable n, Typeable m) => Instr (Tc n ': (Tc m ': s)) (Tc (ArithRes Compare n m) ': s)
EQ :: UnaryArithOp Eq' n => Instr (Tc n ': s) (Tc (UnaryArithRes Eq' n) ': s)
NEQ :: UnaryArithOp Neq n => Instr (Tc n ': s) (Tc (UnaryArithRes Neq n) ': s)
LT :: UnaryArithOp Lt n => Instr (Tc n ': s) (Tc (UnaryArithRes Lt n) ': s)
GT :: UnaryArithOp Gt n => Instr (Tc n ': s) (Tc (UnaryArithRes Gt n) ': s)
LE :: UnaryArithOp Le n => Instr (Tc n ': s) (Tc (UnaryArithRes Le n) ': s)
GE :: UnaryArithOp Ge n => Instr (Tc n ': s) (Tc (UnaryArithRes Ge n) ': s)
INT :: Instr (Tc CNat ': s) (Tc CInt ': s)
SELF :: forall (cp :: T) s. Instr s (TContract cp ': s)
CONTRACT :: (SingI p, Typeable p) => Notes p -> Instr (Tc CAddress ': s) (TOption (TContract p) ': s)
TRANSFER_TOKENS :: (Typeable p, SingI p, HasNoOp p, HasNoBigMap p) => Instr (p ': (Tc CMutez ': (TContract p ': s))) (TOperation ': s)
SET_DELEGATE :: Instr (TOption (Tc CKeyHash) ': s) (TOperation ': s)
CREATE_ACCOUNT :: Instr (Tc CKeyHash ': (TOption (Tc CKeyHash) ': (Tc CBool ': (Tc CMutez ': s)))) (TOperation ': (Tc CAddress ': s))
CREATE_CONTRACT :: (Each [Typeable, SingI, HasNoOp] [p, g], HasNoBigMap p, BigMapConstraint g) => Instr '[TPair p g] '[TPair (TList TOperation) g] -> Instr (Tc CKeyHash ': (TOption (Tc CKeyHash) ': (Tc CBool ': (Tc CBool ': (Tc CMutez ': (g ': s)))))) (TOperation ': (Tc CAddress ': s))
IMPLICIT_ACCOUNT :: Instr (Tc CKeyHash ': s) (TContract TUnit ': s)
NOW :: Instr s (Tc CTimestamp ': s)
AMOUNT :: Instr s (Tc CMutez ': s)
BALANCE :: Instr s (Tc CMutez ': s)
CHECK_SIGNATURE :: Instr (TKey ': (TSignature ': (Tc CBytes ': s))) (Tc CBool ': s)
SHA256 :: Instr (Tc CBytes ': s) (Tc CBytes ': s)
SHA512 :: Instr (Tc CBytes ': s) (Tc CBytes ': s)
BLAKE2B :: Instr (Tc CBytes ': s) (Tc CBytes ': s)
HASH_KEY :: Instr (TKey ': s) (Tc CKeyHash ': s)
STEPS_TO_QUOTA :: Instr s (Tc CNat ': s)
SOURCE :: Instr s (Tc CAddress ': s)
SENDER :: Instr s (Tc CAddress ': s)
ADDRESS :: Instr (TContract a ': s) (Tc CAddress ': s)

Instances

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 #
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 #
(SingI cp, SingI st) => IsContract (Contract cp st) Source #
Instance details Defined in Lorentz.Discover Methods toUntypedContract :: Contract cp st -> Contract0 Source #
(SingI (ToT cp), SingI (ToT st), NoOperation cp, NoOperation st, NoBigMap cp, CanHaveBigMap st) => IsContract (Contract cp st) Source #
Instance details Defined in Lorentz.Discover Methods toUntypedContract :: Contract cp st -> Contract0 Source #
type ToT Operation Source #
Instance details Defined in Michelson.Typed.Haskell.Value type ToT Operation = TOperation

data ExtInstr s Source #

Constructors

TEST_ASSERT (TestAssert s)
PRINT (PrintComment s)

Instances

Typeable s => Eq (ExtInstr s) Source #
Instance details Defined in Michelson.Typed.Convert Methods (==) :: ExtInstr s -> ExtInstr s -> Bool # (/=) :: ExtInstr s -> ExtInstr s -> Bool #
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 #

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

A reference into the stack of a given type.

Constructors

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

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

Instances

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 #

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

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 #
type Rep (PrintComment st) Source #
Instance details Defined in Michelson.Typed.Instr type Rep (PrintComment st) = D1 (MetaData "PrintComment" "Michelson.Typed.Instr" "morley-0.3.0.1-Avb9bjjqJWNEobyGi9OGAh" 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 (Tc CBool ': out) -> TestAssert inp

Instances

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 #

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