Hacker News Reader

Comment by pansa2 | Hacker News Reader

The walrus operator hardly changes that example at all:

    if m := re.match(pattern1, line):
        do_stuff(m.group(1))
    else:
        if m := re.match(pattern2, line):
            do_other_stuff(m.group(2))
        else:
            if m := re.match(pattern3, line):
                do_things(m.groups())
            else:
                m = ...

I've found `:=` useful in the headers of `while` loops, but that's about it. The complexity that walrus adds to the language far outweighs its usefulness.

View on HN

The walrus operator allows you to use `elif` there to avoid cascading indentation.

    if m := re.match(pattern1, line):
        do_stuff(m.group(1))
    elif m := re.match(pattern2, line):
        do_other_stuff(m.group(2))
    elif m := re.match(pattern3, line):
        do_things(m.groups())
    else:
        ...

Ah, I missed that. Thanks

...and for me, the benefit is that this is much more clear to me when reading the code. An increasing level of indentation directly maps to needing to keep more in my head. (Sure, in this case you can pattern match and see that there's nothing else, but in general you need to watch out for cases where the else may be doing more than just the next check on the same inputs. )

But the walrus is good even in the absence of a series of matches. It is quite common to need to know more than the boolean "did this match or not?", and so to my eye it is much cleaner to have one line doing the test and the next lines using the results. I don't care about saving characters or even lines. `m = ...match...` immediately followed by `if m:` feels like overhead for the sake of the programming language's limitations; it's extraneous to what I want to express.

Also, I assert that the pattern is better for correctness. It's like Rust's `if let Some(foo) = f() { ... }` pattern: guard on a certain condition, then use the results if that condition is true.

    v = f()
    if v:
        ...use v...

invites injecting code in between the assignment and the test. They're two different things to the reader. And it's not as clear that `v` should only be used in the consequent body.

    if v := f():
        ...use v...

says exactly what it means: `f()` may return a truthy value. If it does, do something with it.

Reply on news.ycombinator.com