Safe Haskell	None
Language	Haskell2010

Lorentz.Instr

Synopsis

nop :: s :-> s
drop :: (a & s) :-> s
dropN :: forall (n :: Nat) (s :: [Type]). (SingI (ToPeano n), KnownPeano (ToPeano n), RequireLongerOrSameLength (ToTs s) (ToPeano n), Drop (ToPeano n) (ToTs s) ~ ToTs (Drop (ToPeano n) s)) => s :-> Drop (ToPeano n) s
dup :: (a & s) :-> (a & (a & s))
swap :: (a & (b & s)) :-> (b & (a & s))
digPeano :: forall (n :: Peano) inp out a. ConstraintDIGLorentz n inp out a => inp :-> out
dig :: forall (n :: Nat) inp out a. ConstraintDIGLorentz (ToPeano n) inp out a => inp :-> out
dug :: forall (n :: Nat) inp out a. ConstraintDUGLorentz (ToPeano n) inp out a => inp :-> out
push :: forall t s. NiceConstant t => t -> s :-> (t & s)
some :: (a & s) :-> (Maybe a & s)
none :: forall a s. KnownValue a => s :-> (Maybe a & s)
unit :: s :-> (() & s)
ifNone :: (s :-> s') -> ((a & s) :-> s') -> (Maybe a & s) :-> s'
pair :: (a & (b & s)) :-> ((a, b) & s)
car :: ((a, b) & s) :-> (a & s)
cdr :: ((a, b) & s) :-> (b & s)
left :: forall a b s. KnownValue b => (a & s) :-> (Either a b & s)
right :: forall a b s. KnownValue a => (b & s) :-> (Either a b & s)
ifLeft :: ((a & s) :-> s') -> ((b & s) :-> s') -> (Either a b & s) :-> s'
nil :: KnownValue p => s :-> (List p & s)
cons :: (a & (List a & s)) :-> (List a & s)
size :: SizeOpHs c => (c & s) :-> (Natural & s)
emptySet :: KnownCValue e => s :-> (Set e & s)
emptyMap :: (KnownCValue k, KnownValue v) => s :-> (Map k v & s)
emptyBigMap :: (KnownCValue k, KnownValue v) => s :-> (BigMap k v & s)
map :: (MapOpHs c, IsoMapOpRes c b, HasCallStack) => ((MapOpInpHs c & s) :-> (b & s)) -> (c & s) :-> (MapOpResHs c b & s)
iter :: (IterOpHs c, HasCallStack) => ((IterOpElHs c & s) :-> s) -> (c & s) :-> s
mem :: MemOpHs c => (MemOpKeyHs c & (c & s)) :-> (Bool & s)
get :: GetOpHs c => (GetOpKeyHs c & (c & s)) :-> (Maybe (GetOpValHs c) & s)
update :: UpdOpHs c => (UpdOpKeyHs c & (UpdOpParamsHs c & (c & s))) :-> (c & s)
failingWhenPresent :: forall c k s v st e. (MemOpHs c, k ~ MemOpKeyHs c, KnownValue e, st ~ (k & (v & (c & s)))) => (forall s0. (k ': s0) :-> (e ': s0)) -> st :-> st
updateNew :: forall c k s e. (UpdOpHs c, MemOpHs c, k ~ UpdOpKeyHs c, k ~ MemOpKeyHs c, KnownValue e) => (forall s0. (k ': s0) :-> (e ': s0)) -> (k & (UpdOpParamsHs c & (c & s))) :-> (c & s)
if_ :: (s :-> s') -> (s :-> s') -> (Bool & s) :-> s'
ifCons :: ((a & (List a & s)) :-> s') -> (s :-> s') -> (List a & s) :-> s'
loop :: (s :-> (Bool & s)) -> (Bool & s) :-> s
loopLeft :: ((a & s) :-> (Either a b & s)) -> (Either a b & s) :-> (b & s)
lambda :: (ZipInstrs [i, o], KnownValue (ZippedStack i), KnownValue (ZippedStack o)) => (i :-> o) -> s :-> ((i :-> o) & s)
exec :: (a & (Lambda a b & s)) :-> (b & s)
execute :: forall i o s. Each [KnownList, ZipInstr] [i, o] => ((i :-> o) ': (i ++ s)) :-> (o ++ s)
apply :: forall a b c s. NiceConstant a => (a & (Lambda (a, b) c & s)) :-> (Lambda b c & s)
dip :: forall a s s'. HasCallStack => (s :-> s') -> (a & s) :-> (a & s')
type ConstraintDIPNLorentz (n :: Peano) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]) = (ConstraintDIPN n (ToTs inp) (ToTs out) (ToTs s) (ToTs s'), ConstraintDIPN' Type n inp out s s')
dipNPeano :: forall (n :: Peano) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]). ConstraintDIPNLorentz n inp out s s' => (s :-> s') -> inp :-> out
dipN :: forall (n :: Nat) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]). ConstraintDIPNLorentz (ToPeano n) inp out s s' => (s :-> s') -> inp :-> out
failWith :: KnownValue a => (a & s) :-> t
cast :: KnownValue a => (a & s) :-> (a & s)
pack :: forall a s. NicePackedValue a => (a & s) :-> (ByteString & s)
unpack :: forall a s. NiceUnpackedValue a => (ByteString & s) :-> (Maybe a & s)
concat :: ConcatOpHs c => (c & (c & s)) :-> (c & s)
concat' :: ConcatOpHs c => (List c & s) :-> (c & s)
slice :: SliceOpHs c => (Natural & (Natural & (c & s))) :-> (Maybe c & s)
isNat :: (Integer & s) :-> (Maybe Natural & s)
add :: ArithOpHs Add n m => (n & (m & s)) :-> (ArithResHs Add n m & s)
sub :: ArithOpHs Sub n m => (n & (m & s)) :-> (ArithResHs Sub n m & s)
rsub :: ArithOpHs Sub n m => (m & (n & s)) :-> (ArithResHs Sub n m & s)
mul :: ArithOpHs Mul n m => (n & (m & s)) :-> (ArithResHs Mul n m & s)
ediv :: EDivOpHs n m => (n & (m & s)) :-> (Maybe (EDivOpResHs n m, EModOpResHs n m) & s)
abs :: UnaryArithOpHs Abs n => (n & s) :-> (UnaryArithResHs Abs n & s)
neg :: UnaryArithOpHs Neg n => (n & s) :-> (UnaryArithResHs Neg n & s)
lsl :: ArithOpHs Lsl n m => (n & (m & s)) :-> (ArithResHs Lsl n m & s)
lsr :: ArithOpHs Lsr n m => (n & (m & s)) :-> (ArithResHs Lsr n m & s)
or :: ArithOpHs Or n m => (n & (m & s)) :-> (ArithResHs Or n m & s)
and :: ArithOpHs And n m => (n & (m & s)) :-> (ArithResHs And n m & s)
xor :: ArithOpHs Xor n m => (n & (m & s)) :-> (ArithResHs Xor n m & s)
not :: UnaryArithOpHs Not n => (n & s) :-> (UnaryArithResHs Not n & s)
compare :: ArithOpHs Compare n n => (n & (n & s)) :-> (ArithResHs Compare n n & s)
eq0 :: UnaryArithOpHs Eq' n => (n & s) :-> (UnaryArithResHs Eq' n & s)
neq0 :: UnaryArithOpHs Neq n => (n & s) :-> (UnaryArithResHs Neq n & s)
lt0 :: UnaryArithOpHs Lt n => (n & s) :-> (UnaryArithResHs Lt n & s)
gt0 :: UnaryArithOpHs Gt n => (n & s) :-> (UnaryArithResHs Gt n & s)
le0 :: UnaryArithOpHs Le n => (n & s) :-> (UnaryArithResHs Le n & s)
ge0 :: UnaryArithOpHs Ge n => (n & s) :-> (UnaryArithResHs Ge n & s)
int :: (Natural & s) :-> (Integer & s)
self :: forall p s. NiceParameter p => s :-> (ContractRef p & s)
contract :: forall p s. NiceParameter p => (Address & s) :-> (Maybe (ContractRef p) & s)
transferTokens :: forall p s. NiceParameter p => (p & (Mutez & (ContractRef p & s))) :-> (Operation & s)
setDelegate :: (Maybe KeyHash & s) :-> (Operation & s)
createContract :: forall p g s. (NiceStorage g, ParameterEntryPoints p) => Contract p g -> (Maybe KeyHash & (Mutez & (g & s))) :-> (Operation & (Address & s))
implicitAccount :: (KeyHash & s) :-> (ContractRef () & s)
now :: s :-> (Timestamp & s)
amount :: s :-> (Mutez & s)
balance :: s :-> (Mutez & s)
checkSignature :: (PublicKey & (Signature & (ByteString & s))) :-> (Bool & s)
sha256 :: (ByteString & s) :-> (ByteString & s)
sha512 :: (ByteString & s) :-> (ByteString & s)
blake2B :: (ByteString & s) :-> (ByteString & s)
hashKey :: (PublicKey & s) :-> (KeyHash & s)
stepsToQuota :: s :-> (Natural & s)
source :: s :-> (Address & s)
sender :: s :-> (Address & s)
address :: (ContractRef a & s) :-> (Address & s)
chainId :: s :-> (ChainId & s)
framed :: forall s i o. (KnownList i, KnownList o) => (i :-> o) -> (i ++ s) :-> (o ++ s)
class LorentzFunctor (c :: Type -> Type) where
- lmap :: KnownValue b => ((a ': s) :-> (b ': s)) -> (c a ': s) :-> (c b ': s)
nonZero :: NonZero t => (t ': s) :-> (Maybe t ': s)

