Expressions¶

Indigo has several builders of expressions (here generically called operators) and statements employing them. This appendix is meant to list the former and present the latter.

This will not explain the basics of expressions, because this is already the argument of some tutorial's chapters. In particular, if you haven't already, please read the tutorial's chapter about Expressions and operators.

As a reminder, for informations on types you can instead consult their reference material.

Consulting the operators' tables¶

All operators listed in the following tables can have a certain amount of argument expressions and will always return a single resulting expression.

As a reminder the most basic expressions are the constant ones, for example you can write True or 42 int in your contract code and know that these are expressions of type Bool or Integer, respectively.

Much like constants some of the following operators can be used on their own, because they have no inputs. For example, sender takes no arguments and is an expression of type Address.

However most operators have one or more inputs, in which case you can use them by writing the operator followed by its arguments, each separated by spaces. For example, these are valid expressions:

• abs (1 int) (abs takes 1 argument expression of type Integer)
• pair () True (pair takes 2 of any type instead)

Infix operators are all the ones that take 2 arguments and are made of symbols (as opposed to letters) and as such they are used between their arguments and not before them (e.g. 1 + 2, True || False, etc.)

Many infix operator have a synonym prefix form, in which case you'll find them specified in the same row (e.g. add and +).

Compound operators are also infix, but are special in that they:

1. do require the first argument to be a variable
2. will replace the value of the variable with the result of the expression
3. do not return an expression, but a complete statement For example:

1 int += 2 int -- is invalid, this will not compile

a <- new$ 1 int
a += 2 int -- "a" will have value of "3" after this expression

b <- new$ a += 1 int -- is also invalid, because "(a += b)" is not an expression

Type variables are used in the types of these tables as well, you can recognize them because they start with a lower-case letter.

Unless differently specified, they can be replaced by any other type, however remember that if the same variable is used in a line this means its type is the same everywhere it is used.

For example, if an operator says to accept an expression of type [a] as an input and return one of type a, it means it can operate on a list of any type and will return a single element, but of that same type (e.g. take a [Integer] and return an Integer, or a [Natural] and return a Natural, but not take [Integer] and return a Natural).

You'll notice also that some operators are overloaded, so you'll find them in multiple places, operating on and returning different types. For example you can sum 2 Naturals with + as well as 2 Integers.

Logical sections¶

Starting right below are the operators and statements for Indigo.

They are grouped in sections based on the logic they execute.

Arithmetic¶

Operators¶

Comparison¶

NOTE: the comparable type variable in this section can be replaced only by a type that can be compared and not any arbitrary type, for more information see tezos's documentation.

Operators¶

Bits and boolean¶

Operators¶

Serialization¶

Operators¶

Pairs¶

Operators¶

Maybe¶

Operators¶

Either¶

Operators¶

Conversion¶

Operators¶

Bytes and String¶

Operators¶

List¶

Operators¶

Set¶

Operators¶

Map¶

Operators¶

BigMap¶

Operators¶

Constructor¶

Operators¶

Record¶

Operators¶

Auxiliary¶

Operators¶

Never¶

Operators¶

Contract¶

As a reminder chapter 05 explains and shows with an example how to use the result of the following operators and statements to perform side effects.

Operators¶

Statements¶

For improved type safety Indigo internally uses some types in addition to Address and ContractRef param (the only ones listed in Appendix A: types).

Among these types the only one necessary to use the following statements is EntrypointRef mname. As the name might suggest this is an identifier for the entrypoint we want to call, there are two possibile choices for it: - CallDefault for the default entrypoint of a contract - Call @"<entrypointname>" where <entrypointname> is the name of the entrypoint we want to call

selfCalling is a statement that returns a ContractRef param variable given an EntrypointRef mname for the contract is executed in. For example, supposing we want to use this statement in the example controlContract of chapter 03, which defines its parameter type IncrementIf with entrypoints IsZero and HasDigitOne, each of the following is a valid use:

contractRef <- selfCalling CallDefault
contractRef <- selfCalling Call @"IsZero"
contractRef <- selfCalling Call @"HasDigitOne"

contractCalling is just like selfCalling, except it points at a different contract and because of this it also needs an expression for its address. For example, supposing this time we want to call the controlContract above from a different one (and that we already have a ccAddr variable for it), each of the following is a valid use:

mContractRef <- contractCalling CallDefault ccAddr
mContractRef <- contractCalling (Call @"IsZero") ccAddr
mContractRef <- contractCalling (Call @"HasDigitOne") ccAddr

