| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Lorentz.Macro
Contents
Description
Common Michelson macros defined using Lorentz syntax.
Synopsis
- type IfCmpXConstraints a op = (Typeable a, ArithOpHs Compare a a, UnaryArithOpHs op (ArithResHs Compare a a), UnaryArithResHs op (ArithResHs Compare a a) ~ Bool)
- eq :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Eq' (ArithResHs Compare n n) & s)
- neq :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Neq (ArithResHs Compare n n) & s)
- lt :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Lt (ArithResHs Compare n n) & s)
- gt :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Gt (ArithResHs Compare n n) & s)
- le :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Le (ArithResHs Compare n n) & s)
- ge :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Ge (ArithResHs Compare n n) & 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 Eq' => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s'
- ifGe :: IfCmpXConstraints a Ge => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s'
- ifGt :: IfCmpXConstraints a Gt => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s'
- ifLe :: IfCmpXConstraints a Le => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s'
- ifLt :: IfCmpXConstraints a Lt => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s'
- ifNeq :: IfCmpXConstraints a Neq => (s :-> s') -> (s :-> s') -> (a & (a & s)) :-> s'
- fail_ :: a :-> c
- 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 :: (IfCmpXConstraints a Eq', IsError err) => err -> (a & (a & s)) :-> s
- assertNeq :: (IfCmpXConstraints a Neq, IsError err) => err -> (a & (a & s)) :-> s
- assertLt :: (IfCmpXConstraints a Lt, IsError err) => err -> (a & (a & s)) :-> s
- assertGt :: (IfCmpXConstraints a Gt, IsError err) => err -> (a & (a & s)) :-> s
- assertLe :: (IfCmpXConstraints a Le, IsError err) => err -> (a & (a & s)) :-> s
- assertGe :: (IfCmpXConstraints a Ge, 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
- dropX :: forall (n :: Nat) a inp out s s'. (ConstraintDIPNLorentz (ToPeano n) inp out s s', s ~ (a ': s')) => inp :-> out
- cloneX :: forall (n :: Nat) a s. CloneX (ToPeano n) a s => (a & s) :-> CloneXT (ToPeano n) 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)
- 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
- 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)
- mapInsert :: (MapInstrs map, IsComparable k) => (k ': (v ': (map k v ': s))) :-> (map k v ': s)
- setInsertNew :: (IsComparable e, KnownValue err) => (forall s0. (e ': s0) :-> (err ': s0)) -> (e & (Set e & s)) :-> (Set e & s)
- mapInsertNew :: (MapInstrs map, IsComparable k, KnownValue e) => (forall s0. (k ': s0) :-> (e ': s0)) -> (k ': (v ': (map k v ': s))) :-> (map k v ': s)
- deleteMap :: forall k v s. (MapInstrs map, IsComparable k, KnownValue k, KnownValue v) => (k ': (map k v ': s)) :-> (map k v ': s)
- setDelete :: IsComparable e => (e & (Set e & s)) :-> (Set e & s)
- data View (a :: Type) (r :: Type) = View {
- viewParam :: a
- viewCallbackTo :: ContractRef r
- data Void_ (a :: Type) (b :: Type) = Void_ {
- voidParam :: a
- voidResProxy :: Lambda b b
- newtype VoidResult r = VoidResult {
- unVoidResult :: r
- view_ :: NiceParameter r => (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
- void_ :: forall a b s s' anything. (IsError (VoidResult b), KnownValue b) => ((a & s) :-> (b & s')) -> (Void_ a b & s) :-> anything
- mkVoid :: forall b a. a -> Void_ a b
- buildView :: (a -> Builder) -> View a r -> Builder
- buildViewTuple :: TupleF a => View a r -> Builder
- pushContractRef :: NiceParameter arg => (forall s0. (Address ': s) :-> s0) -> ContractRef arg -> s :-> (ContractRef arg ': s)
- pickFutureContract :: NiceParameter p => (FutureContract p ': s) :-> (Maybe (ContractRef p) ': s)
Compare
type IfCmpXConstraints a op = (Typeable a, ArithOpHs Compare a a, UnaryArithOpHs op (ArithResHs Compare a a), UnaryArithResHs op (ArithResHs Compare a a) ~ Bool) Source #
eq :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Eq' (ArithResHs Compare n n) & s) Source #
neq :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Neq (ArithResHs Compare n n) & s) Source #
lt :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Lt (ArithResHs Compare n n) & s) Source #
gt :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Gt (ArithResHs Compare n n) & s) Source #
le :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Le (ArithResHs Compare n n) & s) Source #
ge :: ArithOpHs Compare n n => (n & (n & s)) :-> (UnaryArithResHs Ge (ArithResHs Compare n n) & s) Source #
Fail
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.
Syntactic Conveniences
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.
setInsert :: IsComparable 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, IsComparable k) => (k ': (v ': (map k v ': s))) :-> (map k v ': s) Source #
Insert given element into map.
setInsertNew :: (IsComparable 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, IsComparable 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, IsComparable k, KnownValue k, KnownValue v) => (k ': (map k v ': s)) :-> (map k v ': s) Source #
Delete element from the map.
setDelete :: IsComparable e => (e & (Set e & s)) :-> (Set e & s) Source #
Delete given element from the set.
Additional Morley macros
data View (a :: Type) (r :: Type) Source #
view type synonym as described in A1.
Constructors
| View | |
Fields
| |
Instances
data Void_ (a :: Type) (b :: Type) Source #
void type synonym as described in A1.
Constructors
| Void_ | |
Fields
| |
Instances
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
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.
void_ :: forall a b s s' anything. (IsError (VoidResult b), KnownValue b) => ((a & s) :-> (b & s')) -> (Void_ a b & s) :-> anything Source #
Buildable utils for additional Morley macros
Macros for working with contract-like types
pushContractRef :: NiceParameter arg => (forall s0. (Address ': 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.
pickFutureContract :: NiceParameter p => (FutureContract p ': s) :-> (Maybe (ContractRef p) ': s) Source #
Turn FutureContract into actual contract.
This requires contracts lookup and may fail.