3 ms·
I still find it's a pity that so new language has "you must write let" that even Basic programmers don't have to do during at least 30-40 years: https://www.po
by acqq 13y ago
I still find it's a pity that so new language has "you must write let" that even Basic programmers don't have to do during at least 30-40 years:
https://www.powerbasic.com/support/help/pbcc/let_statement.htm https://www.powerbasic.com/support/help/pbcc/let_statement.h...
I remember not having to write let in Basic even in eighties. Anyway, since 1995, http://en.wikipedia.org/wiki/Limbo_(programming_language) http://en.wikipedia.org/wiki/Limbo_(programming_language) people have an idea that there is a simple way to have "define and assign" that is different from "assign" without requiring a keyword: use := for define and assign, x:=exp is equivalent to let x=exp, use = for just assign. Google Go just reused that idea. Even if it's used today by Go, I still don't understand why Rust avoids it, because it makes sources significantly more readable: the variable is not obstructed by the keyword.
let mut is even more "stuff" before the variable in the language where declarations otherwise always follow the variable (which is good!) I'd use x := expression and x : mut = expression.
- pcwalton 13y agoIt wouldn't work in Rust because "let" supports arbitrary (irrefutable) patterns, and Rust has full pattern matching. The parser has to know when a pattern is coming up. Languages that use :=, like Go, don't have a complete set of destructuring features. The convenience of being able to have an arbitrary pattern in "let" bindings far outweighs the disadvantage of having to type "let". "x : mut = expression" wouldn't work in Rust because types follow :, and "mut" is not part of a type. "mut" is needed after each binding because one pattern can contain some mutable bindings and some immutable bindings.
- acqq 13y agoCan you please point me to the examples of the kind of the pattern matching constructs that don't allow using := ? I know it's obvious to you, I don't have your experience but I'd really want to understand. Thanks in advance. Regarding "mut is not a part of a type," so what? From my perspective (of somebody who implemented just much simpler languages than Rust) it's something like a "storage attribute." It doesn't prevent me to build the syntax to be more readable: it's a keyword anyway. It's certainly not that it can't be there because otherwise it's unparsable. Having x = expr, x := expr and x : mut = expr make all pretty clean and obvious to me...
- acqq 13y agoI've tried to find any meaningful example of "why not." Is "let" supposed to be needed because of something like this? let (a, b) = get_tuple_of_two_ints(); I don't see that it's fundamentally different to parse if it would be written like this: (a, b) := get_tuple_of_two_ints(); It's true that the parser has to wait for := to do know the semantics of the expression on the left side of it, but it can definitely be done.
- bjz_ 13y agoRust can pattern match on structs, fixed length vectors, references, and it has keywords to bind them as mutable and/or by-ref. Doing all that without a `let` would extremely challenging.
- pcwalton 13y agoIt would require making "expression" and "pattern" into the same nonterminal in the grammar, and then deciding afterwards whether something that was parsed was an expression or a pattern. This is sometimes called a "cover grammar" because it "covers" two distinct nonterminals. It is possible--ECMAScript 6 does it--but it's definitely a complex way to parse. It doesn't seem compatible with Rust's design goal of being easy to parse and regular, e.g. for tooling.
- bjz_ 13y agoI would check out: http://pzol.github.io/getting_rusty/posts/20140417_destructuring_in_rust/ http://pzol.github.io/getting_rusty/posts/20140417_destructu... For example: struct Foo { x: (uint, uint), y: uint } let foo = Foo { x: (1, 2), y: 3 }; let Foo { x: tuple @ (a, b), .. } = foo; // => a == 1; b == 2; tuple == (1, 2) In terms of mut: let (mut x, ref y, &z) = (1, 2, &3); x = 2; // reassignment is ok, because we bound `x` as mutable x += *y; // we bound `y` as a reference, so it must be derefed first x += z; // we used a `&` pattern to get the value stored in the reference, so // derefing is not necessary *y += 1; // this would not compile, because y is immutable
- acqq 13y ago
- jnbiche 13y agoAs someone who is learning OCaml at the same time as Rust (and who already had some Haskell), I can attest that the power of pattern matching is well-worth the extra "let". Plus, in addition to the signal it provides to the compiler, it also provides me a signal to know that I've got a new variable and the option here to do destructuring pattern matching. Very cool. pcwalton: after getting over the hump of Rust's pointer semantics, I've found that it's a very elegant and fairly simple language. So I was partially wrong about my assessment of Rust as a "complex" language (I say "partially" because the pointer semantics do add a significant layer of unavoidable complexity). I'd encourage anyone put off by the complexity of Rust's pointers to just push on through. I think you'll find it's worth the trouble. Rust is definitely the language of the future for games, embedded programming, system programming and other areas of programming that require a high level of determinism. I can't wait until it's stable enough to use for real projects (hopefully sometime this year).
- bjz_ 13y ago> after getting over the hump of Rust's pointer semantics, I've found that it's a very elegant and fairly simple language Definitely, I cannot stress this enough. Back when I first looked at the language in 0.3 it was awfully complex and I had doubts about hwo successful it would be. But ever since 0.4, with the removal of classes and argument modes, the core devs have been working extremely hard to make the core semantics of Rust as simple as possible, whilst at the same time making the language powerful and extensible. It will take time to dispel the myths still hanging around though, so I would urge you to share your experiences more widely.
- steveklabnik 13y agoHave you read http://static.rust-lang.org/doc/master/guide-pointers.html http://static.rust-lang.org/doc/master/guide-pointers.html ?
- jnbiche 13y agoYes. That was the guide, along with the pointer semantics table, that basically convinced me to give Rust a second chance, since if pointers could be summed up in a table, they were definitely comprehensible even for a PL peon like me.
- mpartel 13y agoHaving programmed a lot in both Scala and Ruby, I'd argue the opposite. The keyword makes new variables easier to spot quickly, and with syntax highlighting, I really don't see `let [mut]` as clutter. Admittedly tastes in such things will always vary.
- Theriac25 13y agoI'd like to inform you that you have bad taste and your post doesn't have anything to do with the article.
- sixbrx 13y agoI actually like "let" to introduce variables, it's what I scratch on paper when doing psuedo-code since before I met Rust or any other functional language. To omit it (or something like it, e.g. "var" or "val") would be to omit crucial information. It's short, clear, and has a long history in mathematics and logic too.