Hacker News Reader

Comment by askvictor | Hacker News Reader

The word else implies something different to what it does (IMHO at least). In and if/else clause, the else happens when the primary/expected thing doesn't happen. I would expect that for a loop, an else clause would happen when the loop does _not_ finish normally, or if they loop is empty. I'm sure it's a useful clause in certain cases, but the meaning of the word used is reversed. It might be better use 'then' or something like that:

  for i in l:
     print(i)
  then:
     print("iteration finished without breaking")

View on HN

Here’s why (Hettinger):

> In 1991, “else” was the obvious choice because of the traditional way compilers implemented while-loops: pastebin.com/tY35CTJ4

That is, “if I haven’t finished the loop, GOTO the body.”

He says if he had a time machine he could tell Guido in the future we’re all using structured programming so no one will find “else” intuitive; call it “nobreak” instead: https://m.youtube.com/watch?v=OSGv2VnC0go#

Guido says if he had a time machine he would not have included the feature at all: https://mail.python.org/pipermail/python-ideas/2009-October/...

This whole thing was Knuth’s idea, not Guido’s: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.103...

> Guido says if he had a time machine he would not have included the feature at all

So deprecate it with a runtime warning and remove it after some years.

I wonder if there are some statistics about its usage. I guess it's very low.

Why remove a feature that could be useful? That makes no sense.

Just because it isn't named in a way people find intuitive doesn't mean it isn't useful.

Goto is also useful... See why now?

This comment contains more snark than content, but I'll reply anyway:

Goto is considered harmful, but it's important to recognize the context of that decision rather than parroting the idea. It's not an obvious idea and if the discussion had happened today with modern languages[0] instead it's not at all obvious the same conclusions would be reached.

This write-up does a pretty fair job of translating the original paper to something more modern without a lot of bias. http://david.tribble.com/text/goto.html

[0]: Modern languages of course learned from this paper, so that's not a fair comparison. In fact golang contains a goto, but it behaves well according to Dijkstra's concerns and occasionally results in more readable code. I would be shocked if Dijkstra took any issue with go's implementation.

Unintuitive features that "could be useful" sounds like the antithesis of good design.

And it sounds like a common problem in the software industry.

I find it hard to argue it’s (the else block) any more useful than just using the `else` block’s logic in the try block.

    try:
        import uvloop
        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy)
    except ImportError:
        pass

Does the handler for if the try succeeds need to be in an else, separated from the success logic?

Generally you can't be sure that the second statement does not also raise ImportError, where you do not want to catch it.

You can actually use else for try statements. Doesn't answer question but it's something I learned relatively recently and may help some others.

    try:
        import uvloop
        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy)
    except ImportError:
        pass
    else:
        print("well that didn't work")

I'm not sure about what the message in that print() refers to (else fires if the import succeeded) so here's another example

    $ python3
    >>> try:
          1/0
        except ZeroDivisionError:
          print("exception")
        else:
          print("surprise")
        
    exception
    >>> try:
          1/1
        except ZeroDivisionError:
          print("exception")
        else:
          print("normal")
        
    1.0
    normal

The choice of the name else is unfortunate because it's activated under the same circumstances of a then branch of an "if". Maybe its name should really be "then". That would also look like a .then of a JavaScript Promise, which would make sense nowadays and was obviously impossible to foresee back in 1991. However the name "else" makes sense if it refers to "except": it's what happens when no "except" fire. I still don't understand why it should be "else" for a "for" that succeeded: it should be a "then" there.

In the case of a for loop, you are modeling "a for which did not break". The cases where you want that block are typically when you are looping through a list trying to find something, so "if I found it I broke, else do this default logic".

That's the intended use case but it works also when there is no break

    $ python3
    >>> for i in [1,2,3]:
          print(i)
        else:
          print("completed")
        
    1
    2
    3
    completed

That should be a "then", but admittedly a very useless one.

I agree that for the intended use case "else" is a better choice. It's like the else of the if that failed to find 2 in this code:

    >>> for i in [1,2,3]:
          if i == 2:
            break
        else:
          print("we didn't find 2")

