Let-in binding syntax

[lucian1900]

I thought it would be interesting to be also able to bind a symbol only for the scope of the following expression, much like "let ... in" syntax in Haskell/ML.

So this

let a = 1 in a + 1

would be equivalent to this

{
    let a = 1;
    a + 1
}

Such syntax would also more closely align with match, where the symbols are scoped only in that arm of the match.

I've felt the need for this trying to write Some(&1) and having to fall back binding it separately, but I understand that will be fixed.

[huonw]

This (or something equivalent) can be written with a macro:

#[feature(macro_rules)];

macro_rules! bind {
    ($( $p:pat $(: $t:ty)* = $val:expr );* in $rhs:expr) => {
        {
            $( let $p $(: $t)* = $val; )*
            $rhs
        }
    }
}

fn main() {
    let v = bind!(a: int = 1; b = 2 in a + b);
    println!("{}", v);
}

Does that appear to cover what you are thinking of?

[lucian1900]

Yep, that's pretty much it. It would look a bit ugly when used with a block, but not too bad I guess.

Is it too much to add this to syntax?

[huonw]

The macro could be tuned to allow bind!(a = 1 in foo(a); bar(a); baz(a)); without needing { } (probably as simple as $( $rhs: expr );* in the definition and then $($rhs);* at the point of use.

And yes, to me, this seems like a poster boy for macros/syntax extensions, rather than hard-coding extended syntax into the language.

[lucian1900]

It's quite a common feature of let, in ML/Haskell and Lisps, which is why I was thinking it would be nice if it were actual syntax. I was certainly surprised it didn't exist.

Of course, I can work with a macro as well.

[huonw]

I'm going to close this in favour of macros.

Anyone who feels particularly strongly (preferably with a good reason why a macro is insufficient) can comment/reopen.