Does Rust have an alternative for all the valid uses of goto?

Jules-Bertholet · September 9, 2025, 1:28am

Previous discussion:

github.com/rust-lang/rfcs

RFC: Improved State Machine Codegen

master ← folkertdev:labeled-match

opened 02:16PM - 28 Oct 24 UTC

folkertdev

+1452 -0

[Rendered](https://github.com/folkertdev/rust-rfcs/blob/labeled-match/text/3720-…labeled-match.md) This RFC adds `loop match`: - a `loop` and `match` can be fused into a `loop match <scrutinee> { /* ... */ }` - a `loop match` can be targeted by a `continue <value>`. The `value` is treated as a replacement operand to the `match` expression. The state transitions (going from one branch of the match to another) can be annotated with the `const` keyword, providing more accurate CFG information to the backend. That means: - more valid programs are accepted, increasing expressivity - the backend can generate better code, leading to significant speedups The goal of `loop match` is improved ergonomics and codegen for state machines. Rust, being a systems language, should make it possible to write efficient state machines, and currently falls short. Complex state machines are niche, but foundational to many programs (parsers, interpreters, networking protocols). This RFC follows in part from work on [zlib-rs](https://github.com/trifectatechfoundation/zlib-rs). Today, we simply cannot achieve the same codegen as C implementations. This limitation actively harms the adoption of rust in high-performance areas like compression. ### Basic example A `loop match` is similar to a `match` inside of a `loop`, with a mutable variable being updated to move to the next state. For instance, these two functions are semantically equivalent: ```rust fn loop_match() -> Option<u8> { loop match 1u8 { 1 => continue 2, 2 => continue 3, 3 => break Some(42), _ => None } } fn loop_plus_match() -> Option<u8> { let mut state = 1u8; loop { match state { 1 => { state = 2; continue; } 2 => { state = 3; continue; } 3 => { break Some(42) } _ => { break None } } } } ``` ### Interesting example The real power of `loop match` lies in giving the compiler more accurate information about the control flow of a program. Consider ```rust enum State { Foo, Bar, Baz, } let owned = Box::new(1); let mut state = State::Foo; loop { match state { State::Foo => state = State::Bar, State::Bar => { // or any function that moves the value drop(owned); // ERROR use of moved value: `owned` state = State::Baz; } State::Baz => break, } } ``` Reading the code, it is obvious that state moves from states `Foo` to `Bar` to `Baz`: no other path is possible. Specifically, we cannot end up in `State::Bar` twice, and hence the generated "use of moved value" error is not a problem in practice. This program is valid, but nonetheless rejected by the rust compiler. With `loop const match` and `const continue` the compiler now understands the control flow: ```rust loop const match State::Foo { State::Foo => const continue State::Bar, State::Bar => { // or any function that moves the value drop(owned); // all good now! const continue State::Baz; } State::Baz => break, } ``` --- [Rendered](https://github.com/folkertdev/rust-rfcs/blob/labeled-match/text/3720-labeled-match.md) Tracking: - https://github.com/rust-lang/rust/issues/132306

… and probably a lot more I’m missing

Topic		Replies	Views
[Pre-RFC] Safe goto with value language design	60	5677	August 15, 2021
Why does Rust not support goto statements? language design	16	19315	December 6, 2021
Idea for safe computed goto using enums language design	17	1593	December 25, 2024
Pre-RFC: Add Labeled Switches to Rust	16	902	March 12, 2025
Gotos in restricted functions language design	16	13998	March 25, 2019

Does Rust have an alternative for all the valid uses of goto?

Related topics