# Conditional statements · Chromia Docs (concept)

> Rell has two conditional statements: if for branching on a boolean condition, and when for multi-way branching.

Source: https://docs.chromia.com/rell/language-features/statements/conditional-statements/

# Conditional statements

On this page

* [If statement](#if-statement)
* [When statement](#when-statement)
* [Differences from the expression forms](#differences-from-the-expression-forms)

Rell has two conditional statements: `if` for branching on a boolean condition, and `when` for multi-way branching. Both
also exist in expression form, described in
[Conditional expressions](https://docs.chromia.com/rell/language-features/expressions/conditional-expressions/).

## If statement

An `if` statement executes a branch depending on whether its condition is true, with an optional `else` branch. A branch
is either a single statement or a block.

Rell

```
val x = 5;
val y = 10;

if (x == 5) print('Hello');

if (y == 10) {
    print('Hello');
} else {
    print('Bye');
}
```

Chain conditions with `else if`:

Rell

```
function describe(x: integer): text {
    if (x == 0) {
        return 'Zero';
    } else if (x == 1) {
        return 'One';
    } else {
        return 'Many';
    }
}

print(describe(1));   // One
```

## When statement

The `when` statement is similar to `switch` in C++ or Java, but uses the syntax of `when` in Kotlin. It branches on the
value of an expression:

Rell

```
function describe(x: integer): text {
    when (x) {
        1 -> return 'One';
        2, 3 -> return 'Few';
        else -> {
            val res = 'Many: ' + x;
            return res;
        }
    }
}

print(describe(5));   // Many: 5
```

A case matches when `x` equals the case value; comma-separated values in one case match any of them. The `else` case
runs when nothing else matched.

Cases can use both constants and arbitrary expressions. When the values are constants, the compiler checks that they're
unique. With an enum type, values use simple names, not full names.

A form of `when` without an argument is equivalent to a chain of `if ... else if`:

Rell

```
function classify(x: integer, some_value: integer): text {
    when {
        x == 1 -> return 'One';
        x >= 2 and x <= 7 -> return 'Several';
        x == 11, x == 111 -> return 'Magic number';
        some_value > 1000 -> return 'Special case';
        else -> return 'Unknown';
    }
}

print(classify(5, 0));   // Several
```

Cases take arbitrary boolean expressions, and multiple comma-separated expressions in one case are combined with OR.

## Differences from the expression forms

Both constructs behave the same in statement and expression position, including how block arms work, with these
exceptions:

* A conditional statement produces no value, so it doesn't have to be exhaustive. An `if` statement needs no `else`
  branch, and a `when` statement needs no `else` case.
* A branch of a conditional statement is a plain statement or code block, and it produces no value. In expression
  position, an arm is an expression or a
  [value block](https://docs.chromia.com/rell/language-features/expressions/conditional-expressions/#value-block-arms) whose trailing expression
  is the arm's value.

[View this page on docs.chromia.com](https://docs.chromia.com/rell/language-features/statements/conditional-statements/)Content mirrored from the live docs
