Lorentz.Macro

Common Michelson macros defined using Lorentz syntax.

Compare

type NiceComparable n = (ProperNonComparableValBetterErrors (ToT n), KnownValue n, Comparable (ToT n))

Constraint applied to any type, to check if Michelson representation (if exists) of this type is Comparable. In case it is not prints human-readable error message

eq :: NiceComparable n => (n ': (n ': s)) :-> (Bool ': s)

neq :: NiceComparable n => (n ': (n ': s)) :-> (Bool ': s)

lt :: NiceComparable n => (n ': (n ': s)) :-> (Bool ': s)

gt :: NiceComparable n => (n ': (n ': s)) :-> (Bool ': s)

le :: NiceComparable n => (n ': (n ': s)) :-> (Bool ': s)

ge :: NiceComparable n => (n ': (n ': s)) :-> (Bool ': s)

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

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

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

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

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

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

ifEq :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a ': (a ': s)) :-> s'

ifGe :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a ': (a ': s)) :-> s'

ifGt :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a ': (a ': s)) :-> s'

ifLe :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a ': (a ': s)) :-> s'

ifLt :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a ': (a ': s)) :-> s'

ifNeq :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a ': (a ': s)) :-> s'

Fail

fail_ :: a :-> c

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

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

assertNeq0 :: (IfCmp0Constraints a Neq, IsError err) => err -> (a ': s) :-> s

assertLt0 :: (IfCmp0Constraints a Lt, IsError err) => err -> (a ': s) :-> s

assertGt0 :: (IfCmp0Constraints a Gt, IsError err) => err -> (a ': s) :-> s

assertLe0 :: (IfCmp0Constraints a Le, IsError err) => err -> (a ': s) :-> s

assertGe0 :: (IfCmp0Constraints a Ge, IsError err) => err -> (a ': s) :-> s

assertEq :: (NiceComparable a, IsError err) => err -> (a ': (a ': s)) :-> s

assertNeq :: (NiceComparable a, IsError err) => err -> (a ': (a ': s)) :-> s

assertLt :: (NiceComparable a, IsError err) => err -> (a ': (a ': s)) :-> s

assertGt :: (NiceComparable a, IsError err) => err -> (a ': (a ': s)) :-> s

assertLe :: (NiceComparable a, IsError err) => err -> (a ': (a ': s)) :-> s

assertGe :: (NiceComparable a, IsError err) => err -> (a ': (a ': s)) :-> s

assertNone :: IsError err => err -> (Maybe a ': s) :-> s

assertSome :: IsError err => err -> (Maybe a ': s) :-> (a ': s)

assertLeft :: IsError err => err -> (Either a b ': s) :-> (a ': s)

assertRight :: IsError err => err -> (Either a b ': s) :-> (b ': s)

assertUsing :: IsError a => a -> (Bool ': s) :-> s

Syntactic Conveniences

type ErrInstr s = forall serr. s :-> serr

An instruction that always fails.

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)

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)

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

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

Methods

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

Instances

