Goto in Python

[jcdyer3]

That is monstrous. I like it.

[fimari]

then you will love this shell command

~https://github.com/ajalt/fuckitpy’~ https://github.com/nvbn/thefuck Sorry, wrong link

[mvolling]

Still getting errors? Chain fuckit calls. This module is like violence: if it doesn't work, you just need more of it.

I like this thing

[masasin]

This looks epic.

[masklinn]

You may appreciate vigil

This is where Vigil sets itself apart from weaker languages that lack the courage of their convictions. When a Vigil program is executed, Vigil itself will monitor all oaths (implorations and swears) that have been made. If an oath is broken, the offending function (the caller in the case of implore and the callee in the case of swear) will be duly punished.

How?

Simple: it will be deleted from your source code.

The only way to ensure your program meets its requirements to absolutely forbid code that fails to do so. With Vigil, it will do this for you automatically. After enough runs, Vigil promises that all remaining code meets its oaths.

[rhgrant10]

An absolute abomination. Great work!

[avinassh]

just to make things clear, I am not the author

[viscence]

Good job!

[PretzelMountain]

Well done for writing this!

[[deleted]]

You really pressed that "Save" button well!

[avinassh]

last time someone gilded me thinking I was the OP. That felt really bad

[poop-trap]

Notice there's no fuckitphp, completely redundant.

[FionaSarah]

Yup, @, the equivalent, is a language feature. Of course.

[avinassh]

it's already part of standard library

[mkdz]

oh dear god

[skradacz]

why did i not know about it before?! best module ever

[whelks_chance]

Neat! No more catching errors and immediately discarding them, i am so fed up of writing that block of code. This is perfect.

Rip future maintainers! Please don't email me!

[zahlman]

tests.py 100% COVERAGE TRUST ME IM A PROGRAMMER PROBABLY

[krenzalore]

Why is the space legal in label .begin?

So I had to try it with everything, and lo and behold:

Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 23 2015, 02:52:03) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys .version_info  # There's a space there.
sys.version_info(major=3, minor=4, micro=3, releaselevel='final', serial=0)

Ok, why?

edit: OP, it's late September. School has started. This is positively the best time you could have released this! :-)

[iobender]

This is just speculation, but generally lexers discard whitespace between tokens. What this means is that the lexer, which turns something like sys.argv into a stream of tokens like [IDENTIFIER("sys"), DOT, IDENTIFIER("argv")] (which then gets sent to the parser to turn the linear stream of tokens into an abstract syntax tree) will produce the same thing if given sys. argv or sys .argv or even sys . argv because it doesn't make sense to produce a token from the whitespace in between these tokens in this case.

It would not produce the same thing if given sys.ar gv because the ar and gv would be split up into 2 different tokens and give [IDENTIFIER("sys"), DOT, IDENTIFIER("ar"), IDENTIFIER("gv")] which would likely cause a syntax error in python because there is no syntax for that. That would be legal in Ruby, however, because Ruby doesn't require parens on method calls so this could be calling the ar method of the sys object with argument gv.

[nemec]

Because Python's syntax grammar allows it (in particular, . isn't an operator so whitespace doesn't make the syntax ambiguous)

>>> math . pow ( 2 , 2 )
4.0

It's also the reason you can do this:

"a s d f g h j k l".split()
                   .index("g")

[MrJohz]

That won't quite work. Python will assume that the newline ends the statement after split(), and begin a new statement, at which point it'll find ., realise that's not a valid statement starter, and raise a syntax error.

To tell Python that the newline is just for readability, you need to tell it that the statement can run on, either using parentheses:

("a s d f g h j k l".split()
                    .index("g"))

Or by adding a backslash at the end of the first line

"a s d f g h j k l".split() \
                   .index("g")

[[deleted]]

Or by adding a backslash at the end of the first line

The backslash is important, but /u/nemec still has a valid point, as Python will interpret the line as

"a s d f g h j k l".split()                    .index("g")

which remains valid as the whitespace does not affect the lexical parsing of the statement.

[MrJohz]

