Booleans and Conditionals

Booleans

The type of a boolean value is bool. Here is how to define a boolean value:

const a : bool = True // Also: true
const b : bool = False // Also: false

Common operations:

and
Logical and
const logical_and: bool = True and True;
or
Logical or
const logical_or: bool = False or True;
not
Logical not
const logical_not: bool = not False;
=
Equals
const eq: bool = 2 = 3;
=/=
Not equals
const not_eq: bool = 2 =/= 3;
>
Greater than
const gt: bool = 4 > 3;
<
Less than
const lt: bool = 4 < 3;
>=
Greater than or equal to
const gte: bool = 4 >= 3;
<=
Less than or equal to
const lte: bool = 4 <= 3;

Comparing Values

In LIGO, only values of the same type can be compared. Moreover, not all values of the same type can be compared, only those with comparable types, which is a concept lifted from Michelson. Comparable types include, for instance, int, nat, string, tez, timestamp, address, etc. As an example of non-comparable types: maps, sets or lists are not comparable: if you wish to compare them, you will have to write your own comparison function.

Comparing Strings

const a : string = "Alice"
const b : string = "Alice"
const c : bool = (a = b) // True

Comparing numbers

const a : int = 5
const b : int = 4
const c : bool = (a = b)
const d : bool = (a > b)
const e : bool = (a < b)
const f : bool = (a <= b)
const g : bool = (a >= b)
const h : bool = (a =/= b)

Comparing tez

💡 Comparing tez values is especially useful when dealing with an amount sent in a transaction.

const a : tez = 5mutez
const b : tez = 10mutez
const c : bool = (a = b) // False

Conditionals

Conditional logic enables forking the control flow depending on the state.

type magnitude is Small | Large // See variant types.
function compare (const n : nat) : magnitude is
if n < 10n then Small else Large

You can run the compare function defined above using the LIGO compiler like this:

ligo run-function
gitlab-pages/docs/language-basics/src/boolean-if-else/cond.ligo compare '21n'
# Outputs: Large(Unit)

When the branches of the conditional are not a single expression, as above, we need a block:

if x < y then
block {
const z : nat = x;
x := y; y := z
}
else skip;

As an exception to the rule, the blocks in a conditional branch do not need to be introduced by the keyword block, so we could have written instead:

if x < y then {
const z : nat = x;
x := y; y := z
}
else skip;