basic.rs

match 'foo {
   'foo => {
       if some_thing {
           match 'bar;
       } else if other_thing {
           match 'baz;
       }
    }
    'bar => { blah(); match 'baz; }
    'baz => { blahblah(); match 'foo; }
}

computed.rs

match 'foo {
   'foo => {
       match if some_thing {
           'bar
       } else if other_thing {
           'baz
       } else {
           'end
       }
    }
    'bar => { blah(); match 'baz; }
    'baz => { blahblah(); match 'foo; }

    'end => {}
}

pattern_matching.rs

enum Matcher { Foo, Bar(int), Baz(float) }

match xyz {
    Foo => {
       if some_thing {
           match Bar(10);
       } else if other_thing {
           match Baz(10000.0);
       }
    }
    Bar(n) => { blah(n); match Baz(1.2); }
    Baz(f) => { blahblah(f); match Foo; }
}

@huonw: Well we don't need to worry about the proto! macro anymore, it just got removed.

@erickt, oh, sorry, I though I replied.

I think that something like

'outer: match xyz {
    Foo => match abc {
         Bar => match 'outer: Foo;
    }
}

might work?

In any case, I feel that pattern_matching.rs is the most flexible, e.g. it automatically gives "computed goto", and means that the state machine can be easily breakable/resumable.

There are probably concerns about lifetimes and so on that need to be considered carefully. (I guess that it could be restricted to only types without lifetimes in match JumpTo(x); if it gets too hard to be correct otherwise.)

A basic sketch of what this might look like when used for a yield state machine compiler. (Probably unworkable... it somehow has to handle the loop properly.)