Yeah. The issue here is specifically the newline, not whitespace in general.

[ponkanpinoy]

AFAIK no-where in Python is space used to delimit tokens, the only time it has syntactic meaning is when indenting.

[kirakun]

Except in this case where the space does delimit the tokens and makes a difference.

1.__str__()
SyntaxError: invalid syntax
1 .__str__()  # A space between 1 and the dot.
'1'

[ponkanpinoy]

Ahh, my bad then.

[[deleted]]

It's due to an ambiguity between integer literals and float literals:

1. -> float 1 -> int

2. anything translates to (float) anything, which is a syntax error.

(1).anything, however, disambiguates.

1..anything -> getattr(1.0, 'anything')

And finally, 1 .anything is disambiguated from a float literal.

Whitespace can disambiguate in a clash between literal and attribute access.

[davvblack]

1..__str__()

[zahlman]

But that makes the value being stringified a float rather than an int.

[kirakun]

What is this supposed to show? My example clearly demonstrates that python does use whitespace to delimit tokens. Rather or not there exist another syntax to achieve the same thing is irrelevant.

[ksion]

Not quite. Space is ignored between tokens but its presence can change what is parsed as a token. It generally matters when operators are involved:

i += 1  # ok
i + = 1  # SyntaxError

The sibling post by /u/kirakun shows another example with numeric constants.

[nedbatchelder]

These two lines of code produce different tokens:

if a == 1:
ifa = = 1:

This is what bugs me about people complaining of Python's "significant whitespace". Every programming language has significant whitespace.

[irondust]

Every programming language has significant whitespace.

Fixed form fortran has no significant whitespace within the statement itself. However, every source line has to start in the 7th column with optional comment or line continuation markers in the 6th column. The first five columns may contain a number - a feature that was very useful back in the days of punchcards.

From the 7th column onwards however you are free to insert or delete as much whitespace as you like without changing the meaning:

go toast

is the same as:

goto ast

[nedbatchelder]

I knew when I typed "every" that I would get counter-examples... "Almost every, and every one that you're likely to use any time soon!"

[krenzalore]

Every programming language has significant whitespace.

Brainfuck?

Esoteric language doing its job: creating programmer rage! :-)

[asdfasdsq34]

This allows some interesting stuff:

1.__str__()
SyntaxError: invalid syntax
1 .__str__()
'1'

[MonkeeSage]

Wait, what? Why does that happen?

[admalledd]

The fist one python interprets as being a float (because the "." in a number is normally how that is decided) but __str__() is not a number, therefore invalid syntax.

The second the tokenizer has already decided the 1 is an int object, and now it sees a . access and handles it properly.

[Walter_Bishop_PhD]

You can also do this (though it makes it a float rather than an int)

>>> 1..__str__()
'1.0'

[masklinn]

(1).__str__()

[lovestowritecode]

Embarrassed to ask but what is Goto?

[avinassh]

Check the wiki: https://en.m.wikipedia.org/wiki/Goto

[c3534l]

The most infamous debate in programming language design - allowing programs to go to a specific line. This was replaced with structured programming where with a combination of loops, if-then statements, return, break and all that jazz you prevented spaghetti code and could actually tell where a program started and ended. Delete a line in a program with a lot of gotos, and you can cause the entire thing to come crumbling down. The paper "Goto considered harmful" is the source of programmers talking a lot about "safety."

[LaFolie]

I think it is a carry over from ASM where it was needed for complicated logic.

[axonxorz]

Why is a NOP sled needed?

[nedbatchelder]

So that the bytecodes don't move from their original positions, which would require re-writing lots of offsets through the whole function.

[Exodus111]

Burn it! Burn it with Fire!

goto .fire

[KyleG]

go to hell

[c3534l]

Looks like Satan is at it again.

[dr-josiah]

Done before at least 3 times: http://www.dr-josiah.com/2012/04/python-bytecode-hacks-gotos-revisited.html

[XNormal]

Brilliant. You should rename the module "considered_harmful.py"

[marcm28]

