18

I was interested in Rust, and so I started reading the Rust programming guide on the Rust website, and discovered that variables are declared with the following syntax:

let x: i32 = 5;

Which means assign the value integer 5 to the variable type integer 32 bit which shall be referred to by the notation x from this point onwards.

Why is the let keyword reequired? It seems redundant, what does it actually "do"?

I assume the compiler would be able to tell that the following is a variable (or const variable) declaration:

x: i32 = 5;

There doesn't appear to be a reason for a let keyword, but presumably there is a smart reason because Rust is focused on safety. So what is that reason?

Edit: Addition: As function arguments, the let keyword is not required. Here is an example:

fn add1(x: i32) -> i32
{
    x = x + 1
}

This seems a bit strange - this "looks like" a pass by reference because of the missing let. But it's not. It's a pass by value. (Or at least I think it is.) Is this a syntactic inconsistency?

As an aside, why is the ordering of the variable name and type different from other languages? For example, the syntax could have been:

i32 x = 5;

Put a colon in there if you prefer.

i32: x = 5;
  • When programming you usually know what "type" of data you want before you think of a name for it. Maybe that's just something that comes from a C++ background, perhaps some think the other way around?

This brings me to another point; how can one declare a several variables of the same type in Rust? Such as:

let x, y, z: i32 = {4, 5, 5} // A guess of what this might look like?

Or is this just not allowed in Rust?

Improve this question
4
  • 1
    I don't get your point of your edit. In a function signature, the context tells us that we're declaring parameters and not assigning anything. And how you get the impression that anything happens by-reference, without any & or other indicator, is beyond me. Commented Aug 24, 2015 at 12:27
  • @delnan Read it carefully - I said that it isn't by reference, but it looks like it might be. Commented Aug 24, 2015 at 12:27
  • I understand that. I just don't get how it might look like it. There is nothing indicating that. As you note, the only difference is the absence of let, what does that have to do with by-value/by-reference? Commented Aug 24, 2015 at 12:28
  • The fact that let it missing makes it look (to me personally) like it's not the creation of a new variable. Therefore perhaps it is something else. Perhaps that something else is a reference? What else could it be? Commented Aug 24, 2015 at 12:46

3 Answers 3

Reset to default
44

Rust has local type inference, so the type normally doesn’t need to be written; let x = 5; will suffice. x = 5; would be quite different, as it would not declare a variable x, and Rust very deliberately separates declaration and assignment.

It’s also actually let PATTERN = EXPR;, not just let IDENT = EXPR;, so removing the let keyword would cause grammatical ambiguity. A pattern could be mut x (making the variable binding mutable), it could be (a, b) signifying tuple unpacking, &c.

You only think i32 x = 5; makes sense because you’re used to languages like C++. Seriously, who came up with that idea? It makes more sense on purely philosophical grounds to have the type after the name than before, and having just the type to declare variables is silly too. All sorts of grammatical ambiguity there. Type inference, allowing you to omit the type altogether, is a much nicer approach all round.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

Interesting points raised here - can you give an example of such an ambiguity? And to respond to paragraph 3, No, many years ago when I stopped using Basic and went to start programming in C, I liked that the "dim" keyword had disappeared because I didn't see any reason for it being there. I don't understand your point about philosophical grounds - I think it's perhaps personal preference whether you prefer type or identifier first? What's your philosophical argument for having the type after?
So, from a visual perspective, assigning a value to a type is less silly than i32 x = 5; ?
"Who came up with that idea?" Dennis Ritchie did. "Analogical reasoning led to a declaration syntax for names mirroring that of the expression syntax in which the names typically appear." In retrospect, it was an unfortunate move (because it removed all hope of context insensitivity from the language), but it probably seemed like a great idea at the time exactly on philosophical grounds ("how do you generalise type composition syntax?")
@Wtrmute: I’m finding that a bit hard to follow. Is the expression syntax it refers to “(int) foo”? If so that doesn’t seem like a very good mirror, so I’m wondering if it’s something else.
@ChrisMorgan: Ritchie's article (which I linked) explains this much better than a SO comment ever could, but it refers to the expressions with which one gets the primitive type out of the type of the variable. Ritchie gives examples, among which int *api[10], (*pai)[10]; — in each case, the expressions *api[0] and (*pai)[0] yield exactly the primitve type int.
13

First, parsing ambiguity. While it may be possible to parse such code (but only because a < b > c is already illegal as expression for a different reason), it would complicate all tooling and make parser performance (and error recovery) worse.

Second, type inference. Regardless of where the type is written, it can be omitted, so you need let or another marker to distinguish assignment from declaration. (You could technically use let x = ...; and Type x = ...; but why? It's not a type, it's the absence of a type.)

Third, generality. let works with any (irrefutable) pattern, including those that double as perfectly legal expressions: StructLiteral { field: x, other_field: y } and Some(thing). This is a source of even more ambiguity, if not for the parser (it rejects Some(a) = b currently), then for humans.

Fourth, while you may be used to type name, there is a long tradition of name: type, and it's gaining mainstream traction without Rust's doing (e.g. in Scala).

Fifth, I dispute this:

When programming you usually know what "type" of data you want before you think of a name for it.

Perhaps I know the general shape of the data (an integer, a string, an iterator, a set, etc.) but the exact type is often an implementation detail that comes second. This argument also falls apart in the face of type inference: How can leaving the type out be useful if that's what you are mostly thinking in? If on the other hand you're only talking about what you think of first while writing code, then the case is dismissed: Code is read far more often than it is written, and the order in which concepts are introduced need not (and often shouldn't) reflect the order in which they are conceived.

Improve this answer

13 Comments

I don't fully understand what you are trying to say in the final paragraph. When I write programs, I know whether my data is an integer, a pointer, a floating point value, a char, a std::vector, etc, etc... I would probably say it's not possible to write code unless you know about what format your data is to be stored in. That's the whole point about programming - to manipulate data, so if you "don't know" what your data looks like then you'd better figure it out before you start typing!
@user3728501 I know what my data looks like. Fortunately, in that I am not fully constrained by the machine and can think more abstractly: I can know that something is an integer without already making up my mind whether it's u32 or u64. I can know that I want to look up the users for all the user IDs without caring that the result type of items.iter().map(User::lookup) is iter::Map<slice::Iter<u32>, fn(u32) -> User>. And even if I need to know these things at some point, I don't need to know at all times and push it into the face of every reader.
@user3728501 So you are opposed to type inference as well?
@user3728501 Of course writing needs to be possible. But we're talking about (what you perceive to be) a slight loss in write-ability, for a slight win in readability. The fact that it will be read more often than written makes this a good trade off. RE: Last comment: But we do add the colon, and it even has many additional benefits (as explained in this answer). So what's your point here? And again, consider that the by far most common variable declaration in Rust is let name = value; with no type mentioned.
@user3728501 This is turning into a discussion that exceeds the scope of a comment chain (and Stack Overflow in general), so I'll refer you to Google to find some of the many essays arguing that "code is read more often than it is written". I have neither the time nor the space to reproduce all the arguments here.
|
9

It significantly simplifies the grammar. Remember, there's a full pattern on the left hand side, it's not actually let var it's let pattern.

how can one declare a several variables of the same type in Rust?

This is a completely different question, but there's no direct way to do this, no, at least not in the way you're thinking of. You can

let (a, b, c) = (1, 2, 3);

But they don't have to be of the same type, this is a destructuring pattern in action.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.