Documentation

nop :: s :-> s Source #

drop :: (a & s) :-> s Source #

dropN :: forall (n :: Nat) (s :: [Type]). (SingI (ToPeano n), KnownPeano (ToPeano n), RequireLongerOrSameLength (ToTs s) (ToPeano n), Drop (ToPeano n) (ToTs s) ~ ToTs (Drop (ToPeano n) s)) => s :-> Drop (ToPeano n) s Source #

Drop top n elements from the stack.

dup :: (a & s) :-> (a & (a & s)) Source #

swap :: (a & (b & s)) :-> (b & (a & s)) Source #

digPeano :: forall (n :: Peano) inp out a. ConstraintDIGLorentz n inp out a => inp :-> out Source #

Version of dig which uses Peano number. It is inteded for internal usage in Lorentz.

dig :: forall (n :: Nat) inp out a. ConstraintDIGLorentz (ToPeano n) inp out a => inp :-> out Source #

dug :: forall (n :: Nat) inp out a. ConstraintDUGLorentz (ToPeano n) inp out a => inp :-> out Source #

push :: forall t s. NiceConstant t => t -> s :-> (t & s) Source #

some :: (a & s) :-> (Maybe a & s) Source #

none :: forall a s. KnownValue a => s :-> (Maybe a & s) Source #

