Indigo.Frontend.Expr

All the basic Expressions used in Indigo code.

Note: infix operators acting on structure follow a naming convention:

1. the last character identifies the structure type:

   • : for containers (Map, BigMap, Set, List)
   • @ for storage operations (MEM, GET, UPDATE)
   • ! for HasField
   • ~ fot Named

2. the preceding characters identify the action:

   • # for get, lookup or from
   • ! for set, update or to
   • + for insert
   • ++ for insertNew
   • - for remove
   • ? for mem or elem

The only exception to this convention is (.:) (for cons)

Basic

constExpr :: forall a. NiceConstant a => a -> Expr a

varExpr :: KnownValue a => Var a -> Expr a

Create an expression holding a variable.

cast :: ex :~> a => ex -> Expr a

Math

add :: IsArithExpr exN exM Add n m r => exN -> exM -> Expr r

sub :: IsArithExpr exN exM Sub n m r => exN -> exM -> Expr r

mul :: IsArithExpr exN exM Mul n m r => exN -> exM -> Expr r

div :: forall reminder exN exM n m ratio. IsDivExpr exN exM n m ratio reminder => exN -> exM -> Expr ratio

mod :: forall ratio exN exM n m reminder. IsModExpr exN exM n m ratio reminder => exN -> exM -> Expr reminder

neg :: IsUnaryArithExpr exN Neg n => exN -> Expr (UnaryArithResHs Neg n)

abs :: IsUnaryArithExpr exN Abs n => exN -> Expr (UnaryArithResHs Abs n)

even :: (ParityExpr n m, ArithOpHs EDiv n m r, exN :~> n) => exN -> Expr Bool

odd :: (ParityExpr n m, ArithOpHs EDiv n m r, exN :~> n) => exN -> Expr Bool

(+) :: IsArithExpr exN exM Add n m r => exN -> exM -> Expr r infixl 6

(-) :: IsArithExpr exN exM Sub n m r => exN -> exM -> Expr r infixl 6

(*) :: IsArithExpr exN exM Mul n m r => exN -> exM -> Expr r infixl 7

(/) :: forall reminder exN exM n m ratio. IsDivExpr exN exM n m ratio reminder => exN -> exM -> Expr ratio infixl 7

(%) :: forall ratio exN exM n m reminder. IsModExpr exN exM n m ratio reminder => exN -> exM -> Expr reminder infixl 7

Comparison

eq :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool

neq :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool

lt :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool

gt :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool

le :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool

ge :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool

(==) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool infix 4

(/=) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool infix 4

(<) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool infix 4

(>) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool infix 4

(<=) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool infix 4

(>=) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool infix 4

Conversion

isNat :: ex :~> Integer => ex -> Expr (Maybe Natural)

toInt :: ex :~> Natural => ex -> Expr Integer

nonZero :: (ex :~> n, NonZero n, KnownValue (Maybe n)) => ex -> Expr (Maybe n)

coerce :: forall b a ex. (Castable_ a b, KnownValue b, ex :~> a) => ex -> Expr b

Convert between types that have the same Michelson representation and an explicit permission for that in the face of CanCastTo constraint.

forcedCoerce :: forall b a ex. (MichelsonCoercible a b, KnownValue b, ex :~> a) => ex -> Expr b

Convert between expressions of types that have the same Michelson representation.

Bits and boolean

lsl :: IsArithExpr exN exM Lsl n m r => exN -> exM -> Expr r

lsr :: IsArithExpr exN exM Lsr n m r => exN -> exM -> Expr r

and :: IsArithExpr exN exM And n m r => exN -> exM -> Expr r

or :: IsArithExpr exN exM Or n m r => exN -> exM -> Expr r

xor :: IsArithExpr exN exM Xor n m r => exN -> exM -> Expr r

not :: IsUnaryArithExpr exN Not n => exN -> Expr (UnaryArithResHs Not n)

(<<<) :: IsArithExpr exN exM Lsl n m r => exN -> exM -> Expr r infixl 8

(>>>) :: IsArithExpr exN exM Lsr n m r => exN -> exM -> Expr r infixl 8

(&&) :: IsArithExpr exN exM And n m r => exN -> exM -> Expr r infixr 3

(||) :: IsArithExpr exN exM Or n m r => exN -> exM -> Expr r infixr 2

(^) :: IsArithExpr exN exM Xor n m r => exN -> exM -> Expr r infixr 2

Serialization

pack :: (ex :~> a, NicePackedValue a) => ex -> Expr (Packed a)

unpack :: (NiceUnpackedValue a, exb :~> Packed a) => exb -> Expr (Maybe a)

packRaw :: (ex :~> a, NicePackedValue a) => ex -> Expr ByteString

