Remove goto

[thejoshwolfe]

Please everyone post links to your zig code that uses goto, so we won't remove the feature. Alternatively, post links to C code that uses goto, so we can assess if there's a more zig-like way to do it, or if goto is really the best solution for those cases.

I want real actual code here, not pseudocode examples. Please link to open source projects.

This discussion started in #346.

For reference, here's how you can do without goto:

• use defer for the try-finally pattern.
• use %defer for the cleanup-on-error pattern.
• use while (true) { switch (state) { ... for cases where you want computed goto. Here's some existing discussion on that: labeled loops, labeled break, labeled continue #346 (comment)
• use labeled break to jump forward and labeled continue to jump backward, placing loops where necessary. This is the plan for the C-to-Zig translator. This is the ugliest solution, but should always work when all else fails.

[PavelVozenilek]

Unless there are local functions with access to parent stack defer cannot do the following:

if (error condition) goto error;
...
if (some other error condition) goto error;
...
if (yet another error condition) goto error;
...

error:
   // nontrivial error handling code

defer would need to duplicate all the error handling code, or one has to create a top level function and pass needed parameters there.

[andrewrk]

Your example code can be implemented with defer like this:

fn foo() -> %void {
    %defer {
        // nontrivial error handling code
    };
    %return errorCondition();
    %return someOtherErrorCondition();
    %return yetAnotherErrorCondition();
}

[andrewrk]

Here's another way to write it:

fn foo() {
    e: {
        if (error_condition) return :e;
        if (some_other_error_condition) return :e;
        if (yet_another_error_condition) return :e;
        return;
    }
    // nontrivial error handling code
}

[PavelVozenilek]

@andrewrk: these two examples are syntactically very tricky. They move the simple and explicit error checking from its proper place to some unnatural location, or they require creating additional functions (and inventing more names).

They are replacing the most simple and readable flow

do_A();
if (wrong) handle error
do_B();
if (wrong) handle error
do_C();
if (wrong) handle error

with something strange.

The examples also assume that everyone wants to return Zig error when the function gets into internal error situation handling business. The function may try to return some valid substitute, not the error. This also makes %defer not full replacement for traditional error handling.

(I am also unsure whether the examples would work, because of the need to access local variables.)

---

Here's another real code advantage of goto based error handling:

if (error condition) goto error1;
...
if (some other error condition) goto error2;
...
if (yet another error condition) goto error3;
...

error3:
  // the least common part of error handling
  ...
error2: // fallthrough  
  // error handling code for some scenarios
  ...
error1: // fallthrough
   // error handling code common for all scenarios
    ...

To implement such feature (shared error handling code) is impossible w/o goto (except for certain Forth dialects which offer so called "headless functions", where it is possible to jump inside of a function).

[andrewrk]

They move the simple and explicit error checking from its proper place to some unnatural location

The second one has the same source locations as your pseudocode.

The examples also assume that everyone wants to return Zig error

Where is the Zig error in the second example?

Please respect the OP's request:

I want real actual code here, not pseudocode examples. Please link to open source projects.

[PavelVozenilek]

@andrewrk:

The second one has the same source locations as your pseudocode.

I should had comment the examples separately. The second example is still tricky and creates named block and adds new level of indentation.

These are two local level problems I try to minimize: the need to invent names and the excessive indentation. (That's why I proposed Zig having elif or anonymous tuples and enums.)

Where is the Zig error in the second example?

There's not.

real code

The 3pp code which uses goto in a restricted way (handling errors down the flow) is DL malloc ( ftp://g.oswego.edu/pub/misc/malloc.c ), LZ4 compressor ( https://github.com/lz4/lz4/blob/dev/lib/lz4.c ) or SQLite. These libraries use fairly long functions and goto is the least intrusive way to handle errors (I guess).

A non-simple use is quicksort implementation in MSVC stdlib, it jumps up. This is IME quite rare occurence.

I do not write open source. I use goto occasionally, only for error handling, and only going down. It never caused problems for me.

[PavelVozenilek]

Btw, the second example could be rewritten as:

fn foo() {
    while (true)
        if (error_condition) break;
        if (some_other_error_condition) break;
        if (yet_another_error_condition) break;
        return;
    }
    // nontrivial error handling code
}

No need for blocks and one artificial name less, but I would not like it either. Unlike occasional goto such trick is also not present in C codebases I know.

re2c is a free and open-source lexer generator for C and C++. Its main goal is generating fast lexers: at least as fast as their reasonably optimized hand-coded counterparts. Instead of using traditional table-driven approach, re2c encodes the generated finite state automata directly in the form of conditional jumps and comparisons. The resulting programs are faster and often smaller than their table-driven analogues, and they are much easier to debug and understand.

[pluto439]

I wrote this code today. Made me regret that there is no goto in javascript.

        var file = FileUtils.getFile("Home", comment_path_from.slice(0,1));
        if ( file.exists() ) file = FileUtils.getFile("Home", comment_path_from.slice(0,2));
        if ( file.exists() ) file = FileUtils.getFile("Home", comment_path_from.slice(0,3));
        if ( file.exists() ) file = FileUtils.getFile("Home", comment_path_from.slice(0,4));
        if ( file.exists() ) file = FileUtils.getFile("Home", comment_path_from.slice(0,5));

        if (! file.exists() ) {
            hijack.innerHTML = "NO COMMENTS FOUND"
        } else {

In the worst case it calls file.exists() 4 extra times. Have to create a new variable, but I'm too lazy for that. And I doubt any compiler will optimize it properly.

I honestly don't understand why you want to remove goto so much.

[pluto439]

re2c looked like a spam, but I guess it's not. It uses goto heavily, is it?