unit :: s :-> (() & s) Source #

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

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

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

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

left :: forall a b s. KnownValue b => (a & s) :-> (Either a b & s) Source #

right :: forall a b s. KnownValue a => (b & s) :-> (Either a b & s) Source #

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

nil :: KnownValue p => s :-> (List p & s) Source #

cons :: (a & (List a & s)) :-> (List a & s) Source #

size :: SizeOpHs c => (c & s) :-> (Natural & s) Source #

emptySet :: KnownCValue e => s :-> (Set e & s) Source #

emptyMap :: (KnownCValue k, KnownValue v) => s :-> (Map k v & s) Source #

emptyBigMap :: (KnownCValue k, KnownValue v) => s :-> (BigMap k v & s) Source #

map :: (MapOpHs c, IsoMapOpRes c b, HasCallStack) => ((MapOpInpHs c & s) :-> (b & s)) -> (c & s) :-> (MapOpResHs c b & s) Source #

iter :: (IterOpHs c, HasCallStack) => ((IterOpElHs c & s) :-> s) -> (c & s) :-> s Source #

mem :: MemOpHs c => (MemOpKeyHs c & (c & s)) :-> (Bool & s) Source #

get :: GetOpHs c => (GetOpKeyHs c & (c & s)) :-> (Maybe (GetOpValHs c) & s) Source #

