lorentz-0.6.1: EDSL for the Michelson Language
Safe HaskellNone
LanguageHaskell2010

Lorentz.Macro

Description

Common Michelson macros defined using Lorentz syntax.

Synopsis

Compare

type NiceComparable n = (KnownValue n, Comparable (ToT n)) Source #

eq :: NiceComparable n => (n & (n & s)) :-> (Bool & s) Source #

neq :: NiceComparable n => (n & (n & s)) :-> (Bool & s) Source #

lt :: NiceComparable n => (n & (n & s)) :-> (Bool & s) Source #

gt :: NiceComparable n => (n & (n & s)) :-> (Bool & s) Source #

le :: NiceComparable n => (n & (n & s)) :-> (Bool & s) Source #

ge :: NiceComparable n => (n & (n & s)) :-> (Bool & s) Source #

ifEq0 :: IfCmp0Constraints a Eq' => (s :-> s') -> (s :-> s') -> (a & s) :-> s' Source #

ifGe0 :: IfCmp0Constraints a Ge => (s :-> s') -> (s :-> s') -> (a & s) :-> s' Source #

ifGt0 :: IfCmp0Constraints a Gt => (s :-> s') -> (s :-> s') -> (a & s) :-> s' Source #

ifLe0 :: IfCmp0Constraints a Le => (s :-> s') -> (s :-> s') -> (a & s) :-> s' Source #

ifLt0 :: IfCmp0Constraints a Lt => (s :-> s') -> (s :-> s') -> (a & s) :-> s' Source #

ifNeq0 :: IfCmp0Constraints a Neq => (s :-> s') -> (s :-> s') -> (a & s) :-> s' Source #

ifEq :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s' Source #

ifGe :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s' Source #

ifGt :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s' Source #

ifLe :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s' Source #

ifLt :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s' Source #

ifNeq :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s' Source #

Fail

fail_ :: a :-> c Source #

Warning: fail_ remains in code

Analog of the FAIL macro in Michelson. Its usage is discouraged because it doesn't carry any information about failure.

Assertion macros

They differ from the same macros in Michelson, because those macros use FAIL macro which is not informative (fails with unit). If you really want Michelson versions (maybe to produce exact copy of an existing contract), you can pass UnspecifiedError, then FAILWITH will be called with unit.

assert :: IsError err => err -> (Bool & s) :-> s Source #

assertEq0 :: (IfCmp0Constraints a Eq', IsError err) => err -> (a & s) :-> s Source #

assertNeq0 :: (IfCmp0Constraints a Neq, IsError err) => err -> (a & s) :-> s Source #

assertLt0 :: (IfCmp0Constraints a Lt, IsError err) => err -> (a & s) :-> s Source #

assertGt0 :: (IfCmp0Constraints a Gt, IsError err) => err -> (a & s) :-> s Source #

assertLe0 :: (IfCmp0Constraints a Le, IsError err) => err -> (a & s) :-> s Source #

assertGe0 :: (IfCmp0Constraints a Ge, IsError err) => err -> (a & s) :-> s Source #

assertEq :: (NiceComparable a, IsError err) => err -> (a & (a & s)) :-> s Source #

assertNeq :: (NiceComparable a, IsError err) => err -> (a & (a & s)) :-> s Source #

assertLt :: (NiceComparable a, IsError err) => err -> (a & (a & s)) :-> s Source #

assertGt :: (NiceComparable a, IsError err) => err -> (a & (a & s)) :-> s Source #

assertLe :: (NiceComparable a, IsError err) => err -> (a & (a & s)) :-> s Source #

assertGe :: (NiceComparable a, IsError err) => err -> (a & (a & s)) :-> s Source #

assertNone :: IsError err => err -> (Maybe a & s) :-> s Source #

assertSome :: IsError err => err -> (Maybe a & s) :-> (a & s) Source #

assertLeft :: IsError err => err -> (Either a b & s) :-> (a & s) Source #

assertRight :: IsError err => err -> (Either a b & s) :-> (b & s) Source #

assertUsing :: IsError a => a -> (Bool & s) :-> s Source #

Syntactic Conveniences

type ConstraintDuupXLorentz (n :: Peano) (s :: [Type]) (a :: Type) (s1 :: [Type]) (tail :: [Type]) = (DuupXConstraint' T n (ToTs s) (ToT a) (ToTs s1) (ToTs tail), DuupXConstraint' Type n s a s1 tail) Source #

Constraint for duupX that combines kind-agnostic constraint for Lorentz (Haskell) types and for our typed Michelson.

type ConstraintReplaceNLorentz (n :: Peano) (s :: [Type]) (a :: Type) (mid :: [Type]) (tail :: [Type]) = (ReplaceNConstraint' T n (ToTs s) (ToT a) (ToTs mid) (ToTs tail), ReplaceNConstraint' Type n s a mid tail) Source #

Constraint for replaceN that combines kind-agnostic constraint for Lorentz (Haskell) types and for our typed Michelson.

type ConstraintUpdateNLorentz (n :: Peano) (s :: [Type]) (a :: Type) (b :: Type) (mid :: [Type]) (tail :: [Type]) = (UpdateNConstraint' T n (ToTs s) (ToT a) (ToT b) (ToTs mid) (ToTs tail), UpdateNConstraint' Type n s a b mid tail) Source #

Constraint for updateN that combines kind-agnostic constraint for Lorentz (Haskell) types and for our typed Michelson.

class DuupX (n :: Peano) (s :: [Type]) (a :: Type) s1 tail where Source #

Methods

duupXImpl :: s :-> (a ': s) Source #

Instances

Instances details
s ~ (a ': xs) => DuupX ('S 'Z) s a (s1 :: k1) (tail :: k2) Source # 
Instance details

Defined in Lorentz.Macro

Methods

duupXImpl :: s :-> (a ': s) Source #

DuupX ('S ('S 'Z)) (b ': (a ': xs)) a (s1 :: k1) (tail :: k2) Source # 
Instance details

Defined in Lorentz.Macro

Methods

duupXImpl :: (b ': (a ': xs)) :-> (a ': (b ': (a ': xs))) Source #

ConstraintDuupXLorentz ('S ('S n)) s a s1 tail => DuupX ('S ('S ('S n))) s a (s1 :: [Type]) (tail :: [Type]) Source # 
Instance details

Defined in Lorentz.Macro

Methods

duupXImpl :: s :-> (a ': s) Source #

class ReplaceN (n :: Peano) (s :: [Type]) (a :: Type) mid tail where Source #

Methods

replaceNImpl :: (a ': s) :-> s Source #

Instances

Instances details
s ~ (a ': xs) => ReplaceN ('S 'Z) s a (mid :: k1) (tail :: k2) Source # 
Instance details

Defined in Lorentz.Macro

Methods

replaceNImpl :: (a ': s) :-> s Source #

ConstraintReplaceNLorentz ('S n) s a mid tail => ReplaceN ('S ('S n)) s a (mid :: [Type]) (tail :: [Type]) Source # 
Instance details

Defined in Lorentz.Macro

Methods

replaceNImpl :: (a ': s) :-> s Source #

class UpdateN (n :: Peano) (s :: [Type]) (a :: Type) (b :: Type) mid tail where Source #

Methods

updateNImpl :: ('[a, b] :-> '[b]) -> (a ': s) :-> s Source #

Instances

Instances details
s ~ (x ': (b ': tail)) => UpdateN ('S ('S 'Z)) s a b (mid :: k) (tail :: [Type]) Source # 
Instance details

Defined in Lorentz.Macro

Methods

updateNImpl :: ('[a, b] :-> '[b]) -> (a ': s) :-> s Source #

s ~ (b ': tail) => UpdateN ('S 'Z) s a b (mid :: k) (tail :: [Type]) Source # 
Instance details

Defined in Lorentz.Macro

Methods

updateNImpl :: ('[a, b] :-> '[b]) -> (a ': s) :-> s Source #

ConstraintUpdateNLorentz ('S ('S n)) s a b mid tail => UpdateN ('S ('S ('S n))) s a b (mid :: [Type]) (tail :: [Type]) Source # 
Instance details

Defined in Lorentz.Macro

Methods

updateNImpl :: ('[a, b] :-> '[b]) -> (a ': s) :-> s Source #

dropX :: forall (n :: Nat) a inp out s s'. (ConstraintDIPNLorentz (ToPeano n) inp out s s', s ~ (a ': s')) => inp :-> out Source #

Custom Lorentz macro that drops element with given index (starting from 0) from the stack.

cloneX :: forall (n :: Nat) a s. CloneX (ToPeano n) a s => (a & s) :-> CloneXT (ToPeano n) a s Source #

Duplicate the top of the stack n times.

For example, `cloneX @3` has type `a & s :-> a & a & a & a & s`.

duupX :: forall (n :: Nat) a (s :: [Type]) (s1 :: [Type]) (tail :: [Type]). (ConstraintDuupXLorentz (ToPeano (n - 1)) s a s1 tail, DuupX (ToPeano n) s a s1 tail) => s :-> (a ': s) Source #

DUU+P macro. For example, `duupX @3` is DUUUP, it puts the 3-rd (starting from 1) element to the top of the stack. Note that it is implemented differently for `n ≤ 2` and for `n > 2`. In the latter case it is implemented using dipN, dig and dup. In the former case it uses specialized versions. There is also a minor difference with the implementation of `DUU*P` in Michelson. They implement DUUUUP as `DIP 3 { DUP }; DIG 4`. We implement it as `DIP 3 { DUP }; DIG 3`. These are equivalent. Our version is supposedly cheaper, at least it should be packed more efficiently due to the way numbers are packed.

framedN :: forall n nNat s i i' o o'. (nNat ~ ToPeano n, i' ~ Take nNat i, s ~ Drop nNat i, i ~ (i' ++ s), o ~ (o' ++ s), KnownList i', KnownList o') => (i' :-> o') -> i :-> o Source #

Version of framed which accepts number of elements on input stack which should be preserved.

You can treat this macro as calling a Michelson function with given number of arguments.

caar :: (((a, b1), b2) & s) :-> (a & s) Source #

cadr :: (((a, b1), b2) & s) :-> (b1 & s) Source #

cdar :: ((a1, (a2, b)) & s) :-> (a2 & s) Source #

cddr :: ((a1, (a2, b)) & s) :-> (b & s) Source #

ifRight :: ((b & s) :-> s') -> ((a & s) :-> s') -> (Either a b & s) :-> s' Source #

ifSome :: ((a & s) :-> s') -> (s :-> s') -> (Maybe a & s) :-> s' Source #

when_ :: (s :-> s) -> (Bool ': s) :-> s Source #

unless_ :: (s :-> s) -> (Bool ': s) :-> s Source #

whenSome :: ((a ': s) :-> s) -> (Maybe a ': s) :-> s Source #

whenNone :: (s :-> (a ': s)) -> (Maybe a ': s) :-> (a ': s) Source #

mapCar :: ((a & s) :-> (a1 & s)) -> ((a, b) & s) :-> ((a1, b) & s) Source #

mapCdr :: ((b & ((a, b) & s)) :-> (b1 & ((a, b) & s))) -> ((a, b) & s) :-> ((a, b1) & s) Source #

papair :: (a & (b & (c & s))) :-> (((a, b), c) & s) Source #

ppaiir :: (a & (b & (c & s))) :-> ((a, (b, c)) & s) Source #

unpair :: ((a, b) & s) :-> (a & (b & s)) Source #

setCar :: ((a, b1) & (b2 & s)) :-> ((b2, b1) & s) Source #

setCdr :: ((a, b1) & (b2 & s)) :-> ((a, b2) & s) Source #

setInsert :: NiceComparable e => (e & (Set e & s)) :-> (Set e & s) Source #

Insert given element into set.

This is a separate function from updateMap because stacks they operate with differ in length.

mapInsert :: (MapInstrs map, NiceComparable k) => (k ': (v ': (map k v ': s))) :-> (map k v ': s) Source #

Insert given element into map.

setInsertNew :: (NiceComparable e, KnownValue err) => (forall s0. (e ': s0) :-> (err ': s0)) -> (e & (Set e & s)) :-> (Set e & s) Source #

Insert given element into set, ensuring that it does not overwrite any existing entry.

As first argument accepts container name.

mapInsertNew :: (MapInstrs map, NiceComparable k, KnownValue e) => (forall s0. (k ': s0) :-> (e ': s0)) -> (k ': (v ': (map k v ': s))) :-> (map k v ': s) Source #

Insert given element into map, ensuring that it does not overwrite any existing entry.

As first argument accepts container name (for error message).

deleteMap :: forall k v s. (MapInstrs map, NiceComparable k, KnownValue v) => (k ': (map k v ': s)) :-> (map k v ': s) Source #

Delete element from the map.

setDelete :: NiceComparable e => (e & (Set e & s)) :-> (Set e & s) Source #

Delete given element from the set.

replaceN :: forall (n :: Nat) a (s :: [Type]) (s1 :: [Type]) (tail :: [Type]). (ConstraintReplaceNLorentz (ToPeano (n - 1)) s a s1 tail, ReplaceN (ToPeano n) s a s1 tail) => (a ': s) :-> s Source #

Replace nth element (0-indexed) with the one on the top of the stack. For example, `replaceN 3` replaces the 3rd element with the 0th one. `replaceN 0` is not a valid operation (and it is not implemented). `replaceN 1` is equivalent to `swap # drop` (and is the only one implemented like this). In all other cases `replaceN n` will drop the nth element (`dipN n drop`) and then put the 0th one in its place (`dug (n-1)`).

updateN :: forall (n :: Nat) a b (s :: [Type]) (mid :: [Type]) (tail :: [Type]). (ConstraintUpdateNLorentz (ToPeano (n - 1)) s a b mid tail, UpdateN (ToPeano n) s a b mid tail) => ('[a, b] :-> '[b]) -> (a ': s) :-> s Source #

Replaces the nth element (0-indexed) with the result of the given "updating" instruction (binary with the return type equal to the second argument) applied to the 0th element and the nth element itself. For example, `updateN 3 cons` replaces the 3rd element with the result of cons applied to the topmost element and the 3rd one. `updateN 0 instr` is not a valid operation (and it is not implemented). `updateN 1 instr` is equivalent to instr (and so is implemented). `updateN 2 instr` is equivalent to `swap # dip instr` (and so is implemented). In all other cases `updateN n instr` will put the topmost element right above the nth one (`dug (n-1)`) and then apply the function to them in place (`dipN @(n-1) instr`).

Additional Morley macros

data View (a :: Type) (r :: Type) Source #

view type synonym as described in A1.

Constructors

View 

Instances

Instances details
(CanCastTo a1 a2, CanCastTo r1 r2) => CanCastTo (View a1 r1 :: Type) (View a2 r2 :: Type) Source # 
Instance details

Defined in Lorentz.Macro

Methods

castDummy :: Proxy (View a1 r1) -> Proxy (View a2 r2) -> () Source #

Eq a => Eq (View a r) Source # 
Instance details

Defined in Lorentz.Macro

Methods

(==) :: View a r -> View a r -> Bool #

(/=) :: View a r -> View a r -> Bool #

Show a => Show (View a r) Source # 
Instance details

Defined in Lorentz.Macro

Methods

showsPrec :: Int -> View a r -> ShowS #

show :: View a r -> String #

showList :: [View a r] -> ShowS #

Generic (View a r) Source # 
Instance details

Defined in Lorentz.Macro

Associated Types

type Rep (View a r) :: Type -> Type #

Methods

from :: View a r -> Rep (View a r) x #

to :: Rep (View a r) x -> View a r #

WellTypedIsoValue r => Buildable (View () r) Source # 
Instance details

Defined in Lorentz.Macro

Methods

build :: View () r -> Builder #

(Buildable a, WellTypedIsoValue r) => Buildable (View a r) Source # 
Instance details

Defined in Lorentz.Macro

Methods

build :: View a r -> Builder #

Each '[Typeable :: Type -> Constraint, TypeHasDoc] '[a, r] => TypeHasDoc (View a r) Source # 
Instance details

Defined in Lorentz.Macro

Associated Types

type TypeDocFieldDescriptions (View a r) :: FieldDescriptions #

Methods

typeDocName :: Proxy (View a r) -> Text #

typeDocMdDescription :: Markdown #

typeDocMdReference :: Proxy (View a r) -> WithinParens -> Markdown #

typeDocDependencies :: Proxy (View a r) -> [SomeDocDefinitionItem] #

typeDocHaskellRep :: TypeDocHaskellRep (View a r) #

typeDocMichelsonRep :: TypeDocMichelsonRep (View a r) #

(WellTypedIsoValue r, WellTypedIsoValue a) => IsoValue (View a r) Source # 
Instance details

Defined in Lorentz.Macro

Associated Types

type ToT (View a r) :: T #

Methods

toVal :: View a r -> Value (ToT (View a r)) #

fromVal :: Value (ToT (View a r)) -> View a r #

(HasAnnotation a, HasAnnotation r) => HasAnnotation (View a r) Source # 
Instance details

Defined in Lorentz.Macro

Methods

getAnnotation :: FollowEntrypointFlag -> Notes (ToT (View a r)) Source #

type Rep (View a r) Source # 
Instance details

Defined in Lorentz.Macro

type Rep (View a r) = D1 ('MetaData "View" "Lorentz.Macro" "lorentz-0.6.1-inplace" 'False) (C1 ('MetaCons "View" 'PrefixI 'True) (S1 ('MetaSel ('Just "viewParam") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "viewCallbackTo") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (ContractRef r))))
type TypeDocFieldDescriptions (View a r) Source # 
Instance details

Defined in Lorentz.Macro

type TypeDocFieldDescriptions (View a r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (View a r) Source # 
Instance details

Defined in Lorentz.Macro

type ToT (View a r) = GValueType (Rep (View a r))

data Void_ (a :: Type) (b :: Type) Source #

void type synonym as described in A1.

Constructors

Void_ 

Fields

Instances

Instances details
(CanCastTo a1 a2, CanCastTo r1 r2) => CanCastTo (Void_ a1 r1 :: Type) (Void_ a2 r2 :: Type) Source # 
Instance details

Defined in Lorentz.Macro

Methods

castDummy :: Proxy (Void_ a1 r1) -> Proxy (Void_ a2 r2) -> () Source #

Show a => Show (Void_ a b) Source # 
Instance details

Defined in Lorentz.Macro

Methods

showsPrec :: Int -> Void_ a b -> ShowS #

show :: Void_ a b -> String #

showList :: [Void_ a b] -> ShowS #

Generic (Void_ a b) Source # 
Instance details

Defined in Lorentz.Macro

Associated Types

type Rep (Void_ a b) :: Type -> Type #

Methods

from :: Void_ a b -> Rep (Void_ a b) x #

to :: Rep (Void_ a b) x -> Void_ a b #

Buildable a => Buildable (Void_ a b) Source # 
Instance details

Defined in Lorentz.Macro

Methods

build :: Void_ a b -> Builder #

Each '[Typeable :: Type -> Constraint, TypeHasDoc] '[a, r] => TypeHasDoc (Void_ a r) Source # 
Instance details

Defined in Lorentz.Macro

Associated Types

type TypeDocFieldDescriptions (Void_ a r) :: FieldDescriptions #

Methods

typeDocName :: Proxy (Void_ a r) -> Text #

typeDocMdDescription :: Markdown #

typeDocMdReference :: Proxy (Void_ a r) -> WithinParens -> Markdown #

typeDocDependencies :: Proxy (Void_ a r) -> [SomeDocDefinitionItem] #

typeDocHaskellRep :: TypeDocHaskellRep (Void_ a r) #

typeDocMichelsonRep :: TypeDocMichelsonRep (Void_ a r) #

(WellTypedIsoValue r, WellTypedIsoValue a) => IsoValue (Void_ a r) Source # 
Instance details

Defined in Lorentz.Macro

Associated Types

type ToT (Void_ a r) :: T #

Methods

toVal :: Void_ a r -> Value (ToT (Void_ a r)) #

fromVal :: Value (ToT (Void_ a r)) -> Void_ a r #

(HasAnnotation a, HasAnnotation b) => HasAnnotation (Void_ a b) Source # 
Instance details

Defined in Lorentz.Macro

Methods

getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Void_ a b)) Source #

type Rep (Void_ a b) Source # 
Instance details

Defined in Lorentz.Macro

type Rep (Void_ a b) = D1 ('MetaData "Void_" "Lorentz.Macro" "lorentz-0.6.1-inplace" 'False) (C1 ('MetaCons "Void_" 'PrefixI 'True) (S1 ('MetaSel ('Just "voidParam") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "voidResProxy") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Lambda b b))))
type TypeDocFieldDescriptions (Void_ a r) Source # 
Instance details

Defined in Lorentz.Macro

type TypeDocFieldDescriptions (Void_ a r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (Void_ a r) Source # 
Instance details

Defined in Lorentz.Macro

type ToT (Void_ a r) = GValueType (Rep (Void_ a r))

newtype VoidResult r Source #

Newtype over void result type used in tests to distinguish successful void result from other errors.

Usage example: lExpectFailWith (== VoidResult roleMaster)`

This error is special - it can contain arguments of different types depending on entrypoint which raises it.

Constructors

VoidResult 

Fields

Instances

Instances details
Eq r => Eq (VoidResult r) Source # 
Instance details

Defined in Lorentz.Macro

Methods

(==) :: VoidResult r -> VoidResult r -> Bool #

(/=) :: VoidResult r -> VoidResult r -> Bool #

Generic (VoidResult r) Source # 
Instance details

Defined in Lorentz.Macro

Associated Types

type Rep (VoidResult r) :: Type -> Type #

Methods

from :: VoidResult r -> Rep (VoidResult r) x #

to :: Rep (VoidResult r) x -> VoidResult r #

(TypeHasDoc r, IsError (VoidResult r)) => TypeHasDoc (VoidResult r) Source # 
Instance details

Defined in Lorentz.Macro

Associated Types

type TypeDocFieldDescriptions (VoidResult r) :: FieldDescriptions #

(WellTypedIsoValue (VoidResult r), TypeError ('Text "No IsoValue instance for VoidResult " :<>: 'ShowType r) :: Constraint) => IsoValue (VoidResult r) Source # 
Instance details

Defined in Lorentz.Macro

Associated Types

type ToT (VoidResult r) :: T #

TypeHasDoc r => ErrorHasDoc (VoidResult r) Source # 
Instance details

Defined in Lorentz.Macro

Associated Types

type ErrorRequirements (VoidResult r) Source #

(Typeable r, NiceConstant r, ErrorHasDoc (VoidResult r)) => IsError (VoidResult r) Source # 
Instance details

Defined in Lorentz.Macro

Methods

errorToVal :: VoidResult r -> (forall (t :: T). ErrorScope t => Value t -> r0) -> r0 Source #

errorFromVal :: forall (t :: T). KnownT t => Value t -> Either Text (VoidResult r) Source #

type Rep (VoidResult r) Source # 
Instance details

Defined in Lorentz.Macro

type Rep (VoidResult r) = D1 ('MetaData "VoidResult" "Lorentz.Macro" "lorentz-0.6.1-inplace" 'True) (C1 ('MetaCons "VoidResult" 'PrefixI 'True) (S1 ('MetaSel ('Just "unVoidResult") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 r)))
type TypeDocFieldDescriptions (VoidResult r) Source # 
Instance details

Defined in Lorentz.Macro

type ToT (VoidResult r) Source # 
Instance details

Defined in Lorentz.Macro

type ToT (VoidResult r) = TypeError ('Text "No IsoValue instance for VoidResult " :<>: 'ShowType r) :: T
type ErrorRequirements (VoidResult r) Source # 
Instance details

Defined in Lorentz.Macro

view_ :: NiceParameter r => (forall s0. (a & (storage & s0)) :-> (r ': s0)) -> (View a r & (storage & s)) :-> ((List Operation, storage) & s) Source #

mkView :: ToContractRef r contract => a -> contract -> View a r Source #

Polymorphic version of View constructor.

wrapView :: ((a, ContractRef r) ': s) :-> (View a r ': s) Source #

Wrap internal representation of view into View itself.

View is part of public standard and should not change often.

unwrapView :: (View a r ': s) :-> ((a, ContractRef r) ': s) Source #

Unwrap View into its internal representation.

View is part of public standard and should not change often.

void_ :: forall a b s s' anything. (IsError (VoidResult b), KnownValue b) => ((a & s) :-> (b & s')) -> (Void_ a b & s) :-> anything Source #

mkVoid :: forall b a. a -> Void_ a b Source #

wrapVoid :: ((a, Lambda b b) ': s) :-> (Void_ a b ': s) Source #

Wrap internal representation of void into Void_ itself.

Void_ is part of public standard and should not change often.

unwrapVoid :: (Void_ a b ': s) :-> ((a, Lambda b b) ': s) Source #

Unwrap Void_ into its internal representation.

Void_ is part of public standard and should not change often.

Buildable utils for additional Morley macros

Macros for working with address and contract-like types

pushContractRef :: NiceParameter arg => (forall s0. (FutureContract arg ': s) :-> s0) -> ContractRef arg -> s :-> (ContractRef arg ': s) Source #

Push a value of contract type.

Doing this via push instruction is not possible, so we need to perform extra actions here.

Aside from contract value itself you will need to specify which error to throw in case this value is not valid.