Labeled break and continue

[brson]

Henri needs a labeled break and continue equivalent in order to generate an HTML parser for servo. For C++ they use gotos and macros. We could possibly devise something with macros, though it may not be efficient.

[graydon]

The only difficulty is grammatical: collides when at the beginning of a block. Open brace ident colon is the prefix of a record literal. Any other good looking options?

[boggle]

Would pre-declaring of labels help to sort this out, i.e. label foo and a production that dispatches pre-declared labels as potential jump targets and non-declared ones as record fields?

[graydon]

might, but seems unfortunate. maybe some kind of sub production on the loop headers? while foo: bar() {...} should work, i think. label immediately following loop keyword. tolerable?

[boggle]

I find that hard to read when scanning for labels but with a small lookahead 'foo: while' should be distinguishable due to while being a keyword.

[bstrie]

Right now {foo: while true { break; }} is a valid record where the value of foo is ().

[bstrie]

Perhaps the most sane solution is simply to introduce a new label keyword. In that way at least it doesn't require too much cleverness, and it requires people to be explicit where they want to use labeled break and continue (which hopefully will not be too often).

[nikomatsakis]

One thing: I don't know what Henri needs precisely, but at least in Java it is possible to label an arbitrary block and break out of it:

some_block: {
    ...
    if (some_cond)
        // Jumps to (1)
        break some_block;
    ...
}
... // (1)

Whatever syntax we do may need to be applicable to blocks as well.

[brson]

I think we should try to resolve this for 0.3

[brson]

I took a peek at the parser source and I suspect that it only uses labels on for loops, mostly ones that look like for(;;).

[brson]

#[label = "foo"]
loop {
}

We don't even have to commit to a syntax.

[brson]

#[label = "foo"]
loop {
    #[label = "foo"]
    break;
}

[boggle]

Nice, I like this!

[graydon]

Attributes could work but feels odd to me given that it is control flow. What about assembly style labels? .label: { ... } ?

[bstrie]

If concerns over the syntax for labeling loops is blocking this, there's a way to defer that argument while still having this feature:

loop {
    // whatever
    loop {
        // whatever
        loop {
            if whatever {
                break 0;  // breaks to the parent loop
            }
            else {
                break 1;  // breaks to the grandparent loop
            }
        }
    }
}

Ugly, but at least it wouldn't preclude people from making use of labeled break/continue due to syntax concerns.

[brson]

This is likely to be a rarely used feature so it doesn't need a perfect syntax. It may not be worth, for example, reserving the prefix dot for labels, introducing a new syntax for naming things. Splicing the name in as a subproduction of the loop header as graydon suggested is a reasonably unobtrusive way to introduce a feature we're not sure about.

Here's another idea - loop is the only way to create a labeled loop and it looks like this:

loop {
loop: foo {
loop: bar while something {
loop: baz for xs.each |x| {

This should be easier to scan since all the labels are in the same position.

[JosephLenton]

A random suggestion, but why not allow multiple breaks in a stamenet?

loop {
    loop {
        loop {
            break break break;
        }
    }
}

If one break breaks one loop, then two breaks should break two loops, and three would break three loops, and so on.

[Vincent-Belliard]

I think that Rust doesn't use dot as an unary prefixed operator. A syntax could be:

loop.foo {}

while.foo a > 0 {}

for.foo each(~[2, 4, 8, 5, 16]) |n| {}

The dot could also be replaced by a colon.

[jesse99]

Was this done in bdb206f? If so it should be documented.

[brson]

The syntax has been added as loop foo: { }, with no syntax for while and for. This is hopefully the minimum we can do to support the use cases for which it matters. It still doesn't work though.

[burg]

IME, labeled break/continue is really really helpful when writing an inline flow/text wrapping algorithm.

[catamorphism]

Reassigning to myself.

[nikomatsakis]

Deferring to 0.5

[brson]

Henri gave us some specific requirements: https://mail.mozilla.org/pipermail/rust-dev/2012-October/002413.html

[hsivonen]

One thing: I don't know what Henri needs precisely, but at least in Java it is possible to label an arbitrary block and break out of it

Whoa. I was unaware!

The parser code currently just breaks/continues conditionless for loops. However, so of those never loop and are, in fact, just block to break out of, but I didn’t know that was allowed in Java.

[ibukanov]

Regarding that Java feature where the break can jump out of any labeled block. Effectively it provides a forward-only goto that cannot enter new blocks. So what about just adding a real goto to Rust that has the similar forward-only jump restrictions? Then one would not need a labeled continue and explicit label statement no longer looks bad like in:

loop {
loop {
loop {
goto out;
}
}
}
label out;

[brson]

@ibukanov nice idea! It does add two entire keywords for a corner case, though.

[ibukanov]

On 10 October 2012 21:23, Brian Anderson [email protected] wrote:

@ibukanov nice idea! It does add two entire keywords for a corner case, though.

Well, then goto may remain labeled break.

[JosephLenton]

Then use 'break break break' instead. No new keywords, just a little extra grammar.

Even with the controlled goto's we have now, they are not that readable.

[catamorphism]

This is going to be my priority for 0.5 (and shouldn't take the entire time in between now and the next release!)

[catamorphism]

Preliminary version pending review by @pcwalton .

[catamorphism]

This is working except for a named break inside a for loop. I guess I'll just make a separate bug for that.