update :: UpdOpHs c => (UpdOpKeyHs c & (UpdOpParamsHs c & (c & s))) :-> (c & s) Source #

failingWhenPresent :: forall c k s v st e. (MemOpHs c, k ~ MemOpKeyHs c, KnownValue e, st ~ (k & (v & (c & s)))) => (forall s0. (k ': s0) :-> (e ': s0)) -> st :-> st Source #

Helper instruction.

Checks whether given key present in the storage and fails if it is. This instruction leaves stack intact.

updateNew :: forall c k s e. (UpdOpHs c, MemOpHs c, k ~ UpdOpKeyHs c, k ~ MemOpKeyHs c, KnownValue e) => (forall s0. (k ': s0) :-> (e ': s0)) -> (k & (UpdOpParamsHs c & (c & s))) :-> (c & s) Source #

Like update, but throw an error on attempt to overwrite existing entry.

if_ :: (s :-> s') -> (s :-> s') -> (Bool & s) :-> s' Source #

ifCons :: ((a & (List a & s)) :-> s') -> (s :-> s') -> (List a & s) :-> s' Source #

loop :: (s :-> (Bool & s)) -> (Bool & s) :-> s Source #

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

lambda :: (ZipInstrs [i, o], KnownValue (ZippedStack i), KnownValue (ZippedStack o)) => (i :-> o) -> s :-> ((i :-> o) & s) Source #

exec :: (a & (Lambda a b & s)) :-> (b & s) Source #

execute :: forall i o s. Each [KnownList, ZipInstr] [i, o] => ((i :-> o) ': (i ++ s)) :-> (o ++ s) Source #

Similar to exec but works for lambdas with arbitrary size of input and output.

Note that this instruction has its arguments flipped, lambda goes first. This seems to be the only reasonable way to achieve good inference.

apply :: forall a b c s. NiceConstant a => (a & (Lambda (a, b) c & s)) :-> (Lambda b c & s) Source #

dip :: forall a s s'. HasCallStack => (s :-> s') -> (a & s) :-> (a & s') Source #

type ConstraintDIPNLorentz (n :: Peano) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]) = (ConstraintDIPN n (ToTs inp) (ToTs out) (ToTs s) (ToTs s'), ConstraintDIPN' Type n inp out s s') Source #

dipNPeano :: forall (n :: Peano) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]). ConstraintDIPNLorentz n inp out s s' => (s :-> s') -> inp :-> out Source #

Version of dipN which uses Peano number. It is inteded for internal usage in Lorentz.

dipN :: forall (n :: Nat) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]). ConstraintDIPNLorentz (ToPeano n) inp out s s' => (s :-> s') -> inp :-> out Source #

failWith :: KnownValue a => (a & s) :-> t Source #

cast :: KnownValue a => (a & s) :-> (a & s) Source #

pack :: forall a s. NicePackedValue a => (a & s) :-> (ByteString & s) Source #

unpack :: forall a s. NiceUnpackedValue a => (ByteString & s) :-> (Maybe a & s) Source #

concat :: ConcatOpHs c => (c & (c & s)) :-> (c & s) Source #

concat' :: ConcatOpHs c => (List c & s) :-> (c & s) Source #

slice :: SliceOpHs c => (Natural & (Natural & (c & s))) :-> (Maybe c & s) Source #

isNat :: (Integer & s) :-> (Maybe Natural & s) Source #

add :: ArithOpHs Add n m => (n & (m & s)) :-> (ArithResHs Add n m & s) Source #

sub :: ArithOpHs Sub n m => (n & (m & s)) :-> (ArithResHs Sub n m & s) Source #

rsub :: ArithOpHs Sub n m => (m & (n & s)) :-> (ArithResHs Sub n m & s) Source #

mul :: ArithOpHs Mul n m => (n & (m & s)) :-> (ArithResHs Mul n m & s) Source #

ediv :: EDivOpHs n m => (n & (m & s)) :-> (Maybe (EDivOpResHs n m, EModOpResHs n m) & s) Source #

abs :: UnaryArithOpHs Abs n => (n & s) :-> (UnaryArithResHs Abs n & s) Source #

neg :: UnaryArithOpHs Neg n => (n & s) :-> (UnaryArithResHs Neg n & s) Source #

