Version: 0.41.0

# Booleans and Conditionals

## Booleans#

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

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

Common operations:

&&
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#

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

### Comparing numbers#

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.

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

## Conditionals#

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

type magnitude = ["Small"] | ["Large"]; // See variant types.
let compare = (n : nat) : magnitude => {
if (n < (10 as nat)) { return Small (); } else { return Large (); };
};

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

ligo run evaluate-call
gitlab-pages/docs/language-basics/src/boolean-if-else/cond.religo '21n' --entry-point compare
# Outputs: Large

## Switch Statement#

JsLIGO also supports branching of control flow via the switch statement.

let quarter = (n : int) : string => {
let output = "";
switch (n) {
case 1:
case 2:
case 3:
output = "Q1";
break;
case 4:
case 5:
case 6:
output = "Q2";
break;
case 7:
case 8:
case 9:
output = "Q3";
break;
case 10:
case 11:
case 12:
output = "Q4";
break;
default:
output = "Invalid month."
};
return output;
}

The switch statement takes an expression and tries to find a `case` which matches the switch expression, If a matching `case` is found, the statements of the matching case are executed untill a `break;` statement. If no `break` is found the control falls through to the next `case` or `default`. If no matching case is found the statements of the `default` case are executed.

A few gotcha's about the switch statement

1. A switch should have at-least one `case` or `default`.
2. If a `default` case is provided, It should be the last case.
3. Conditional `break`'s are not supported i.e. `break` inside a `if-then-else`.
4. In case of nested `switch` statements, the inner `switch` should not contain a `return`.

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

ligo run evaluate-call
gitlab-pages/docs/language-basics/src/boolean-if-else/switch.jsligo '5' --entry-point quarter
# Outputs: "Q2"