Still "else" doesn't hint much at what's going on, especially if the body of the loop is long. Maybe "nobreak" would make it immediately understandable to everybody? However in the best Python tradition I would make it very explicit, remove the feature from the language and use boolean flags. They are less compact but easier to understand than a feature that (probably) very few people know about.

    >>> we_found_2 = False # this is a valid assertion now 
    >>> for i in [1,2,3]:
          if i == 2:
            we_found_2 = True
            break
        if not we_found_2:
          print("we didn't find 2")

That's also the only way to do it if there are multiple break in the loop on different conditions.

yeah you are right, it should be

print("well that's done")

By the way, try also has an else clause that behaves like the one in if https://docs.python.org/3/reference/compound_stmts.html

It behaves more like the main branch of “if” unless you construe “try” as “try to produce an exception”; outside of “if”, Python’s “else” pretty consistently implies exactly the wrong picture of normal flow.

I guess I wasn’t clear, because my point is generally that moving the logic to an else block in any supported control structures (if, for, try, ...) doesn’t necessarily make it clearer or cleaner.

> Why remove a feature that could be useful? That makes no sense.

It makes sense in the way that a language which is strongly biased to readability and consistent expectations makes sense. It is also how a language which minimizes programmer error makes sense.

For languages that refuse to remove anything, and thus suffer from unnecessary challenges, see C++.

Several things have been removed from C++, including auto_ptr, exception specifications, unary/binary_functions, trigraphs.

I think the extreme difficulty and indeed controversy that the committee stared down when removing trigraphs, which are a useless feature that the vast majority of C++ programmers will never once encounter, speaks well to GP's point that C++ is very conservative in how it removes features. Maybe not JS-level careful. But still.

Of course, JS has a problem in this regard that while it looks like a language, it is also a (de facto) assembler for the browsers. So disabling anything in JS will break lots of sites which will never be fixed.

However as far as programming is concerned, many things have been deprecated through transpilers and linters (for example "==" throws a warning in ESlint).

Most legacy cpp features and language semantics will never be removed, despite what many prominent voices in the community think.

>Why remove a feature that could be useful? That makes no sense.

Cleaning up a language "makes no sense"?

Besides "could be useful" can be said for anything. Features should prove their usefulness (and in this case Guido regrets even adding it), we don't just keep them around in the off chance that they might be. That's hoarding.

You want a major version bump on very widely used software just to remove something that causes a minor confusion on the rare occasion it is used? In what world does that sound like a good idea?

It's one thing to make a change like this along with a bunch of other breaking changes, but there is no way this justifies breakage by itself.

>You want a major version bump on very widely used software just to remove something that causes a minor confusion on the rare occasion it is used?

No, I want a deprecation warning, and an eventual removal when for 4.0 lands.

>In what world does that sound like a good idea?

In a world where we don't pile crap upon crap forever, like with POSIX, X-Windows, or C++.

There are reason those systems are still widespread in use today, strong compatibility is one of them.

There are also reasons those systems have tons of accidental complexity that frustrate users and wastes endless workhours. Strong compatibility is one of them.

> Why remove a feature that could be useful? That makes no sense.

Everything has a cost. In maintenance, in documentation, in support, in limiting the design space or constraining further development for other reasons (performance, for example).

Nothing is truly free. Everything has to be balanced regarding costs and benefits.

Because readability counts, and id at the core of Python.

Here's the first sentence of the spec of the Scheme programming language:

"Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary."

It's interesting how Lisp languages get criticized for lack of maintainable because of their power to let you essentially add new features, but then every popular modern language with the exception of Go piles on new features over time.

Go is still relatively young.

That grand statement is made possible by banishing needed Scheme features into numerous SRFI documents, and into implementations.

> So deprecate it with a runtime warning and remove it after some years.

After the Python3 brouhaha, I think people are very cautious about making backwards incompatible changes to the language, even with a deprecation warning.

If it was done together with the rest of Python3 changes then it could have been approved, but not any more.

As Guido suggests, adding the warning to pylint and other style checkers, but keeping compatibility is much easier.

I whipped up something to test that: https://gist.github.com/gvx/667efcd263b18d313801c1b1ffa41509

