## IF and SWITCH: Conditional and Alternative

### IF: Conditional Actions

A conditional action is a construct that performs different actions depending on whether a programmer-specified boolean condition evaluates to true or false. A conditional action takes the form:

              if (boolean_expression)
              {
                    ... actions launched if the condition evaluates to true ...
              }

or

              if (boolean_expression)
              {
                    ... actions launched if the condition evaluates to true ...
              }
              else
              {
                    ... actions launched if the condition evaluates to false ...
              }

Like other actions, a conditional action can be prefixed by a delay. Note that the actions in the if and in the else clause are evaluated as if they are in a group. So, the delay of these actions does not impact the timing of the actions which follow the conditional. For example

              if ($x) { 5 print HELLO }
              1 print DONE

will print `DONE` one beat after the start of the conditional independently of the value of the condition.

The actions of the “true” (resp. of the “else”) parts of a condition are members of an implicit group named `xxx_true_body` (resp. `xxx_false_body`) where `xxx` is the label of the conditional itself. The attribute of `if` are used for these groups.

There are also conditional expressions (sections Conditional Expression and Extended Expression If) that share a similar syntax.

Any kind of Antescofo value can be interpreted as a boolean value, see sections scalar values and data structures.

### SWITCH: Alternative Actions

Alternative actions extend conditional actions to handle several alternatives. At most one of the alternative will be performed. They are two forms of alternative actions, without and with selector, which differ by the way the alternative to execute is chosen.

There are also alternatives expressions (section switch expression) that share a similar syntax in the context of function definitions.

#### Alternative Actions without Selectors

An alternative action without a selector is simply a sequence of cases guarded by expressions. The guards are evaluated in the sequence order and the action performed is the first case whose guard evaluates to a true value. So :

              switch
              {
                   case e₁: a₁
                   case e₂: a₂
                   ; ...
              }

(where `e₁`, `e₂`... are arbitrary expressions and `a₁`, `a₂`... are sequences of actions) can be rewritten in:

              if ( e₁ )  { a₁  }
              else
              {
                   switch
                   {
                        case e₂: a₂
                        ; ...
                   }
              }

If no guard is true, then no action is performed. Notice that several actions can be associated to a `case` : they are launched as a group.

Here is an example where the evaluation order matters: the idea is to rank the value of the variable `$x`. The following code

              whenever ($PITCH)
              {
                   switch
                   {
                        case $PITCH < 80:
                             $octave := 1

                        case $PITCH < 92:
                             $octave := 2

                        case $PITCH < 104:
                             $octave := 3
                   }
             }

uses a whenever to set the variable `$octave` to some value each time `$PITCH` is updated for a value below `104`.

Note that the actions associated to a `case` are evaluated as if they are in a group. So the eventual delay of these actions does not impact the timing of the actions which follows the alternative. And like other actions, an alternative action can be prefixed by a delay.

#### Alternative Action with a Selector

In this form, a selector is evaluated and checked in turn against each guard of the cases:

              switch (s)
              {
                   case e₁: a₁
                   case e₂: a₂
                   ; ...
              }

The evaluation proceeds as follows: the selector \(s\) is evaluated and then, the result is checked in turn with the result of the evaluation of the \(e_i\):

- If `eᵢ` evaluates to a function, this function is assumed to be a unary predicate and is applied to `s`. If the application returns a true value, the sequence of actions `aᵢ` is performed.

- If `eᵢ` is not a function, the values of `s` and `eᵢ` are compared with the operator `==`. If it returns a true value, the sequence of actions `aᵢ` is performed.

The evaluation start with `e₁` and stops as soon as an action is performed for one of the `eᵢ`. If no guard checks true, no action is performed.

For example:

              switch ($x)
              {
                   case 0:
                      $zero := true
                   case @size:
                      $empty := false
                      $zero := false
              }

checks a variable `$x` and sets the variable `$zero` to true if `$x == 0` or `0.0` (because `0.0 == 0`). It then sets the variable `$empty` and `$zero` to false if `$x` refers to a non-empty tab or to a non-empty map (because function @size returns an integer which is `0` only if its argument is an empty tab or an empty map).

#### Search

From here you can search these documents. Enter your search terms below.