unpackRaw :: (NiceUnpackedValue a, exb :~> ByteString) => exb -> Expr (Maybe a)

Pairs

pair :: (ex1 :~> n, ex2 :~> m, KnownValue (n, m)) => ex1 -> ex2 -> Expr (n, m)

car :: (op :~> (n, m), KnownValue n) => op -> Expr n

cdr :: (op :~> (n, m), KnownValue m) => op -> Expr m

fst :: (op :~> (n, m), KnownValue n) => op -> Expr n

snd :: (op :~> (n, m), KnownValue m) => op -> Expr m

Maybe

some :: (ex :~> t, KnownValue (Maybe t)) => ex -> Expr (Maybe t)

none :: KnownValue t => Expr (Maybe t)

Either

right :: (ex :~> x, KnownValue y, KnownValue (Either y x)) => ex -> Expr (Either y x)

left :: (ex :~> y, KnownValue x, KnownValue (Either y x)) => ex -> Expr (Either y x)

Bytes and string

slice :: (an :~> Natural, bn :~> Natural, IsSliceExpr ex c) => (an, bn) -> ex -> Expr (Maybe c)

concat :: IsConcatExpr exN1 exN2 n => exN1 -> exN2 -> Expr n

(<>) :: IsConcatExpr exN1 exN2 n => exN1 -> exN2 -> Expr n infixr 6

List

concatAll :: IsConcatListExpr exN n => exN -> Expr n

nil :: KnownValue a => Expr (List a)

cons :: (ex1 :~> a, ex2 :~> List a) => ex1 -> ex2 -> Expr (List a)

(.:) :: (ex1 :~> a, ex2 :~> List a) => ex1 -> ex2 -> Expr (List a) infixr 5

Containers

get :: IsGetExpr exKey exMap map => exKey -> exMap -> Expr (Maybe (GetOpValHs map))

update :: IsUpdExpr exKey exVal exMap map => (exKey, exVal) -> exMap -> Expr map

insert :: (ExprInsertable c insParam, ex :~> c) => insParam -> ex -> Expr c

remove :: (ExprRemovable c, exStruct :~> c, exKey :~> UpdOpKeyHs c) => exKey -> exStruct -> Expr c

mem :: IsMemExpr exKey exN n => exKey -> exN -> Expr Bool

size :: IsSizeExpr exN n => exN -> Expr Natural

