Lorentz.Macro

Common Michelson macros defined using Lorentz syntax.

Compare

type IfCmpXConstraints a b op = (Typeable a, Typeable b, ArithOpHs Compare a b, UnaryArithOpHs op (ArithResHs Compare a b), UnaryArithResHs op (ArithResHs Compare a b) ~ Bool)

eq :: (ArithOpHs Compare n m, UnaryArithOpHs Eq' (ArithResHs Compare n m)) => (n & (m & s)) :-> (UnaryArithResHs Eq' (ArithResHs Compare n m) & s)

neq :: (ArithOpHs Compare n m, UnaryArithOpHs Neq (ArithResHs Compare n m)) => (n & (m & s)) :-> (UnaryArithResHs Neq (ArithResHs Compare n m) & s)

lt :: (ArithOpHs Compare n m, UnaryArithOpHs Lt (ArithResHs Compare n m)) => (n & (m & s)) :-> (UnaryArithResHs Lt (ArithResHs Compare n m) & s)

gt :: (ArithOpHs Compare n m, UnaryArithOpHs Gt (ArithResHs Compare n m)) => (n & (m & s)) :-> (UnaryArithResHs Gt (ArithResHs Compare n m) & s)

le :: (ArithOpHs Compare n m, UnaryArithOpHs Le (ArithResHs Compare n m)) => (n & (m & s)) :-> (UnaryArithResHs Le (ArithResHs Compare n m) & s)

