# Conditional Expression

`Expr := "if" Expr "then" Expr "else" Expr "end"`

The condition must be a formula, that is, an expression of arity 0.

If the condition is `true`

, then the value of the expression is the value of the expression in the `then`

branch, and the expression in the `else`

branch is not evaluated.
Otherwise the value is the value of the expression in the `else`

branch, and the expression in the `then`

branch is not evaluated.
The `then`

and `else`

branches can have arbitrary arity.

The expression `if e1 then e2 else e3 end`

has the same meaning as `(e1, e2); (not(e1), e3)`

.

Examples:

`if 1 < 2 then 'a' else 'b' end`

This gives `('a',)`

.

```
def p = 1
def q = 2,3
def r = 4,5
def output = if p(1) then q else r end
```

This gives `(2, 3)`

.

`def output = if p > 1 then q else r end`

This gives `(4, 5)`

.

```
def p = 1; 2; 3
def output = if x = 1 then 'a' else 'b' end for x in p
```

This gives the following:

```
(1, 'a')
(2, 'b')
(3, 'b')
```

Conditional expressions can be nested, as shown in the example below, which defines a relation that computes the factorial of a positive integer.
The relation is named `my_factorial`

to avoid conflict with the function `factorial`

in the Standard Library.
See also the annotation `@ondemand`

.

```
// read query
@ondemand
def my_factorial[n in Int] =
if n < 0 then false
else if n = 0 then 1
else n * my_factorial[n - 1]
end
end
def output = my_factorial[5]
```

In Rel such definitions are usually expressed in a more idiomatic way:

```
@ondemand
def my_factorial[n in Int] = 1, n = 0
def my_factorial[n in Int] = n * my_factorial[n - 1], n > 0
```

This version features the infix comma operator, which denotes the Cartesian
product of its arguments.
If `n = 0`

is `true`

, then the body of the first definition will be `1`

, which is the Cartesian product of `{(1,)}`

and `{()}`

.
In that case the body of the second definition will be the empty relation,
because `n > 0`

will be `false`

, that is `{}`

, and a Cartesian product of
anything with an empty relation is an empty relation.

Similarly, if `n > 0`

, then the body of the first definition will be the empty relation, and the body of the second definition will be the relation produced by the expression that precedes the comma.

You can think of `n = 0`

and `n > 0`

as *guards* that allow each of the two definitions to be used only in some particular situations.
If these guards are mutually exclusive, then the effect is a more concise formulation of what can be achieved with a conditional expression or nested conditional expressions.

Note that, in general, these guards do not have to be mutually exclusive.
If they are not, then both definitions will contribute to the result for a given value of `n`

, and the effect may be different from that of a conditional expression.
In this particular example, however, changing `n > 0`

to `n >= 0`

will not affect the result, because `my_factorial[-1]`

will produce an empty relation.

Next: Constants