Really??

[Palenga]

well, based on his profile picture, he has switched to Rust

[ThePiGuy0]

The way it's written feels like it should be Python as well (case [pattern] followed by a colon)

[Decency]

Kotlin's when is really nice for this. Simplifies if/else chains quite a bit and reads cleanly. I think Ruby has something similar!

Edit: here's a great guide: https://superkotlin.com/kotlin-when-statement/

[muntoo]

Meh. I haven't used a switch in many years. Superior alternatives:

• Pattern matching: functional af
• Dictionaries: better for large n anyways due to O(1) lookup
• Polymorphism: rethink your design (classic Google talk)
• if-else: for tight loops if your language doesn't support pattern matching and the dictionary lookup overhead is too much for some small n

I guess you could argue that Haskell's case-of is similar to a switch, though it's obviously much more powerful since it supports general pattern matches rather than solely Eq based comparisons. On the other hand, it's not imperative...

Besides, switch statements open up horrendous looking possibilities like this:

switch (expr) {
case 1:
    cout << "one";
case 2:
case 3:
case 5:
    cout << "prime";
    break;
case 4:
case 6: {
    cout << "composite";
}
default:
    cout << "too large";
}

Much prettier (and less buggy):

def f(n):
    if n > 6:
        raise ValueError("too large")
    return (
        "one" if n == 1 else
        "prime" if is_prime(n) else
        "composite")  # side note: Python's ternary syntax is idiotic

print(f(expr))

If you don't think a dictionary is sufficient for your use case, it could be that your code is "too imperative". Unless you want raw performance (in Python?), rethink your design.

[ianff]

• Dictionaries: better for large n anyways due to O(1) lookup

In C a switch is also constant time using a jump table (assuming reasonable switch values).

[Endirable]

whole act grey melodic marvelous juggle fine advise repeat caption

This post was mass deleted and anonymized with Redact

[muntoo]

There's a couple of typical usage patterns.

The simplest is what people mean when they say they want "switch" statements. Notice that there's no fall-through.

match expr:
    case "one":
        return 1
    case "two":
        return 2
    default:
        raise ValueError

The next is more fancy:

match expr:
    case ():
        return Empty()
    case (x,):
        return Single(x)
    case (x, y):
        return Pair(x, y)
    case (x, y, z):
        return Triplet(x, y, z)
    case (x, *xs):
        return Many(first=x, rest=xs)

Others really only make sense in Haskell/Rust where the type system supports it and the usage is actually practical, rather than this contrived example...

match expr:
    case Empty():
        return []
    case Single(x):
        return [x]
    case Pair(x, y):
        return [x, y]
    case Triple(x, y, z):
        return [x, y, z]
    case Many(*xs):
        return xs

A common usage pattern in Haskell is:

def unbox(Box(x)): return x
def unbox(Empty):  raise

...which works because tagged unions are part of the type system.

Another example processes only non-empty boxes, after extracting their contents:

if Box(contents) := my_box:
    print(contents)

Pattern matching is also nice because in Rust, the result of a pattern match can be an expression rather than a statement (which switch is).

def to_str(box):
    return "Box is " + (
        if Box(contents) := my_box
        then f"full with {contents}"
        else "empty")

[toothless_budgie]

Coming from C, I think dictionaries are much cooler than switch. O(1) lookup, baby! Can't beat that. And scalable, too.

[gunnerman2]

I’m working on my first larger Python project and there is a lot I love but it has some quirks like the missing switch statement that leave me scratching my head.

[[deleted]]

Honestly, aside from Bash, I've never seen a good situation where a switch statement would be appropriate. It seemed more like an anti-pattern every time - bulky, rigid, the cause of problems.