I must say I don't understand this kind of feedback at all. Even when starting to learn a new language, I don't assume I understand it on the basis of surface similarities (or differences) between it and languages I'm already familiar with. I just read a book. There, done.
It would seem very odd to me to take strongly into consideration the first week of learning when designing any aspect of a programming language, aside from its related learning materials. Are people so intolerant of the learning process itself (constant exposure to which is surely one of the joys of programming?) that they would rather slip into a new language as if it's an old pair of shoes?
I don't write this from from any kind of 10x programmer pose. On the contrary I find Rust extremely difficult, to the point where I've now given up on it twice, after some efforts, as being just beyond my meagre capacities to write real programs with (I've decided, with a considerable sigh, to give it another crack this week as it really is well suited to a couple of things I'd like to try). But I don't know why anyone would hobble theirselves in the first week or two or learning by expecting it to accommodate to their expectations. Isn't learning precisely the process of escaping expectations' snares?
Not expecting it to accommodate my preferences. But it's sometimes helpful, when learning, to understand the rationale behind design choices as a way of speeding up learning them and understanding/anticipating the likely design of the rest of the system.
And it's sometimes helpful for any programmer to hear where their UI -- and a language IS a UI -- seemed unintuitive, since most of us go on to write other systems later.
I've worked in more syntaxes than I can shake a stick at, and have some compiler experience though that wasn't a specialty. Rust is far from the most unusual or hardest to adapt to. But that doesn't mean it isn't worth discussing those differences and how to make adaptation to them easier.
If I don't like something, I tend to write so folks know why. If I do like something, I often find I write twice as much, calling out the edge cases I want to understand and/or see improved and/or see better explained in tutorial material. This is very much in the latter category. No disrespect intended -- rather the opposite; if the worst I can find so far is trivial syntactic nitpicking, they're doing much better than average.
If the Rustacians think I'm out of line in tone or content, I welcome correction. But they did encourage people to get involved and ask even newbie questions, and I'm taking them at their word until they say otherwise. Especially since I am considering getting much more involved and want to understand design principles before I start issuing pull requests.
Fair enough. For whatever idiosyncratic reasons, I guess our approaches when approaching something new are just different. My initial attitude tends to be humility and deference: soak it up (even with a fair bit of rote learning) and then, make whatever evaluations are relevant at a later stage. When I feel like I'm initiated!
I don't in any way represent Rustaceans. Indeed I'm not one - I'd be somewhat ashamed to expose my one rather feeble Rust project. I'm just another forum reader and sometime learner. My comment was a statement of incomprehension rather than correction so my apologies if it came across as the latter.
Also fair enough. I have an overcompensated writer's block and sometimes get officious when I'm tired (I try to watch out for that, but...), so I appreciate feedback too. If I'm out of line by all means point it out; I may initially react defensively but I will take it seriously.
Regarding syntax I think the ideal is that the syntax should be as surprising as the semantics they represent. I think ..= serves pretty well here, but name @ pattern does seem worse than it theoretically could have been?
That's rather learning path dependent though. To an all-and-only LISPer, pretty much any syntax might surprise (I was going to add a javascript joke but decided against it).
The name @ pattern syntax is found in Haskell and some less prominent functional languages. One alternative, maybe a friendlier one, could have been pattern as name, as used in OCaml (in which Rust formerly was implemented).
@8573: Thanks for the confirmation.If the RFC was that recent, I don't feel too desperately behind reality. I may be starting to get a general sense for where Rust's designers were drawing their lines... Hope so, anyway. I'll find out when I start using it.
And thanks again to everyone for putting up with my having started this. It probably really belongs on a rust-users mailing list or Q&A board or something like... If there's a better venue, we should adjourn thereunto.
It does, and it's already there: this forum ("URLO", for "Users.Rust-Lang.Org"), is the Rust users' mailing list (yes) and Q&A board.
There was a rust-dev mailing list, now superseded by the Rust Internals forum ("IRLO", for "Internals.Rust-Lang.Org"), but I don't think there ever was a rust-users mailing list per se.