s ~ (a ': xs) => ReplaceN ('S 'Z) s a (mid :: k1) (tail :: k2)

Defined in Lorentz.Macro

Methods

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

(ConstraintReplaceNLorentz ('S n) s a mid tail, SingI n) => ReplaceN ('S ('S n)) s a (mid :: [Type]) (tail :: [Type])

Defined in Lorentz.Macro

Methods

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

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

Methods

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

Instances

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

Defined in Lorentz.Macro

Methods

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

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

Defined in Lorentz.Macro

Methods

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

(ConstraintUpdateNLorentz ('S ('S n)) s a b mid tail, SingI n) => UpdateN ('S ('S ('S n))) s a b (mid :: [Type]) (tail :: [Type])

Defined in Lorentz.Macro

Methods

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

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

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) :-> (a ': CloneXT (ToPeano n) a s)

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 s'. (ConstraintDUPNLorentz (ToPeano n) s s' a, Dupable a) => s :-> (a ': s)

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 DUU+P has since been added as the DUP n instruction and so this macro is defined simply as follows:

duupX = dupN @n

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

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.

Given a stack of 3 elements, >>> arg = (1 :: Integer) ::: (2 :: Integer) ::: (3 :: Integer)

framedN will have access to exactly the number of elements specified, >>> framedN 1 drop -$ arg 2 ::: 3 >>> framedN 1 (drop # drop) -$ arg ... ... error: ... Couldn't match type: '[] ... with: a0 : o'0 ...

When the number of elements is larger than the size of the stack, framedN will have access to all of them: >>> framedN @5 (drop # drop) -$ arg 3

But not more than there are on stack: >>> framedN @5 (drop # drop # drop # drop) -$ arg ... ... error: ... Couldn't match type ‘ZippedStackRepr a1 (ZippedStackRepr a0 out)’ ... with ‘Integer’ ...

carN :: forall (n :: Nat) (pair :: Type) (s :: [Type]). ConstraintPairGetLorentz ((2 * n) + 1) pair => (pair ': s) :-> (PairGetHs (ToPeano ((2 * n) + 1)) pair ': s)

cdrN :: forall (n :: Nat) (pair :: Type) (s :: [Type]). ConstraintPairGetLorentz (2 * n) pair => (pair ': s) :-> (PairGetHs (ToPeano (2 * n)) pair ': s)

caar :: (((a, b1), b2) ': s) :-> (a ': s)

>>> caar == car # car
True

>>> caar -$ ((True, 1), ())
True

cadr :: (((a, b1), b2) ': s) :-> (b1 ': s)

>>> cadr == car # cdr
True

>>> cadr -$ ((True, 1), ())
1

cdar :: ((a1, (a2, b)) ': s) :-> (a2 ': s)

>>> cdar == cdr # car
True

>>> cdar -$ (True, (1, ()))
1

cddr :: ((a1, (a2, b)) ': s) :-> (b ': s)

>>> cddr == cdr # cdr
True

>>> cddr -$ (True, (1, ()))
()

ifRight :: ((b ': s) :-> s') -> ((a ': s) :-> s') -> (Either a b ': s) :-> s'

>>> ifRight (not @Bool) (dup @Integer # compare # eq0) == ifLeft (dup @Integer # compare # eq0) (not @Bool)
True

>>> ifRight not (dup # compare # eq0) -$ (Right True :: Either Integer Bool)
False

>>> ifRight not (dup # compare # eq0) -$ (Left 1 :: Either Integer Bool)
True

ifSome :: ((a ': s) :-> s') -> (s :-> s') -> (Maybe a ': s) :-> s'

>>> ifSome (dup @Integer # compare # eq0) (push False) == ifNone (push False) (dup @Integer # compare # eq0)
True

>>> ifSome (dup # compare # eq0) (push False) -$ (Just 1 :: Maybe Integer)
True

>>> ifSome (dup # compare # eq0) (push False) -$ (Nothing :: Maybe Integer)
False

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

>>> when_ (push 5 # add @Integer @Integer) == if_ (push 5 # add @Integer @Integer) nop
True

>>> when_ (push 5 # add @Integer) -$ True ::: 3
8

>>> when_ (push 5 # add @Integer) -$ False ::: 3
3

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

>>> unless_ (push 5 # add @Integer @Integer) == if_ nop (push 5 # add @Integer @Integer)
True

>>> unless_ (push 5 # add @Integer) -$ True ::: 3
3

>>> unless_ (push 5 # add @Integer) -$ False ::: 3
8

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

>>> whenSome drop == ifSome drop nop
True

>>> whenSome drop -$ Just 1 ::: ()
()

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

>>> whenNone (push True) == ifNone (push True) nop
True

>>> whenNone (push 1) -$ (Nothing :: Maybe Integer)
1

mapCar :: (forall s0. (a ': s0) :-> (a1 ': s0)) -> ((a, b) ': s) :-> ((a1, b) ': s)

>>> mapCar (not @Bool) == unpair # (not @Bool) # pair
True

>>> mapCar not -$ (True, 1)
(False,1)

mapCdr :: (forall s0. (b ': s0) :-> (b1 ': s0)) -> ((a, b) ': s) :-> ((a, b1) ': s)

>>> mapCdr (not @Bool) == unpair # dip (not @Bool) # pair
True

>>> mapCdr not -$ (1, True)
(1,False)

papair :: (a ': (b ': (c ': s))) :-> (((a, b), c) ': s)

>>> papair == pair # pair
True

>>> papair -$ True ::: 1 ::: ()
((True,1),())

ppaiir :: (a ': (b ': (c ': s))) :-> ((a, (b, c)) ': s)

>>> ppaiir == dip pair # pair
True

>>> ppaiir -$ True ::: 1 ::: ()
(True,(1,()))

unpair :: ((a, b) ': s) :-> (a ': (b ': s))

setCar :: ((a, b1) ': (b2 ': s)) :-> ((b2, b1) ': s)

>>> setCar == cdr # swap # pair
True

>>> setCar -$ (True, 1) ::: ()
((),1)

setCdr :: ((a, b1) ': (b2 ': s)) :-> ((a, b2) ': s)

>>> setCdr == car # pair
True

>>> setCdr -$ (True, 1) ::: ()
(True,())

setInsert :: NiceComparable e => (e ': (Set e ': s)) :-> (Set e ': s)

Insert given element into set.

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

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

Insert given element into map.

setInsertNew :: (NiceConstant err, NiceComparable e, Dupable e, Dupable (Set e)) => (forall s0. (e ': s0) :-> (err ': s0)) -> (e ': (Set e ': s)) :-> (Set e ': s)

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

As first argument accepts container name.

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

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)

Delete element from the map.

setDelete :: NiceComparable e => (e ': (Set e ': s)) :-> (Set e ': s)

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

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

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)

view type synonym as described in A1.

Constructors

View_

Fields

• viewParam :: a
• viewCallbackTo :: ContractRef r

Instances

(CanCastTo a1 a2, CanCastTo r1 r2) => CanCastTo (View_ a1 r1 :: Type) (View_ a2 r2 :: Type)

Defined in Lorentz.Macro

Methods

castDummy :: Proxy (View_ a1 r1) -> Proxy (View_ a2 r2) -> ()

Generic (View_ a r)

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

Show a => Show (View_ a r)

Defined in Lorentz.Macro

Methods

showsPrec :: Int -> View_ a r -> ShowS

show :: View_ a r -> String

showList :: [View_ a r] -> ShowS

(HasNoOpToT r, HasNoNestedBigMaps (ToT r)) => Buildable (View_ () r)

Defined in Lorentz.Macro

Methods

build :: View_ () r -> Builder

(Buildable a, HasNoOpToT r, HasNoNestedBigMaps (ToT r)) => Buildable (View_ a r)

Defined in Lorentz.Macro

Methods

build :: View_ a r -> Builder

Eq a => Eq (View_ a r)

Defined in Lorentz.Macro

Methods

(==) :: View_ a r -> View_ a r -> Bool

(/=) :: View_ a r -> View_ a r -> Bool

(HasAnnotation a, HasAnnotation r) => HasAnnotation (View_ a r)

Defined in Lorentz.Macro

Methods

getAnnotation :: FollowEntrypointFlag -> Notes (ToT (View_ a r))

annOptions :: Maybe AnnOptions

HasRPCRepr a => HasRPCRepr (View_ a r)

Defined in Lorentz.Macro

Associated Types

type AsRPC (View_ a r)

Each '[Typeable :: Type -> Constraint, TypeHasDoc] '[a, r] => TypeHasDoc (View_ a r)

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)

(HasNoOpToT r, HasNoNestedBigMaps (ToT r), WellTypedToT a) => IsoValue (View_ a r)

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

type Rep (View_ a r)

Defined in Lorentz.Macro

type Rep (View_ a r) = D1 ('MetaData "View_" "Lorentz.Macro" "lorentz-0.15.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 AsRPC (View_ a r)

Defined in Lorentz.Macro

type AsRPC (View_ a r) = View_ (AsRPC a) r

type TypeDocFieldDescriptions (View_ a r)

Defined in Lorentz.Macro

type TypeDocFieldDescriptions (View_ a r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]

type ToT (View_ a r)

Defined in Lorentz.Macro

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

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

void type synonym as described in A1.

Constructors

Void_

Fields

• voidParam :: a

  Entry point argument.

• voidResProxy :: Lambda b b

  Type of result reported via failWith.

Instances

(CanCastTo a1 a2, CanCastTo r1 r2) => CanCastTo (Void_ a1 r1 :: Type) (Void_ a2 r2 :: Type)

Defined in Lorentz.Macro

Methods

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

Generic (Void_ a b)

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

Show a => Show (Void_ a b)

Defined in Lorentz.Macro

Methods

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

show :: Void_ a b -> String

showList :: [Void_ a b] -> ShowS

Buildable a => Buildable (Void_ a b)

Defined in Lorentz.Macro

Methods

build :: Void_ a b -> Builder

(HasAnnotation a, HasAnnotation b) => HasAnnotation (Void_ a b)

Defined in Lorentz.Macro

Methods

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

annOptions :: Maybe AnnOptions

HasRPCRepr a => HasRPCRepr (Void_ a r)

Defined in Lorentz.Macro

Associated Types

type AsRPC (Void_ a r)

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

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)

(WellTypedToT r, WellTypedToT a) => IsoValue (Void_ a r)

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

type Rep (Void_ a b)

Defined in Lorentz.Macro

type Rep (Void_ a b) = D1 ('MetaData "Void_" "Lorentz.Macro" "lorentz-0.15.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 AsRPC (Void_ a r)

Defined in Lorentz.Macro

type AsRPC (Void_ a r) = Void_ (AsRPC a) r

type TypeDocFieldDescriptions (Void_ a r)

Defined in Lorentz.Macro

type TypeDocFieldDescriptions (Void_ a r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]

type ToT (Void_ a r)

Defined in Lorentz.Macro

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

newtype VoidResult r

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

• unVoidResult :: r

Instances

Generic (VoidResult r)

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

Eq r => Eq (VoidResult r)

Defined in Lorentz.Macro

Methods

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

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

TypeHasDoc r => ErrorHasDoc (VoidResult r)

Defined in Lorentz.Macro

Associated Types

type ErrorRequirements (VoidResult r)

Methods

errorDocName :: Text

errorDocMdCause :: Markdown

errorDocMdCauseInEntrypoint :: Markdown

errorDocHaskellRep :: Markdown

errorDocClass :: ErrorClass

errorDocDependencies :: [SomeDocDefinitionItem]

errorDocRequirements :: Dict (ErrorRequirements (VoidResult r))

(NiceConstant r, ErrorHasDoc (VoidResult r)) => IsError (VoidResult r)

Defined in Lorentz.Macro

Methods

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

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

failUsing :: forall (s :: [Type]) (t :: [Type]). IsError (VoidResult r) => VoidResult r -> s :-> t

(TypeHasDoc r, IsError (VoidResult r)) => TypeHasDoc (VoidResult r)

Defined in Lorentz.Macro

Associated Types

type TypeDocFieldDescriptions (VoidResult r) :: FieldDescriptions

Methods

typeDocName :: Proxy (VoidResult r) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (VoidResult r) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (VoidResult r) -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep (VoidResult r)

typeDocMichelsonRep :: TypeDocMichelsonRep (VoidResult r)

(Bottom, WellTypedToT (VoidResult r), TypeError ('Text "No IsoValue instance for VoidResult " :<>: 'ShowType r) :: Constraint) => IsoValue (VoidResult r)

Defined in Lorentz.Macro

Associated Types

type ToT (VoidResult r) :: T

Methods

toVal :: VoidResult r -> Value (ToT (VoidResult r))

fromVal :: Value (ToT (VoidResult r)) -> VoidResult r

type Rep (VoidResult r)

Defined in Lorentz.Macro

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

type ErrorRequirements (VoidResult r)

Defined in Lorentz.Macro

type ErrorRequirements (VoidResult r) = ()

type TypeDocFieldDescriptions (VoidResult r)

Defined in Lorentz.Macro

type TypeDocFieldDescriptions (VoidResult r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]

type ToT (VoidResult r)

Defined in Lorentz.Macro

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

view_ :: (NiceParameter r, Dupable storage, IsNotInView) => (forall s0. (a ': (storage ': s0)) :-> (r ': s0)) -> (View_ a r ': (storage ': s)) :-> ((List Operation, storage) ': s)

mkView_ :: ToContractRef r contract => a -> contract -> View_ a r

Polymorphic version of View_ constructor.

wrapView_ :: ((a, ContractRef r) ': s) :-> (View_ a r ': s)

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)

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), NiceConstant b) => ((a ': s) :-> (b ': s')) -> (Void_ a b ': s) :-> anything

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

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

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)

Unwrap Void_ into its internal representation.

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

voidResultTag :: MText

dupTop2 :: forall (a :: Type) (b :: Type) (s :: [Type]). (Dupable a, Dupable b) => (a ': (b ': s)) :-> (a ': (b ': (a ': (b ': s))))

Duplicate two topmost items on top of the stack.

fromOption :: NiceConstant a => a -> (Maybe a ': s) :-> (a ': s)

isSome :: (Maybe a ': s) :-> (Bool ': s)

non :: (NiceConstant a, NiceComparable a) => a -> (a ': s) :-> (Maybe a ': s)

Retain the value if it is not equal to the given one.

>>> non 0 -$ 5
Just 5
>>> non 0 -$ 0
Nothing

non' :: NiceConstant a => ('[a] :-> '[Bool]) -> (a ': s) :-> (Maybe a ': s)

Version of non with a custom predicate.

>>> non' eq0 -$ 5
Just 5
>>> non' eq0 -$ 0
Nothing

isEmpty :: SizeOpHs c => (c ': s) :-> (Bool ': s)

Check whether container is empty.

class NonZero t where

Methods

nonZero :: (t ': s) :-> (Maybe t ': s)

Retain the value only if it is not zero.

Instances

NonZero Integer

Defined in Lorentz.Macro

Methods

nonZero :: forall (s :: [Type]). (Integer ': s) :-> (Maybe Integer ': s)

NonZero Natural

Defined in Lorentz.Macro

Methods

nonZero :: forall (s :: [Type]). (Natural ': s) :-> (Maybe Natural ': s)

NiceComparable d => NonZero (Ticket d)

Defined in Lorentz.Macro

Methods

nonZero :: forall (s :: [Type]). (Ticket d ': s) :-> (Maybe (Ticket d) ': s)

(NiceComparable d, Typeable k, Typeable action) => NonZero (STicket action d)

Defined in Lorentz.Tickets

Methods

nonZero :: forall (s :: [Type]). (STicket action d ': s) :-> (Maybe (STicket action d) ': s)

Buildable utils for additional Morley macros

buildView_ :: (HasNoOpToT r, HasNoNestedBigMaps (ToT r)) => (a -> Builder) -> View_ a r -> Builder

buildViewTuple_ :: (HasNoOpToT r, HasNoNestedBigMaps (ToT r), TupleF a) => View_ a r -> Builder

Macros for working with address and contract-like types

addressToEpAddress :: (Address ': s) :-> (EpAddress ': s)

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

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.

selfAddress :: s :-> (Address ': s)

view :: forall name arg ret p vd s. (HasCallStack, KnownSymbol name, KnownValue arg, NiceViewable ret, HasView vd name arg ret) => (arg ': (TAddress p vd ': s)) :-> (ret ': s)

Call a view.

Accepts the view name via a type annotation. This internally asserts the view to be present, as if the supplied TAddress argument is valid, the view is guaranteed to be called successfully.

Integer division

data IDiv

Michelson supports only EDiv, which gives both the quotient and the remainder for integers. For convenience, we also offer IDiv, which gives just the quotient.

Instances

(ArithOpHs EDiv n d (Maybe (q, r)), mq ~ Maybe q, KnownValue q) => ArithOpHs IDiv n d mq

Defined in Lorentz.Macro

Methods

evalArithOpHs :: forall (s :: [Type]). (n ': (d ': s)) :-> (mq ': s)

data IMod

Michelson supports only EDiv, which gives both the quotient and the remainder for integers. For convenience, we also offer IMod, which gives just the remainder.

Instances

(ArithOpHs EDiv n d (Maybe (q, r)), mr ~ Maybe r, KnownValue r) => ArithOpHs IMod n d mr

Defined in Lorentz.Macro

Methods

evalArithOpHs :: forall (s :: [Type]). (n ': (d ': s)) :-> (mr ': s)

idiv :: ArithOpHs IDiv n d q => (n ': (d ': s)) :-> (q ': s)

Integer division.

>>> idiv -$ (5 :: Integer) ::: (2 :: Integer)
Just 2

>>> idiv -$ (5 :: Integer) ::: (0 :: Integer)
Nothing

imod :: ArithOpHs IMod n d r => (n ': (d ': s)) :-> (r ': s)

Integer modulus.

>>> imod -$ (5 :: Integer) ::: (2 :: Integer)
Just 1

>>> imod -$ (5 :: Integer) ::: (0 :: Integer)
Nothing

Orphan instances

CustomErrorHasDoc "no_view"

Methods

customErrDocMdCause :: Markdown

customErrDocMdCauseInEntrypoint :: Markdown

customErrClass :: ErrorClass

customErrArgumentSemantics :: Maybe Markdown