--- id: boolean-if-else title: 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: ```pascaligo group=a const a : bool = True // Also: true const b : bool = False // Also: false ``` ```cameligo group=a let a : bool = true let b : bool = false ``` ```reasonligo group=a let a : bool = true; let b : bool = false; ``` Common operations:
and
Logical and
```pascaligo const logical_and: bool = True and True; ```
or
Logical or
```pascaligo const logical_or: bool = False or True; ```
not
Logical not
```pascaligo const logical_not: bool = not False; ```
=
Equals
```pascaligo const eq: bool = 2 = 3; ```
=/=
Not equals
```pascaligo const not_eq: bool = 2 =/= 3; ```
>
Greater than
```pascaligo const gt: bool = 4 > 3; ```
<
Less than
```pascaligo const lt: bool = 4 < 3; ```
>=
Greater than or equal to
```pascaligo const gte: bool = 4 >= 3; ```
<=
Less than or equal to
```pascaligo const lte: bool = 4 <= 3; ```
&&
Logical and
```cameligo let logical_and: bool = true && true ```
||
Logical or
```cameligo let logical_or: bool = false || true ```
!
Logical not
```cameligo let logical_not: bool = not false ```
=
Equals
```cameligo let eq: bool = 2 = 3 ```
<>
Not equals
```cameligo let not_eq: bool = 2 <> 3 ```
>
Greater than
```cameligo let gt: bool = 4 > 3 ```
<
Less than
```cameligo let lt: bool = 4 < 3 ```
>=
Greater than or equal to
```cameligo let gte: bool = 4 >= 3 ```
<=
Less than or equal to
```cameligo let lte: bool = 4 <= 3 ```
&&
Logical and
```reasonligo let logical_and: bool = true && true; ```
||
Logical or
```reasonligo let logical_or: bool = false || true; ```
!
Logical not
```reasonligo let logical_not: bool = !false; ```
==
Equals
```reasonligo let eq: bool = 2 == 3; ```
!=
Not equals
```reasonligo let not_eq: bool = 2 != 3; ```
>
Greater than
```reasonligo let gt: bool = 4 > 3; ```
<
Less than
```reasonligo let lt: bool = 4 < 3; ```
>=
Greater than or equal to
```reasonligo let gte: bool = 4 >= 3; ```
<=
Less than or equal to
```reasonligo 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 ```pascaligo group=b const a : string = "Alice" const b : string = "Alice" const c : bool = (a = b) // True ``` ```cameligo group=b let a : string = "Alice" let b : string = "Alice" let c : bool = (a = b) // true ``` ```reasonligo group=b let a : string = "Alice"; let b : string = "Alice"; let c : bool = (a == b); // true ``` ### Comparing numbers ```pascaligo group=c 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) ``` ```cameligo group=c 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) ``` ```reasonligo group=c 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. ```pascaligo group=d const a : tez = 5mutez const b : tez = 10mutez const c : bool = (a = b) // False ``` ```cameligo group=d let a : tez = 5mutez let b : tez = 10mutez let c : bool = (a = b) // false ``` ```reasonligo group=d 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. ```pascaligo group=e 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: ```shell 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: ```pascaligo skip 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: ```pascaligo skip if x < y then { const z : nat = x; x := y; y := z } else skip; ``` ```cameligo group=e 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: ```shell 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`. ```reasonligo group=e 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: ```shell ligo run-function gitlab-pages/docs/language-basics/src/boolean-if-else/cond.religo compare '21n' # Outputs: Large ```