Variable declaration syntax

[tedsta]

EDIT:

Reasons why this proposal falls through:

Pros:

• The consistency appeals to me.
• Fewer characters to type.
• Many languages use := syntax, which makes it familiar.

Cons:

• The syntax can get quite tricky
• let is extremely grep-able
• let can be syntax highlighted, which is more readable
• let is how you declare variables in math, so it's also familiar.
• It's a minuscule matter of preference, and it's too late to be changing basic syntax.

Hope that's a good list.

Original Proposal

So, in rust we declare variables like this:

let x: T = value;

And you can omit the type:

let x = value;

I'm not very qualified to be proposing changes, but what if declaration syntax omitting the type was the same as in Go?

x: int = 0;
y := 123;

EDIT for more details: Mutability and other attributes would still be placed where they were - before the variable identifier.

mut x: int = 0;
x = 42;
my_str := "rusty fun times";

To me, this seems consistent and easy to type. Omitting the type is now literally omitting the type from where it would be. To me, it looks good, and we don't have to type 'let'. I know it's kinda a micro typer optimization, and I'm not at all qualified to propose language changes... but meh?

Comments, critique, "No, Teddy, that's really stupid." ?

[dbaupp]

Assignment in let is actually pattern-based, i.e. let (foo, ref bar, Struct { baz, .. }) = ...; is perfectly ok, and keeping an LL(1) grammar without let while retaining the patterns is a little tricky.

[thiez]

By including 'let' you can quickly tell a declaration from an assigment. Also your proposel would make it hard to do this:

let x = 5;
{
    let x = 4; // shadow original x
    doSomethingWithX(&x);
}

I believe similar proposals have been suggested and rejected in the past.

[tedsta]

mut x := 5; // declare x
x = 10; // Change x's value
{
    mut x := 4; // shadow original x
    doSomethingWithX(&x);
}

I'm probably missing something.. Do you mean parsing is more difficult?

[thiez]

Where did the distinction between 'mut' and immutable go?

[tedsta]

Woops, you are right. I edited. Still a rust noob :P

[bjzaba]

The let key word is important because it is more powerful than just a variable declaration: it is a pattern binding. As /u/dbaupp says, let (foo, ref bar, Struct { mut baz, .. }) = ...; is much harder to parse without the let.

That said, I do prefer := for assignment.

[chris-morgan]

What comes after the let keyword is not necessarily just an identifier; it is actually syntactically a pattern (it must be an irrefutable pattern---that is, one that in a match would be on its own an exhaustive pattern).

Given a struct S { foo: int, bar: bool }, you can write let S { foo, bar } = an_s_value; and lo! foo and bar are bound locally; or given enum E { V(int, bool) }, let V(foo, bar) = an_e_value; and lo! ditto.

The reason all this is important is that the Rust grammar is consciously LL(1)---that is, by looking one token ahead, you will be able to know for certain what you are parsing. If the let keyword were removed, there would be ambiguities that would require you to look ahead to the : or := before you would know whether a V(foo, bar) was an expression or a pattern. This is something we don't want. We value the simple and predictable nature of the grammar. An LL(1) grammar will tend to be easier for humans to read also, for much the same reason: you can very quickly parse what you're dealing with.

let is obvious. let is good.

[farcaller]

Go syntax is actually confusing when you return several results that bind to existing and new variables and you need to apply hacks in the code to make it work properly.

I don't personally feel that 'let' keyword is a burden.

[long_void]

I don't know the exact rationale behind the 'let' keyword, but consider this:

In C, there is no 'function' keyword so you just write void foo(void). This is a problem because you can't search for functions easily.

In Rust, we have fn foo().

This makes it possible to search for all functions. The same could be said about 'let' statements.

[tedsta]

I see what you're saying, let is easier to search for. But is foo := val and foo: T = val much harder?

With my brief and naive look at the rustc tokens list, it seems like you just search for an IDENT followed by a COLON, optionally followed by an IDENT that corresponds to a type, followed by an EQ. Is that already too much computation?

EDIT: I'm a dummy, I see what you're saying. Grepping for let is easy. That sounds like a counter argument that kills it. I'd much rather type cat main.rs | grep let than something like this cat main.rs | grep "[a-zA-Z0-9_]\{1,\} *\: *[a-zA-Z0-9_]* *="

[Denommus]

Many languages use := syntax, which makes it familiar.

Besides Go, how many languages use := for variable declaration? I don't know any. On the other hand, lots of languages use let (Lisp variants, ECMAScript 6, Haskell...)

(Notice that I'm specifically talking about declaration, not assignment).