Skip to content

Instantly share code, notes, and snippets.

@huonw
Created January 15, 2014 12:42
Show Gist options
  • Save huonw/8435502 to your computer and use it in GitHub Desktop.
Save huonw/8435502 to your computer and use it in GitHub Desktop.
do-while loops in Rust
while {
let x = foo();
bar(x);
x != 0
} {}
@gsemet
Copy link

gsemet commented Jan 15, 2014

what is the extra {} for?

@bstrie
Copy link

bstrie commented Jan 15, 2014

@stibbons while loops in Rust typically look like this:

while x != 0 {
    x = foo();
}

...but note that the condition there is allowed to be any expression. And blocks are themselves expressions. So you can write the above like this:

while { x != 0 } {
    x = foo();
}

What's been done here is that they've simply moved all the normal loop logic into the condition:

while { x = foo(); x != 0 } {
    // empty loop body
}

...such that it acts just like the typical do/while loop from other languages, thereby evaluating the loop body once before testing the condition. From there it's just a simple matter to reformat for style points:

while {
    x = foo();
    x != 0
} {}

@steveklabnik
Copy link

Wonder if you could macro away the extra {}

@bstrie
Copy link

bstrie commented Jan 15, 2014

No need to macro it away...

while {
    x = foo();
    x != 0
}                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {}

There you go. :)

@UtherII
Copy link

UtherII commented Jan 15, 2014

Arg, It's even worse : with this syntax, you don't see the dirty trick at all.
Until you try to use break or continue ...

@gsemet
Copy link

gsemet commented Jan 16, 2014

i see :)

@jrupac
Copy link

jrupac commented Jan 21, 2014

You can do the same trick in C, too:

int x;
while (
  x = foo(),
  bar(x),
  x != 0
) {}

and even weirder, like this (on some compilers):

int x;
while (({
  x = foo();
  bar(x);
  x != 0;
})) {}

@jFransham
Copy link

This is an ancient thread but I thought I'd share a trick from my first rust project -- it's crazy that this still doesn't exist in stable rust (and I haven't found any mention of it in the nightly book).

macro_rules! run {
    ($x:block until $y:expr) => {{
        while {
            $x;
            !$y
            } {}
    }};
    ($x:block if_still $y:expr) => {{
        while {
            $x;
            $y
            } {}
    }};
}

Additionally, I think keyword! should be parsed seperately to keyword, so you could write this as do! while! without the compiler complaining.

(Should note that I never ended up using this macro because it was too ugly in use, so take from that what you will)

@donbright
Copy link

really helps porting javascript . thanks

@DarkblooM-IO
Copy link

Here have a star

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment