[rust-dev] "let mut" <-> "var"
dbau.pp at gmail.com
Wed Jan 29 19:13:16 PST 2014
On 30/01/14 14:09, Samuel Williams wrote:
> I agree that it is syntactic salt and that the design is to discourage
> mutability. I actually appreciate that point as a programmer.
> w.r.t. this specific issue: I think what concerns me is that it is
> quite a high burden for new programmers (I teach COSC1xx courses to
> new students so I have some idea about the level of new programmers).
> For example, you need to know more detail about what is going on - new
> programmers would find that difficult as it is one more concept to
> overflow their heads.
> Adding "var" as a keyword identically maps to new programmer's
> wouldn't cause any problems right? But, could be optimised more
> (potentially) if using "let" for immutable parts.
> Anyway, I'm not convinced either way, I'm not sure I see the entire
> picture yet. But, if I was writing code, I'd certainly get sick of
> writing "let mut" over and over again - and looking at existing rust
> examples, that certainly seems like the norm..
Inside the main rust repository:
$ git grep 'let ' -- '*.rs' | grep -v mut | wc -l
$ git grep 'let ' -- '*.rs' | grep mut | wc -l
i.e. there are approximately 3 times more non-mutable variable bindings
than there are mutable ones.
> On 30 January 2014 15:59, Samuel Williams
> <space.ship.traveller at gmail.com
> <mailto:space.ship.traveller at gmail.com>> wrote:
> I guess the main gain would be less typing of what seems to be a
> reasonably common sequence, and the formalisation of a particular
> semantic pattern which makes it easier to recognise the code when
> you visually scanning it.
> On 30 January 2014 15:50, Kevin Ballard <kevin at sb.org
> <mailto:kevin at sb.org>> wrote:
> On Jan 29, 2014, at 6:43 PM, Brian Anderson
> <banderson at mozilla.com <mailto:banderson at mozilla.com>> wrote:
> > On 01/29/2014 06:35 PM, Patrick Walton wrote:
> >> On 1/29/14 6:34 PM, Samuel Williams wrote:
> >>> Perhaps this has been considered already, but when I'm
> reading rust code
> >>> "let mut" just seems to stick out all over the place. Why
> not add a
> >>> "var" keyword that does the same thing? I think there are
> lots of good
> >>> and bad reasons to do this or not do it, but I just wanted
> to propose
> >>> the idea and see what other people are thinking.
> >> `let` takes a pattern. `mut` is a modifier on variables in
> a pattern. It is reasonable to write `let (x, mut y) = ...`,
> `let (mut x, y) = ...`, `let (mut x, mut y) = ...`, and so forth.
> >> Having a special "var" syntax would defeat this orthogonality.
> > `var` could potentially just be special-case sugar for `let
> To what end? Users still need to know about `mut` for all the
> other uses of patterns. This would reserve a new keyword and
> appear to duplicate functionality for no gain.
> Rust-dev mailing list
> Rust-dev at mozilla.org <mailto:Rust-dev at mozilla.org>
> Rust-dev mailing list
> Rust-dev at mozilla.org
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Rust-dev