Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- nop :: s :-> s
- drop :: (a & s) :-> s
- dup :: (a & s) :-> (a & (a & s))
- swap :: (a & (b & s)) :-> (b & (a & s))
- push :: forall t s. (KnownValue t, NoOperation t, NoBigMap t, IsoValue 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)
- map :: (MapOpHs c, IsoMapOpRes c b) => ((MapOpInpHs c & s) :-> (b & s)) -> (c & s) :-> (MapOpResHs c b & s)
- iter :: IterOpHs c => ((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 :: (KnownValue i, KnownValue o) => Lambda i o -> s :-> (Lambda i o & s)
- exec :: (a & (Lambda a b & s)) :-> (b & s)
- dip :: forall a s s'. (s :-> s') -> (a & s) :-> (a & s')
- failWith :: KnownValue a => (a & s) :-> t
- failText :: MText -> s :-> t
- failTagged :: KnownValue a => MText -> (a & s) :-> t
- failUsing :: (IsoValue a, KnownValue a, NoOperation a, NoBigMap a) => a -> s :-> t
- failUnexpected :: HasCallStack => MText -> s :-> t
- cast :: KnownValue a => (a & s) :-> (a & s)
- pack :: forall a s. (KnownValue a, NoOperation a, NoBigMap a) => (a & s) :-> (ByteString & s)
- unpack :: forall a s. (KnownValue a, NoOperation a, NoBigMap 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 m => (n & (m & s)) :-> (ArithResHs Compare n m & 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 cp s. s :-> (ContractAddr cp & s)
- contract :: KnownValue p => (Address & s) :-> (Maybe (ContractAddr p) & s)
- transferTokens :: forall p s. (KnownValue p, NoOperation p, NoBigMap p) => (p & (Mutez & (ContractAddr p & s))) :-> (Operation & s)
- setDelegate :: (Maybe KeyHash & s) :-> (Operation & s)
- createAccount :: (KeyHash & (Maybe KeyHash & (Bool & (Mutez & s)))) :-> (Operation & (Address & s))
- createContract :: forall p g s. (KnownValue p, NoOperation p, KnownValue g, NoOperation g, NoBigMap p, CanHaveBigMap g) => ('[(p, g)] :-> '[(List Operation, g)]) -> (KeyHash & (Maybe KeyHash & (Bool & (Bool & (Mutez & (g & s)))))) :-> (Operation & (Address & s))
- implicitAccount :: (KeyHash & s) :-> (ContractAddr () & 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 :: (ContractAddr a & s) :-> (Address & s)
- class LorentzFunctor (c :: Type -> Type) where
- lmap :: KnownValue b => ((a ': s) :-> (b ': s)) -> (c a ': s) :-> (c b ': s)
Documentation
push :: forall t s. (KnownValue t, NoOperation t, NoBigMap t, IsoValue t) => t -> s :-> (t & s) Source #
emptyMap :: (KnownCValue k, KnownValue v) => s :-> (Map k v & s) Source #
map :: (MapOpHs c, IsoMapOpRes c b) => ((MapOpInpHs c & s) :-> (b & s)) -> (c & s) :-> (MapOpResHs c b & 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.
lambda :: (KnownValue i, KnownValue o) => Lambda i o -> s :-> (Lambda i o & s) Source #
failTagged :: KnownValue a => MText -> (a & s) :-> t Source #
Fail with a given message and the top of the current stack.
failUsing :: (IsoValue a, KnownValue a, NoOperation a, NoBigMap a) => a -> s :-> t Source #
Fail with the given Haskell value.
failUnexpected :: HasCallStack => MText -> s :-> t Source #
Fail, providing a reference to the place in the code where this function is called.
Like error
in Haskell code, this instruction is for internal errors only.
pack :: forall a s. (KnownValue a, NoOperation a, NoBigMap a) => (a & s) :-> (ByteString & s) Source #
unpack :: forall a s. (KnownValue a, NoOperation a, NoBigMap a) => (ByteString & s) :-> (Maybe a & s) Source #
abs :: UnaryArithOpHs Abs n => (n & s) :-> (UnaryArithResHs Abs n & s) Source #
neg :: UnaryArithOpHs Neg n => (n & s) :-> (UnaryArithResHs Neg n & s) Source #
not :: UnaryArithOpHs Not n => (n & s) :-> (UnaryArithResHs Not 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 #
contract :: KnownValue p => (Address & s) :-> (Maybe (ContractAddr p) & s) Source #
transferTokens :: forall p s. (KnownValue p, NoOperation p, NoBigMap p) => (p & (Mutez & (ContractAddr p & s))) :-> (Operation & s) Source #
createAccount :: (KeyHash & (Maybe KeyHash & (Bool & (Mutez & s)))) :-> (Operation & (Address & s)) Source #
createContract :: forall p g s. (KnownValue p, NoOperation p, KnownValue g, NoOperation g, NoBigMap p, CanHaveBigMap g) => ('[(p, g)] :-> '[(List Operation, g)]) -> (KeyHash & (Maybe KeyHash & (Bool & (Bool & (Mutez & (g & s)))))) :-> (Operation & (Address & s)) Source #
implicitAccount :: (KeyHash & s) :-> (ContractAddr () & s) Source #
sha256 :: (ByteString & s) :-> (ByteString & s) Source #
sha512 :: (ByteString & s) :-> (ByteString & s) Source #
blake2B :: (ByteString & s) :-> (ByteString & s) Source #
class LorentzFunctor (c :: Type -> Type) where Source #
Instances
LorentzFunctor Maybe Source # | |
Defined in Lorentz.Instr |