(#:) :: IsGetExpr exKey exMap map => exMap -> exKey -> Expr (Maybe (GetOpValHs map)) infixl 8

(!:) :: IsUpdExpr exKey exVal exMap map => exMap -> (exKey, exVal) -> Expr map infixl 8

(+:) :: (ExprInsertable c exParam, exStructure :~> c) => exStructure -> exParam -> Expr c infixl 8

(-:) :: (ExprRemovable c, exStruct :~> c, exKey :~> UpdOpKeyHs c) => exStruct -> exKey -> Expr c infixl 8

(?:) :: IsMemExpr exKey exN n => exN -> exKey -> Expr Bool infixl 8

empty :: (ExprMagma c, NiceComparable (UpdOpKeyHs c), KnownValue c) => Expr c

emptyBigMap :: (KnownValue value, NiceComparable key, KnownValue (BigMap key value)) => Expr (BigMap key value)

emptyMap :: (KnownValue value, NiceComparable key, KnownValue (Map key value)) => Expr (Map key value)

emptySet :: (NiceComparable key, KnownValue (Set key)) => Expr (Set key)

Storages

stGet :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr (Maybe value)

stUpdate :: (StoreHasSubmap store name key value, exKey :~> key, exVal :~> Maybe value, exStore :~> store) => exStore -> (Label name, exKey, exVal) -> Expr store

stInsert :: (StoreHasSubmap store name key value, exKey :~> key, exVal :~> value, exStore :~> store) => exStore -> (Label name, exKey, exVal) -> Expr store

stInsertNew :: (StoreHasSubmap store name key value, Dupable key, IsError err, Buildable err, exKey :~> key, exVal :~> value, exStore :~> store) => exStore -> (Label name, err, exKey, exVal) -> Expr store

stDelete :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr store

stMem :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr Bool

(#@) :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr (Maybe value) infixr 8

(!@) :: (StoreHasSubmap store name key value, exKey :~> key, exVal :~> Maybe value, exStore :~> store) => exStore -> (Label name, exKey, exVal) -> Expr store infixl 8

(+@) :: (StoreHasSubmap store name key value, exKey :~> key, exVal :~> value, exStore :~> store) => exStore -> (Label name, exKey, exVal) -> Expr store infixr 8

(++@) :: (StoreHasSubmap store name key value, Dupable key, IsError err, Buildable err, exKey :~> key, exVal :~> value, exStore :~> store) => exStore -> (Label name, err, exKey, exVal) -> Expr store infixr 8

(-@) :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr store infixl 8

(?@) :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr Bool infixl 8

Sum types

wrap :: (InstrWrapOneC dt name, exField :~> CtorOnlyField name dt, KnownValue dt) => Label name -> exField -> Expr dt

unwrap :: (InstrUnwrapC dt name, exDt :~> dt, KnownValue (CtorOnlyField name dt)) => Label name -> exDt -> Expr (CtorOnlyField name dt)

HasField

(!!) :: (HasField dt name ftype, exDt :~> dt, exFld :~> ftype) => exDt -> (Label name, exFld) -> Expr dt infixl 8

(#!) :: (HasField dt name ftype, exDt :~> dt) => exDt -> Label name -> Expr ftype infixl 8

Record and Named

name :: (ex :~> t, KnownValue (name :! t)) => Label name -> ex -> Expr (name :! t)

unName :: (ex :~> (name :! t), KnownValue t) => Label name -> ex -> Expr t

(!~) :: (ex :~> t, KnownValue (name :! t)) => ex -> Label name -> Expr (name :! t) infixl 8

(#~) :: (ex :~> (name :! t), KnownValue t) => ex -> Label name -> Expr t infixl 8

construct :: (InstrConstructC dt, KnownValue dt, RMap (ConstructorFieldTypes dt), RecordToList (ConstructorFieldTypes dt), fields ~ Rec Expr (ConstructorFieldTypes dt), RecFromTuple fields) => IsoRecTuple fields -> Expr dt

constructRec :: (InstrConstructC dt, RMap (ConstructorFieldTypes dt), RecordToList (ConstructorFieldTypes dt), KnownValue dt) => Rec Expr (ConstructorFieldTypes dt) -> Expr dt

Contract

contract :: forall p vd addr exAddr. (NiceParameterFull p, NoExplicitDefaultEntrypoint p, IsoValue (ContractRef p), ToTAddress p vd addr, ToT addr ~ ToT Address, exAddr :~> addr) => exAddr -> Expr (Maybe (ContractRef p))

self :: (NiceParameterFull p, NoExplicitDefaultEntrypoint p, IsoValue (ContractRef p), IsNotInView) => Expr (ContractRef p)

selfAddress :: Expr Address

contractAddress :: exc :~> ContractRef p => exc -> Expr Address

contractCallingUnsafe :: (NiceParameter arg, IsoValue (ContractRef arg), exAddr :~> Address) => EpName -> exAddr -> Expr (Maybe (ContractRef arg))

contractCallingString :: (NiceParameter arg, IsoValue (ContractRef arg), exAddr :~> Address) => MText -> exAddr -> Expr (Maybe (ContractRef arg))

runFutureContract :: (NiceParameter p, IsoValue (ContractRef p), conExpr :~> FutureContract p) => conExpr -> Expr (Maybe (ContractRef p))

implicitAccount :: exkh :~> KeyHash => exkh -> Expr (ContractRef ())

convertEpAddressToContract :: (NiceParameter p, IsoValue (ContractRef p), epExpr :~> EpAddress) => epExpr -> Expr (Maybe (ContractRef p))

makeView :: (KnownValue (View_ a r), exa :~> a, exCRef :~> ContractRef r) => exa -> exCRef -> Expr (View_ a r)

makeVoid :: (KnownValue (Void_ a b), exa :~> a, exCRef :~> Lambda b b) => exa -> exCRef -> Expr (Void_ a b)

Auxiliary

now :: Expr Timestamp

amount :: Expr Mutez

sender :: Expr Address

blake2b :: (hashExpr :~> bs, BytesLike bs) => hashExpr -> Expr (Hash Blake2b bs)

sha256 :: (hashExpr :~> bs, BytesLike bs) => hashExpr -> Expr (Hash Sha256 bs)

sha512 :: (hashExpr :~> bs, BytesLike bs) => hashExpr -> Expr (Hash Sha512 bs)

sha3 :: (hashExpr :~> bs, BytesLike bs) => hashExpr -> Expr (Hash Sha3 bs)

keccak :: (hashExpr :~> bs, BytesLike bs) => hashExpr -> Expr (Hash Keccak bs)

hashKey :: keyExpr :~> PublicKey => keyExpr -> Expr KeyHash

chainId :: Expr ChainId

balance :: Expr Mutez

level :: Expr Natural

votingPower :: keyExpr :~> KeyHash => keyExpr -> Expr Natural

totalVotingPower :: Expr Natural

checkSignature :: (pkExpr :~> PublicKey, sigExpr :~> TSignature bs, hashExpr :~> bs, BytesLike bs) => pkExpr -> sigExpr -> hashExpr -> Expr Bool