lsl :: ArithOpHs Lsl n m => (n & (m & s)) :-> (ArithResHs Lsl n m & s) Source #

lsr :: ArithOpHs Lsr n m => (n & (m & s)) :-> (ArithResHs Lsr n m & s) Source #

or :: ArithOpHs Or n m => (n & (m & s)) :-> (ArithResHs Or n m & s) Source #

and :: ArithOpHs And n m => (n & (m & s)) :-> (ArithResHs And n m & s) Source #

xor :: ArithOpHs Xor n m => (n & (m & s)) :-> (ArithResHs Xor n m & s) Source #

not :: UnaryArithOpHs Not n => (n & s) :-> (UnaryArithResHs Not n & s) Source #

compare :: ArithOpHs Compare n n => (n & (n & s)) :-> (ArithResHs Compare n n & s) Source #

eq0 :: UnaryArithOpHs Eq' n => (n & s) :-> (UnaryArithResHs Eq' n & s) Source #

neq0 :: UnaryArithOpHs Neq n => (n & s) :-> (UnaryArithResHs Neq n & s) Source #

lt0 :: UnaryArithOpHs Lt n => (n & s) :-> (UnaryArithResHs Lt n & s) Source #

gt0 :: UnaryArithOpHs Gt n => (n & s) :-> (UnaryArithResHs Gt n & s) Source #

le0 :: UnaryArithOpHs Le n => (n & s) :-> (UnaryArithResHs Le n & s) Source #

ge0 :: UnaryArithOpHs Ge n => (n & s) :-> (UnaryArithResHs Ge n & s) Source #

int :: (Natural & s) :-> (Integer & s) Source #

self :: forall p s. NiceParameter p => s :-> (ContractRef p & s) Source #

contract :: forall p s. NiceParameter p => (Address & s) :-> (Maybe (ContractRef p) & s) Source #

transferTokens :: forall p s. NiceParameter p => (p & (Mutez & (ContractRef p & s))) :-> (Operation & s) Source #

setDelegate :: (Maybe KeyHash & s) :-> (Operation & s) Source #

createContract :: forall p g s. (NiceStorage g, ParameterEntryPoints p) => Contract p g -> (Maybe KeyHash & (Mutez & (g & s))) :-> (Operation & (Address & s)) Source #

implicitAccount :: (KeyHash & s) :-> (ContractRef () & s) Source #

now :: s :-> (Timestamp & s) Source #

amount :: s :-> (Mutez & s) Source #

balance :: s :-> (Mutez & s) Source #

checkSignature :: (PublicKey & (Signature & (ByteString & s))) :-> (Bool & s) Source #

sha256 :: (ByteString & s) :-> (ByteString & s) Source #

sha512 :: (ByteString & s) :-> (ByteString & s) Source #

blake2B :: (ByteString & s) :-> (ByteString & s) Source #

hashKey :: (PublicKey & s) :-> (KeyHash & s) Source #

stepsToQuota :: s :-> (Natural & s) Source #

Warning: STEPS_TO_QUOTA instruction is deprecated in Michelson 005

source :: s :-> (Address & s) Source #

Warning: Using source is considered a bad practice. Consider using sender instead until further investigation

sender :: s :-> (Address & s) Source #

address :: (ContractRef a & s) :-> (Address & s) Source #

chainId :: s :-> (ChainId & s) Source #

framed :: forall s i o. (KnownList i, KnownList o) => (i :-> o) -> (i ++ s) :-> (o ++ s) Source #

Execute given instruction on truncated stack.

This instruction requires you to specify the piece of stack to truncate as type argument.

class LorentzFunctor (c :: Type -> Type) where Source #

Methods

lmap :: KnownValue b => ((a ': s) :-> (b ': s)) -> (c a ': s) :-> (c b ': s) Source #

Instances

LorentzFunctor Maybe Source #
Instance details Defined in Lorentz.Instr Methods lmap :: KnownValue b => ((a ': s) :-> (b ': s)) -> (Maybe a ': s) :-> (Maybe b ': s) Source #

nonZero :: NonZero t => (t ': s) :-> (Maybe t ': s) Source #

Retain the value only if it is not zero.