ligo/gitlab-pages/docs/language-basics/boolean-if-else.md

id	title
boolean-if-else	Booleans and Conditionals

import Syntax from '@theme/Syntax';

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

let a : bool = true
let b : bool = false

let a : bool = true;
let b : bool = 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;

&&

Logical and

let logical_and: bool = true && true

||

Logical or

let logical_or: bool = false || true

!

Logical not

let logical_not: bool = not false

=

Equals

let eq: bool = 2 = 3

<>

Not equals

let not_eq: bool = 2 <> 3

>

Greater than

let gt: bool = 4 > 3

<

Less than

let lt: bool = 4 < 3

>=

Greater than or equal to

let gte: bool = 4 >= 3

<=

Less than or equal to

let lte: bool = 4 <= 3

&&

Logical and

let logical_and: bool = true && true;

||

Logical or

let logical_or: bool = false || true;

!

Logical not

let logical_not: bool = !false;

==

Equals

let eq: bool = 2 == 3;

!=

Not equals

let not_eq: bool = 2 != 3;

>

Greater than

let gt: bool = 4 > 3;

<

Less than

let lt: bool = 4 < 3;

>=

Greater than or equal to

let gte: bool = 4 >= 3;

<=

Less than or equal to

let 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

let a : string = "Alice"
let b : string = "Alice"
let c : bool = (a = b) // true

let a : string = "Alice";
let b : string = "Alice";
let 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)

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

let a : int  = 5;
let b : int  = 4;
let c : bool = (a == b);
let d : bool = (a > b);
let e : bool = (a < b);
let f : bool = (a <= b);
let g : bool = (a >= b);
let 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

let a : tez  = 5mutez
let b : tez  = 10mutez
let c : bool = (a = b) // false

let a : tez  = 5mutez;
let b : tez  = 10mutez;
let 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;

type magnitude = Small | Large // See variant types.

let compare (n : nat) : magnitude =
  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.mligo compare '21n'
# Outputs: Large

Notice that, as in OCaml, in CameLIGO, if a conditional has a branch else (), that branch can be omitted. The resulting so-called dangling else problem is parsed by associating any else to the closest previous then.

type magnitude = Small | Large; // See variant types.

let compare = (n : nat) : magnitude =>
  if (n < 10n) { 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.religo compare '21n'
# Outputs: Large