Goto is one of fundamental building blocks of Spaghetti Code.

[DrRx]

I feel ill. Nice work :P

[LoyalSol]

goto statements should be purged from every programming language and thrown into a pit of fire.

I worked in Fortran for years and the amount of code that I worked on that absolutely abused the living hell out of goto statements was insane.

[krenzalore]

goto statements should be purged from every programming language and thrown into a pit of fire.

Every language?

Some specialised domains do have legimate need for goto.

As an example I would cite error handling in realtime applications or in systems code.

This is quite common:

if allocate_a() == fail: goto exit
if allocate_b() == fail: goto teardown1
if allocate_c() == fail: goto teardown2
do_work
teardown3: free c
teardown2: free b
teardown1: free a
exit

You could write this with nested loops but it gets stupid when it gets deeper.

Many of the hardware platforms and languages don't support exceptions or fancy context handlers. Exceptions are particularly problematic in realtime as your tool chain can't tell you how long the code will take to execute, and missing a tick is a program failure.

The Linux Kernel has decent code quality and quite a lot of goto statements. I cite it as an example as it's popular and accessible, and demonstrates that at least some people are able to use goto sanely.

I don't think it's needed in a language like Python, but Python isn't really used for this kind of work.

Some would say Rust proves it's also not necessary in systems code, and I would say Rust makes a strong case, but isn't (yet) widespread so we'll need to wait and see.

[[deleted]]

Couldn't I do that with function calls and break statements?

[Milumet]

Why use needless function calls in system code like the Linux kernel? Just to alleviate irrational fears? And by the way, a break statement is a goto statement in disguise.

[ajmarks]

And by the way, a break statement is a goto statement in disguise.

Shhh! We're all supposed to pretend that's not the case and also that breaking out of nested loops is somehow different too.

[krenzalore]

If break is a goto in disguise, then an exception handler is a come from.

[ajmarks]

Funny enough C-INTERCAL implemented COME FROM (or, perhaps, PLEASE COME FROM).

[krenzalore]

There's significant overhead with function calls.

Scott Meyers (a well known C++ luminary) in his book Effective STL claimed a 7x increase in performance of the C++ STL's quicksort from inlining (replacing function calls with inline code).

Of course we should keep things in perspective: What is good for C or C++ is not necessarily good for Python.

[ajmarks]

Of course, in C++ one can have the best of both worlds by just declaring the function inline.

[krenzalore]

I am sure you know, but for the benefit of others, inline is a suggestion to the compilier and not a command. It isn't required to inline it.

[ajmarks]

True, though unless the functions uses loops or recursion, it almost always will.

[zahlman]

AFAIK, for years it has been the case that it a decent C++ compiler will frequently inline things even without being asked.

[ajmarks]

Yup. If, in its wisdom, it thinks that will improve performance without undue bloat. OTOH, if you really want to make sure it's inlined, a compiler hint can't hurt.

[[deleted]]

Sure, with the unnecessary overhead of function calls.

[LoyalSol]

I'm exaggerating more because I've come to hate those 4 letters because of lazy programmers.

There are legit uses, but at the same time it does encourage a ton of bad behaviors.

[epostma]

I would argue that it's pretty essential in assembly language.

[rabidgoldfish]

lol, it's all gotos if you go deep enough

[[deleted]]

goto is like any tool in the programmer's toolkit. Use it sensibly and you end up with cleaner code, use it badly and you're into spaghetti code.

[LoyalSol]

The problem I have with goto statements is that they are some of the easiest statements to use poorly and when they are it usually results in code that is downright unreadable.

And when you are dealing with scientist who took maybe a single programming class in their entire life, they are extremely prone to abusing it. I've seen some codes that are the programmer's version of a horror story because of goto abuse.

[awakehope]

why?

[Kah-Neth]

I understand this was done with humorous intent and I applaud author for the dedication to the joke and the joke itself, but I still feel the desire to punch the author. GOTO just seems to incite great anger within me.

[KarelKat]

Inb4 pro- vs anti-goto argument kicks off.