Running that on my personal projects folder gives me the following result:

  for elses 60
  for loops 1815
  # modules 598
  # skipped 2

Thanks. I run your program on a couple of projects of a customer. I'm not the only developer.

    for elses 0
    for loops 428
    # modules 673
    # skipped 26

    for elses 99
    for loops 6058
    # modules 2016
    # skipped 286

Runtime warning on what channel without breaking compatibility?

You could print the warning out to STDERR when the Python runtime finishes parsing and before it executes your script.

This will likely break some people's workflows, but honestly, it's the de-facto way of notifying users of a deprecation in many Python frameworks (Gunicorn did this recently with gunicorn-paster vs gunicorn --paste).

They could also include this in a "What's new in Python (4?)" since this is unlikely to be introduced in a minor version bump.

I'm not categorically against deprecation warnings. Isn't gunicorn a command line tool? I can respect such warnings in a tool or even sometimes a library, but not in a language interpreter. The user should as closely as possible be in full control of the streams in those cases, and any standard error output that isn't an exception (i.e. either deliberate or resulting from a programmer error) should stay the hell off.

The proper way to handle this is of course to introduce a new semver major version. No need for deprecation warnings because incompatibility is expected.

Actually I wouldn't like it deprecated, not because I use it often or like it very much. In fact, I myself found this feature counterintuitive at first brush.

Deprecating any feature without any strong reason makes me irritateted and I don't find any strong reason for doing so.

The thing to do here is deprecate 'for-else' in favor of 'for-default' which is much clearer like in a case block.

'for-else' never needs to be removed but the code cleanup will happen over time.

If Guido would not have included the feature at all, why did he not remove it from Python 3? That would have been the perfect opportunity.

Python 3 had it's first release in 2008, that thread was from 2009. Probably didn't even really think about it before then. (the more you know)

> He says if he had a time machine he could tell Guido in the future we’re all using structured programming

Sounds like if people were not already coding C, C++ and Pascal when Python was invented...

I don’t like this feature of Python, but I have come to disagree with what you mention, even though I understand your point.

For example, from [0], it’s described as:

> “The else clause is only executed when your while condition becomes false. If you break out of the loop, or if an exception is raised, it won't be executed.”

So it is very analogous to an if / else statement: the “else” after a for or while loop directly means the conditional of the loop evaluated to False.

If the program never reaches a state in which the loop conditional evaluates to False, then the else block is not entered.

Just like: only when the conditional of an if statement evaluates to False will the else block be entered.

After I understood this, I started to think that break is really the more problematic thing, because it means more like a goto sort of jump, abandoning the status of the variables governing the loop condition.

But again, I don’t like these loop-else features. They definitely violate least surprise for most people reading the code.

[0]: < https://stackoverflow.com/questions/3295938/else-clause-on-p... >

> So it is very analogous to an if / else statement: the “else” after a for or while loop directly means the conditional of the loop evaluated to False.

...how is that supposed to apply to "for i in l"? What is the conditional?

I don't think of python for statements as involving conditionals at all; you seem to be describing a while/else rather than a for/else.

Think along the lines of "for (l = lst.iterate(); l != null; l.next())".

This is right; it’s the StopIteration exception (which is fundamental to what a for loop does in Python).

Not saying is absolves the for/while else syntax, but it’s still using the expected iteration constructs.

Wouldn't that imply that the equivalent of a while/else loop would be a for/except loop, not a for/else loop?

As a matter of trivia, probably not. The iteration mechanism just happens to check for StopIteration, and does not automatically handle any other type of Exception, which would require a usual try block.

So StopIteration can be thought of as an equivalent idea to “emptiness” of an iterator, either an empty container, an exhausted generator, etc.

And since emptiness is most often handled as falsiness in a bool context, it’s in some sense the natural notion of a “false” iteration condition.

This is all incredible mental gymnastics though. But (speaking as someone who loves Python) there’s unfortunately a lot of that in Python.

That's deeply "unpythonic"

> ...how is that supposed to apply to "for i in l"? What is the conditional?

Presumably there is a conditional in the loop body that decides whether or not to break:

  for i in l:
    if ...:
      break

