Add an exhaustive switch expression?

[lars-reimann]

In order to work enumerations, numbers and union types we could add an exhaustive switch expression with some predefined conditions:

Usage with an enum:

enum SomeEnum {
  A, 
  B,
}

// ...

switch {
   enumInstance is A -> { /* ... */ }
   enumInstance is B -> { /* ... */ }
}

Usage with a numbers:

switch {
  integer < 0 -> { /* ... */ }
  integer == 0 -> { /* ... */ }
  else -> { /* ... */ }
}

Usage with object:

switch {
  obj is Type1 -> { /* ... */ }
  obj is Type2 -> { /* ... */ }
  else -> { /* ... */ } // might not always be necessary if we can prove exhaustiveness
}

[lars-reimann]

Currently, I don't see a use-case for this, since

1. we don't use the language to implement new DS functions,
2. we can encapsulate such conditionals in the functions provided by the library.

[lars-reimann]

Reopening this, since we need this e.g. to transform a column of a table. Based on some conditions, we want to return a new value.

Instead of the

switch (value) {
    shortCondition -> ...
}

we might want to use a

switch {
    condition -> ...
}

This also allows more complex conditions that use multiple values and we don't need to add all the short conditions to the grammar.

[lars-reimann]

Open questions:

1. Keyword: switch vs. when
2. Separator after condition:
   • -> Like expression lambda, but we might want to allow adding statements as well (unlike in expression lambdas)
   • {} Like block lambda, but after a list of statements, we need to have a single expression.
   • : Something new, since it fits neither the block nor the expression lambda syntax. However, we currently use : for manifest types.
3. Should we forbid calls of functions with side-effects (or any impure functions) in switch?