# Julia 2.0: superSwitch or SuperCase ... or generalized if-then-else statement

Julia doesn’t have a switch/case statement. I recall reading the past that @StefanKarpinski tried to interest the other developers back in the day, but couldn’t get them excited about it. That makes some sense – early on, you have a list of 20,000 things you wan to do, and the language already has if-then-else, so switch/case would be a low priority.

However, in the drive to Julia 2.0, let me make the case [sic] for the a switch-case statement.

Except - I don’t want a switch-case statement as usually implemented.

Let’s look at the typical switch-case syntax:

switch (age) {
case 1:  printf("You're one.");            break;
case 2:  printf("You're two.");            break;
case 3:  printf("You're three.");
case 4:  printf("You're three or four.");  break;
default: printf("You're not 1,2,3 or 4!");
}


The problem I have with it, and the reason I rarely use it (in languages that have it), is that it’s too limiting. All the cases are constants you’re comparing against the variable.

According to Wikipedia, switch-case statements come in two semantic forms: structured and unstructured. The example above is “unstructured,” where cases are treated as labels within a single block, and the switch functions as a generalized goto. The second form, “structured”, is a generalized if-then-else, with any number of branches, not just two. The Wikipedia also notes two forms, one which requires a “break” statement after each evaluated expression, and those that assume a “break” and you have to put in “continue” if you want it to fall through.

It’s the structured form I’ve always wanted in a language. Usually, I want to operate on ranges of the variable, not single values.

What I would like is switch-case compares to is an expression (expr1, which evaluates to true/false), then if it evaluates to true, executes another expression (expr2, which could be anything). This is really just a generalized if-then-else, with fallthrough in some cases. I could swear one language I used let me do this, but perhaps it’s just mis-memory: I usually wanted to do this, but went away disappointed.

Generic syntax is

Switch(var;
expr1 : expr2
expr1 : expr2
etc.
)


Where expr1 has to evaluate to true/false, and expr2 can be anything. If you want fallthrough, you put continue after expr2.

We’ve all probably encountered a math function that is defined like this:

f(x) = \begin{cases} -1 & \text{if } x < 0 \\ \infty & \text{if } x = 0 \\ 1 & \text{if } x > 0 \end{cases}

This would be a natural for my superSwitch/SuperCase:

function delta(x)
Switch(x;

x < 0 : y = 0

x == 0 : y = Inf

x > 0  : y = 0

)

return y

end


Of course, after the “:” could be many more statements. This example also illustrates an “assumed break statement” after Expr2; if one wants it to fall-through, one puts in “continue”:

function controlmachine(Θ)

switch(Θ;

Θ ≥ 120 && θ < 330         : θ = θ-90
continue

θ ≥ 0 && Θ < 30 || Θ ≥ 330 : direction = "East"
speed = 5
force = 2
# assumed break here

Θ > 30 && θ < 60           : direction = "NorthEast"
speed = 6
force = 3
# assumed break here

θ ≥ 60 && Θ < 120           : direction = "North"
speed = 5
force = 1.3
)                                # assumed break here

return (direction, speed, force)

end


Of course, what is the variable doing in the Switch statement at all?

switch(Θ;


It doesn’t need to be there, as the variable is in each condition (expr1). In fact, you could have multiple variables in the conditions. Again, it’s a generalized if-then-else with fallthrough in some cases.

So don’t call it Switch or Case. Call it something else. BlockIf or Examine:

    BlockIf(

Θ ≥ 120 && θ < 330         : θ = θ-90
continue

    Examine(

Θ ≥ 120 && θ < 330         : θ = θ-90
continue


Now, clearly, this is a convenience syntax for the user. It could, of course, be implemented as if-then-else statements.

However, it would be very convenient. I run into this pattern a lot – having to execute different statements based on a range of a variable. The advantage to the user is the ease of construction and the clarity of the presentation.

Note I have ignored the scoping rules. I would assume the scoping rules would be the same as they are for if-then-else (indeed, I would expect the compiler to deconstruct the syntax into a series of if-then-else constructs).

Now, I’m not a computer scientist. The developers may have very good reason not to do something like this. However, I would love it if they did. It would be a distinctive feature of Julia, and I would use it a lot.

Thanks for taking time to consider it.

4 Likes

I think the advanced version of this feature is MLStyle.jl’s pattern matching.

@match data begin
pattern1 => result1
pattern2 => result2
...
patternn => resultn
end


This is under active development, so I wouldn’t rush to add it to the language.

6 Likes

One thing that is somewhat unfortunate with this design is that the C style switch statement can generate an O(1) lookup table, which can be really nice in some cases.

4 Likes

That is something that can compiler should be able to do these days. Also it’s basically impossible/undesired to have a equivalent syntax as C switch in julia (way too restricted).

2 Likes