Note that another difference with selfCalling is that it returns Maybe (ContractRef param) because it may fail to lookup the contract and return none.

views and voids¶

Operators¶

Statements¶

The view_ statement allows to implement a View entrypoint by using a function. For example, let's say we have a contract that takes a View Integer Bool param for an entrypoint we could implement it like this:

  -- previous contract code to select the entrypoint
  view_ greaterThan0 param

greaterThan0 :: Var Integer -> IndigoFunction Bool
greaterThan0 val = defFunction do
  return (val >. 0 int)

As you can see we only need the function to take an Integer as parameter and return a Bool to satisfy the View Integer Bool requirement.

Another way to do so is by using the project statements, which is like view_ with the arguments inverted. This may seem pointless, but allows to define the function in place, so the previous example could be written as:

  -- previous contract code to select the entrypoint
  project param $ \val ->
    return (val > 0 int)

This is more compact and does not require the definition of a specific function.

Just like for Views there are statements for Voids that work in a matching way to the ones above: void_ and projectVoid.

Conditional¶

Statements¶

The most common conditional statement is the if ... then ... else ... construct. This specifies two branches of code to execute based on a Bool condition. Note that the branches can return a value, in which case this can be captured as a variable, but both branches need to return the same type. For example, these are valid statements:

if 1 int <= 2 int
  then do
    storage =: 1 int -- this will be executed
    return ()
  else do
    return () -- this will not

resVal <- if 1 int == 2 int
            then do
              return False
            else do
              a <- new$ 1 int == 1 int
              return a
-- we can now use the `resVal` `Bool` variable

From the first example statement above you can see than in its second branch we do not do anything (return ()), for these cases Indigo has a convenience statement called when that only takes the Bool condition and a single branch, that will be executed only if the condition is True. The first statement above could so be rewritten as:

when (1 int <= 2 int) do
  storage =: 1 int

In other cases we might want to do exactly the opposite and execute some code only when a Bool condition is False. Indigo has a convenience statement for this too, called unless. The previous example for instance could also be written as:

unless (1 int > 2 int) do
  storage =: 1 int

When we have to deal with Maybe as we often want to know if they are some a or none and execute a different code in each case. For this reason Indigo has the ifSome statement, that based on a Maybe a it executes one of its two branches. The first branch is executed in case the value is some a and takes that a as an input, the second one takes no input and is executed if the value is none For example, let's suppose to have a val variable containing some 1 of type Maybe Integer, these would be a valid statement:

ifSome val
    (\n -> storage =: n)
    (return ())

Just as for if we can have both branches return a value and assign it to a variable.

We have the reverse of ifSome as well, ifNone, whose first branch is executed only when the value is none and second branch is executed in case the value issome a and takes that a as an input.

We also two have statements similar to when for convenience: - whenSome whose single branch is executed only if the value is some a - whenNone whose single branch is executed only if the value is none

Similar to Maybe we also have conditional statement that work with Either as well: - ifRight whose: - first branch is executed only if the value is right a and takes a as input - second branch is executed in case the value is left b and takes b as an input - ifLeft which is the reverse of ifRight - whenRight whose single branch is executed only if the value is right a - whenLeft whose single branch is executed only if the value is left b

We also have another conditional statement that works with List a which is ifCons whose: - first branch is executed only if the value is not an empty list and takes the first element a and the rest of the elements List a as inputs - second branch is executed only if the value is an empty list

Loop¶

Statements¶

while is the statement that will execute a piece of code as long as a Bool condition holds. For example, this loop would execute twice:

i <- new$ 0 int
while (i int < 2 int) do
  -- more code can be here
  i += 1 int
-- the code following will get executed after the loop
i =: 0 int

whileLeft is another statement that will execute a function as long as the condition is a Left a and the function will take a as the argument. The statement will exit the loop when the condition is a Right b and return the b as the result.

forEach is instead a way to execute a piece of code over each of the elements of a container (a list, set or map). For example, given a numList variable of type [Integer] this will compute the sum of all its elements:

sum <- new$ 0 int
forEach numList $ \number -> do
  sum += number

Case¶

Statements¶

case_ is the statement that allows use to pattern-match on the constructors of a custom data-type to execute a different piece of code depending on the value of an expression.

To know about what types case_ can be used with, please refer to the types reference page. An example of a valid type and case_ usage can be found in the Tutorial's statements chapter.