ge :: (ArithOpHs Compare n m, UnaryArithOpHs Ge (ArithResHs Compare n m)) => (n & (m & s)) :-> (UnaryArithResHs Ge (ArithResHs Compare n m) & 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 :: IfCmpXConstraints a b Eq' => (s :-> s') -> (s :-> s') -> (a & (b & s)) :-> s'

ifGe :: IfCmpXConstraints a b Ge => (s :-> s') -> (s :-> s') -> (a & (b & s)) :-> s'

ifGt :: IfCmpXConstraints a b Gt => (s :-> s') -> (s :-> s') -> (a & (b & s)) :-> s'

ifLe :: IfCmpXConstraints a b Le => (s :-> s') -> (s :-> s') -> (a & (b & s)) :-> s'

ifLt :: IfCmpXConstraints a b Lt => (s :-> s') -> (s :-> s') -> (a & (b & s)) :-> s'

ifNeq :: IfCmpXConstraints a b Neq => (s :-> s') -> (s :-> s') -> (a & (b & 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 empty string, then FAILWITH will be called with unit, not empty string.

assert :: MText -> (Bool & s) :-> s

assertEq0 :: IfCmp0Constraints a Eq' => MText -> (a & s) :-> s

assertNeq0 :: IfCmp0Constraints a Neq => MText -> (a & s) :-> s

assertLt0 :: IfCmp0Constraints a Lt => MText -> (a & s) :-> s

assertGt0 :: IfCmp0Constraints a Gt => MText -> (a & s) :-> s

assertLe0 :: IfCmp0Constraints a Le => MText -> (a & s) :-> s

assertGe0 :: IfCmp0Constraints a Ge => MText -> (a & s) :-> s

assertEq :: IfCmpXConstraints a b Eq' => MText -> (a & (b & s)) :-> s

assertNeq :: IfCmpXConstraints a b Neq => MText -> (a & (b & s)) :-> s

assertLt :: IfCmpXConstraints a b Lt => MText -> (a & (b & s)) :-> s

assertGt :: IfCmpXConstraints a b Gt => MText -> (a & (b & s)) :-> s

assertLe :: IfCmpXConstraints a b Le => MText -> (a & (b & s)) :-> s

assertGe :: IfCmpXConstraints a b Ge => MText -> (a & (b & s)) :-> s

assertNone :: MText -> (Maybe a & s) :-> s

assertSome :: MText -> (Maybe a & s) :-> (a & s)

assertLeft :: MText -> (Either a b & s) :-> (a & s)

assertRight :: MText -> (Either a b & s) :-> (b & s)

assertUsing :: (IsoValue a, KnownValue a, NoOperation a, NoBigMap a) => a -> (Bool & s) :-> s

Syntactic Conveniences

dipX :: forall (n :: Nat) inp out s s'. (DipX (ToPeano n) (Above (ToPeano n) inp) s s', (Above (ToPeano n) inp ++ s) ~ inp, (Above (ToPeano n) inp ++ s') ~ out) => (s :-> s') -> inp :-> out

DII+P macro. For example, `dipX @3` is DIIIP.

dropX :: forall (n :: Nat) a inp out s s'. (DipX (ToPeano n) (Above (ToPeano n) inp) s s', (Above (ToPeano n) inp ++ s) ~ inp, (Above (ToPeano n) inp ++ s') ~ out, s ~ (a ': s')) => 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) :-> 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) inp. DuupX (ToPeano n) inp (At (ToPeano (n - 1)) inp) => inp :-> (At (ToPeano (n - 1)) inp & inp)

DUU+P macro. For example, `duupX @3` is DUUUP, it puts the 3-rd (starting from 1) element to the top of the stack.

elevateX :: forall (n :: Nat) inp out s a. (DuupX (ToPeano (1 + n)) inp a, DipX (ToPeano (n + 1)) (Above (ToPeano (n + 1)) (a ': inp)) (a ': s) s, (a ': (Above (ToPeano n) inp ++ s)) ~ out, a ~ At (ToPeano n) inp, (Above (ToPeano (n + 1)) (a ': inp) ++ (a ': s)) ~ (a ': inp), (Above (ToPeano (n + 1)) (a ': inp) ++ s) ~ (a ': (Above (ToPeano n) inp ++ s)), ((1 + n) - 1) ~ n) => inp :-> out

Move item with given index (starting from 0) to the top of the stack.

TODO: probably it can be implemented more efficiently, so if we ever want to optimize gas consumption we can rewrite it. It only makes sense if it's applied to a relatively large index.

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

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

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

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

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

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

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

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

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

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

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

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

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

setInsert :: IsComparable e => (e & (Set e & s)) :-> (Set e & s)

Insert given element into set.

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

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

Insert given element into map.

setInsertNew :: (IsComparable e, KnownValue err) => (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, IsComparable k, KnownValue e) => (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, IsComparable k, KnownValue k, KnownValue v) => (k ': (map k v ': s)) :-> (map k v ': s)

Delete element from the map.

setDelete :: IsComparable e => (e & (Set e & s)) :-> (Set e & s)

Delete given element from the set.

Additional Morley macros

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

view type synonym as described in A1.

Constructors

View

Fields

• viewParam :: a
• viewCallbackTo :: ContractAddr (a, Maybe r)

Instances

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

IsoValue 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" "morley-0.3.0.1-Avb9bjjqJWNEobyGi9OGAh" False) (C1 (MetaCons "View" PrefixI True) (S1 (MetaSel (Just "viewParam") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "viewCallbackTo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ContractAddr (a, Maybe r)))))

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

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

IsoValue a => IsoValue (Void_ a b)

Defined in Lorentz.Macro

Associated Types

type ToT (Void_ a b) :: T

Methods

toVal :: Void_ a b -> Value (ToT (Void_ a b))

fromVal :: Value (ToT (Void_ a b)) -> Void_ a b

type Rep (Void_ a b)

Defined in Lorentz.Macro

type Rep (Void_ a b) = D1 (MetaData "Void_" "Lorentz.Macro" "morley-0.3.0.1-Avb9bjjqJWNEobyGi9OGAh" False) (C1 (MetaCons "Void_" PrefixI True) (S1 (MetaSel (Just "voidParam") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "voidResProxy") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Lambda b b))))

type ToT (Void_ a b)

Defined in Lorentz.Macro

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

newtype VoidResult r

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

Usage example: lExpectFailWith (== VoidResult roleMaster)`

Constructors

VoidResult

Fields

• unVoidResult :: r

Instances

Eq r => Eq (VoidResult r)

Defined in Lorentz.Macro

Methods

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

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

IsoValue r => 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 ToT (VoidResult r)

Defined in Lorentz.Macro

type ToT (VoidResult r) = ToT r

view_ :: (KnownValue a, KnownValue r, NoOperation (a, r), NoBigMap (a, r)) => (forall s0. ((a, storage) & s0) :-> (r ': s0)) -> (View a r & (storage & s)) :-> ((List Operation, storage) & s)

void_ :: forall a b s s' anything. KnownValue b => ((a & s) :-> (b & s')) -> (Void_ a b & s) :-> anything

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