Think of the else clause as being what to do if nothing takes the if in the body.

Same for while...else. You'd only be using an else on a while if there was something in the while that could break, so it is whether or not the conditional that controls that decision happens or not that determines whether the else path is taken.

Huh? Judging by every other comment in the thread, the point of for/else is that breaking does not trigger the else clause. The else clause is triggered when the loop condition is tested and fails... but Python's for doesn't have a loop condition.

No, an explicit break skips the else clause and the else clause is evaluated if and only if the iterator in the loop raises a StopIteration exception (i.e., it's exhausted). For example, this code will still evaluate the else clause even though the break statement is always true, because iter([]).next() throws StopIteration immediately:

    for i in []:
        if True: break
    else: print("Foo")

while this will not:

    for i in [1]
        if True: break
    else: print("Bar")

The "conditional" in a for loop is that the iterator (l in your example) raises a StopIteration exception. I don't really like calling it a conditional though, because it's actually handled as an exception. I guess you could think of the condition being "are there any items remaining in l? If 'no' then evaluate the else clause." I've always considered the else clause on a for loop's proper purpose being to catch erroneous cases, for instance if you try and loop over files in an empty directory. Or if you have no matches searching line by line over a file. Etc.

You're right, technically, but the way tzs thinks about it can still be correct if one thinks about it this way: the if statement in your first loop is mathematically true, but it is never executed because [] is of course empty. It's not about whether the inner if ...: break statement's conditional can evaluate to true.

A lazy way to think about it is that way, but as long as you remember that it's what occurs when there is no break it's fine.

My point is mainly that it's determined by the loop iterator, not the body of the loop; the else clause being skipped if you explicitly break is a consequence of this, not a cause. This is important because there is another case that can terminate the loop early- the else will not be evaluated if the loop body throws an exception (even if it is caught):

    try:
        for i in range(5):
            raise Exception
        else:
            print("Foo") # still won't be evaluated
    except:
        print("Loop aborted")

The vacuous case (iterating over []) is also kinda important if you're iterating over something of variable length in case you need to distinguish between "loop terminated normally" and "input was empty". "else" can't really tell these two cases apart.

That's a very good point. I guess to me, I've already internalized the "else stands for when the loop doesn't terminate early ever" but for people new to the language or feature it might be confusing. The fuzzy reasoning above was my original way of having it make sense in my head but I've since internalized the logic of how it really works.

Yeah the thing I see that sometimes confuses people is that they think "else" works kinda like "finally" or "__exit__" in a context manager, where it's guaranteed to be called even if an exception is raised. I don't think there's anything wrong with thinking about it like you say, just need to be aware of a few edge cases.

Else in a for loop is kinda obscure anyway, so its importance is marginal. It is really handy for a couple specific patterns, but I've only ever found myself using it a handful of times (and I write a lot of Python).

If python used C style loops rather than pushing iterators/generators so hard, I would buy that reasoning. But where's the conditional statement in `for i in range(0,10)`?

Now, clearly there is a check to see if it's still producing values. But it's intentionally hidden from a surface-level reading of the code.

Naming a control structure `else` when it intentionally does not have a clear conditional tied to it is odd to say the least.

But it's worse than that- the else clause is supposed to be the normal flow of the program. Programming introductions (fresh in the minds of many who use Python as it's targeted as user-friendly) often stress the fact that in an if/else statement only one or the other block is executed. But this flips that idea upside-down.

It would be the implicit StopIteration exception from the resulting iterator, but I completely agree this can easily be seen as inconsistent / surprising, which is among the reasons why I don’t like it.

Thanks for the clarification, I don't use python very often myself. That does underscore that there's really not a normal conditional there though.

I don't think it violates any important least-surprise principle. You might be surprised to see it used -- but you don't get surprised when the code behaves how the documentation says it will.

Least surprise doesn't mean everything is documented. It means things behave analogously to everything else

But language attempts to resemble spoken language precisely so we don't have to rely on the documentation alone. We use if/else, not "xan/ka" because we want to leverage the existing meaning of those words.

In the early stages of Perl 6 design I requested a for/else feature where the "else" block fired if and only if the for loop had never been entered...the opposite of how this works. Being literally the opposite of how I would write it qualifies as surprising to me.

Naming is useful for getting adoption but not when you already know the language. And in your case you might have been surprised, but that's because you'd take a guess at what the feature does instead of finding out.

(I don't think for/else is the best option, gotos are. It's just not a harmful feature, the way other aspects of Python are.)

I'm a strong python advocate and rarely use for/else for this exact reason. It makes more sense to me for it to be the other way (your way) around. I always add a comment on the else when I do too, to ensure that future readers don't make the same mistake.

I agree. It's seldom something I've used in my scripts/small projects for this exact reason.

It should also be noted that there is a `while-else` compound statement as well, wherein using a `break` immediately exits the loop, without executing the `else` clause [1].

[1] https://docs.python.org/3/reference/compound_stmts.html#the-...

Yeah, it really feels (almost in a physical sense) like an anti-pattern... I have to force my fingers to write it.

I’ve never found a compelling reason to use this construct (or the analogous `while...else` construct). But then again, I rarely find myself using `else` with `if` either...

The Handlebars template engine works the way you're talking about. The "each" helper loops through an array. You can put in an "else" block for when the array is empty.

  {{#each paragraphs}}
      <p>{{this}}</p>
  {{else}}
      <p class="empty">No content</p>
  {{/each}}

--- https://handlebarsjs.com/builtin_helpers.html

I like this ternary approach.

Django templates also have such a clause but it is named "empty" instead of "else".

> I would expect that for a loop, an else clause would happen when the loop does _not_ finish normally, or if they loop is empty

Suppose it worked like that and you had this code:

  for i in l:
    A()
    if B():
      break
    C()
  else:
    D()

Wouldn't that be equivalent to:

  for i in l:
    A()
    if B():
      D()
      break
    C()

What your suggested else is doing is providing a place to put code to execute after a break in the loop, but we already have a place for such code: immediately in front of the break in the loop.

The only place that comes to mind where this would be useful is situations where you there is more than one

  if ...:
    D()
    break

in the loop. With your suggested kind of else, you could move all the D()'s to an else after the loop.

It makes sense to me in the specific context of using it to respond to an item not being found in a list. In other contexts, I agree that the word is not a good fit.

When I thought about this, I first agreed, then I thought that from the perspective of the interpreter it is else as in checks the condition and then goes to else if the condition is false. So I think it is not so much unintuitive, as it is consistent in a not immediately intuitive way.

Agree completely. I think for-else is same as if-else in that if the condition satisfies then it executes the main loop and if not it executes the 'else'.

Yes, "then" would have been a better choice. But "then" isn't a keyword in Python.

"else" is used with try blocks to indicate the exception didn't take place. It makes more sense there, because it follows the "except" sections.

Agreed. I can see where the design is coming from, but this coupled with the reliance on indentation to delineate scope means that it’s really visually confusing — I expect the `else` to correspond to the `if` statement when I see it in the context of the given example. It’s not strictly ambiguous, but it’s certainly an impediment to readability.

I am not a native speaker but I think "done" or "finished" is better. "else" is a counterpart of "break". It assumes people must think of "break" whenever they see a "for", which is not always the case. We refer to this weirdness as Pythonic.

I like it! Makes perfect sense, it's short, and since then "belongs to" the for, it makes sense for a break or exception to break out of both. On the other hand, under your suggestion someone still has to learn the meaning of then, it's not fully explicit. Since "Explicit is better than Implicit", if we are not optimizing for brevity I have these two suggestions that are more explicit alternatives to your then suggestion.

--------

Suggestion 1 (horrific suggestion):

Call this keyword finally. This implies that no matter what the finally part will execute. This is like defining never as a synonym for true, so that if(never) always executes. Why would anyone ever do that!! Hardly any choice in a design is as bad as explicitly saying something different from what will happen. So this is a terrible suggestion.

--------

Suggestion 2 (good suggestion):

Call this keyword ifthru. (Thru being an abbreviation for through). As it says, this one will run if the loop completed. Another way to read it is if execution continued "through" the end.

So your example might read:

  for i in l:
     print(i)
  ifthru:
     print("iteration finished without breaking or exceptions")

This is extremely explicit about the condition. I picked it to be short while remaining explicit. The elif keyword is an existing precedent for mispelling for the sake of brevity.

It also alerts the reader that logically there is a condition here. After all, semantically every block could start with the "then" word in English. Semantically, when you break you could also be considered to be "through" however in this case the ifthru keyword wouldn't serve any purpose at all, since it could just be on the next line. The "if" alerts the reader that there's a condition here..

I hope you'll agree that my second suggestion is pretty good :)

The else makes perfect sense. The for loop keeps going as long as the condition is true. When the condition is false, it exits the loop without breaking. Else acts on the condition being false.

But the else fires in Python if the loop does not break. It sounds like you're saying the opposite. Even if you aren't, I think we can agree it's potentially confusing.

This is the correct place for it to do so. Break skips the check entirely. If the for loop exits normally, the condition was false.

You understand that it can be a confusing code construct though, right? Even in your comments I'm kind of confused at your meaning because you said:

> When the condition is false, it breaks.

And then you said:

> If the for loop exits normally, the condition was false.

I have updated that comment, a normal loop exit is not the same as a break.

I can understand how it can be confusing, but the inverse would not make any sense.

Another way to look at a for loop is a fancy while loop that sets a variable by some function. Every loop iteration that function is ran. If the function fails, the loop exits.

This is infact how they work. https://anandology.com/python-practice-book/iterators.html#t...

If next() fails, that is when the loop exits.

What you say implies that you’d be happy with

  while(condition()):
      ...
  else:
      ...

But that makes even less sense since `while` is semantically like an `if` with continuation. GP is right, it’s rarely used, because the syntax clashes with the natural reading of the code.

while ... else is a good comparison, yes. and it exists exactly like that in python: if the condition check turns false, the else branch is executed.

They probably used the word "else" to cut down on the number of reserved keywords, and for consistency with try / except / else.

It is consistent with the idea that it provides an alternative clause to a failing loop guard.

Using the much clearer C syntax as pseudo-code, suppose we have this:

  for (;;) {
    if (loop_guard()) {
      body;
    } else {
      alternative;
      break;
    }
  }

We can imagine an extension to while which lets us rewrite it like this:

  while (loop_guard()) {
    body;
  } else {
    alternative;
  }

Based on this framing, there is justification in calling it else.

The runs counter to an intuition which would like it to be this:

   if (loop_guard()) {
     while (loop_guard()) {
       body;
     }
   } else {
     alternative;
   }

I.e. not an alternative in the face of the failed loop guard on every iteration, but just the first loop guard test: an alternative to the loop when no iterations take place.

It always made sense to me since I think about these constructs as the loop searching for something (and breaking if it finds it) and the else running if nothing was found.

    for item in list:
        if search_condition:
            found_item=item
            break
    else:
        found_item=default_item

As an alternative, you could do this:

found_item = next((item for item in list if search_condition), default_item)

Fwiw my initial assumption (as a non python dev) was that the else statement would execute once the loop condition was false (including the case where loop condition was never true).

Honestly it is not a big deal, just remember the else is for the break, not the for. Then it reads naturally: for this break else do that.

I agree that the word 'else' is confusing here. To me, it suggests that one thing is done, or the other, but not both. Python's try..except..else follows this pattern, but for..else and while..else do not, for some reason.

Every time I go to use for...else, I need to look up what the behavior is, I can never remember if it's hitting the break or not hitting the break. That being said, python always tries to minimize the number of keywords, so re-using else makes more sense then introducing a whole new keyword for a niche usecase.

...and then you realize that's why you shouldn't use it, right?

The way I remember it is that it makes sense in loops that search for something in an iterable. Such loops break when they're successful, and so it makes sense for the code in the else clause to run when the loop was unsuccessful.

"Then" implies that the associated code will always run after the for loop completes, which isn't true either. Maybe "complete" is a decent choice. I'm sure language keywords are an issue here, too.

it should be called nobreak

that explains exactly what it does

Reply on news.ycombinator.com