[mhd]

I thought people got along with Rust due to its features and semantics and learned to live with the syntax. Not it being something one would copy. (I'm personally still hoping for a Ratfor/Coffeescript transpiler)

Also, wonder how long it'll take until we see a "Aluminia" fork...

[jimbob45]

What is it that people hate about Rust syntax beyond the terrible lifetime syntax? Seems pretty reasonable to me.

[still_grokking]

Rust's syntax is just baroque.

It's full of unnecessary noise and additionally very irregular. (With complete craziness thrown in between like the semicolon rule to "visually distinguish" procedures and functions, which must be a kind of joke I don't get).

I really don't understand how such a conceptionally well thought out language got this pretty ugly syntax.

(And no, you don't need such ugly syntax "because language features". Just have a look at Scala 3 that is much more powerful but maintains a clean, almost pythonic syntax).

[Syzygies]

Rust is a fly-pollinated flower. Without garbage collection, it needs flies.

Rust is in part designed to look familiar to C programmers. Rob Pike once famously described C syntax as able to survive a channel that mangled whitespace. That's less of an issue now, but habits die hard. Indentation in place of syntax is nevertheless controversial. That's a toy version of the bigger question: Why should text be required to carry a load that a smart editor can infer? In Clojure, some prefer ;; to ; because the comments stand out better. Um, syntax coloring? I dislike all comment characters, and for many years I preprocessed a practical version of "comments are flush, code is indented".

Ownership is nevertheless pure genius, and one can define more powerful operations on Rust's restricted notion of data than on general data. I'm imagining a "lisp without parentheses" that transpiles monadic parsers on steroids (aimed exactly at Rust data) to Rust. It will take me a while.

[kazinator]

> Rust is in part designed to look familiar to C programmers.

Rust may be accompanied by a design statement like that somewhere, but it actually does no such thing.

[Syzygies]

I'm sure you're right. Rust is a popular language in Haskell user surveys, as it's not such a stretch coming from Haskell.

The majority of the lines I've ever written were in C. When I look at Rust, all I see is `{};`

[brundolf]

I love the semicolon rule, I think that distinction is extremely important and too often gets muddled

(though in Rust's case I think it's more accurate to say it distinguishes between "statements and expressions" than "procedures and functions")

[still_grokking]

> I love the semicolon rule, I think that distinction is extremely important and too often gets muddled

Yes, the distinction is important. That's why it's extremely annoying that this distinction is almost invisible if you don't look very close on the code using magnifying glasses. Like I said: Marking such an important distinction through something almost invisible like a (missing) semicolon is pure craziness.

Usually nobody reads semicolons! They are usually just line noise coming form a time as parsing code was actually still some kind of science and people made syntax with the explicit intent to be easy readable by archaic computers (and not humans in the first place).

I think `return`s are superfluous but given the choice between some more line noise in the form of a `return` statement and this semicolon brain-fart I would clearly prefer the `return`…

> (though in Rust's case I think it's more accurate to say it distinguishes between "statements and expressions" than "procedures and functions")

Since when? Did I miss something? (This could be, I'm looking only occasionally into Rust).

AFAIK leaving out the semicolon is only an option on the last expression of a procedure, turning that "procedure" into a function.

Leaving out (the completely unnecessary!) semicolons elsewhere is a syntax error to my best knowledge.

  fn main() {
      let baz = if false {"bar"} else {"foo"}
      println!("Hello, {baz}!", baz = baz);
  }

The above code would not compile, afaik, because the semicolon is missing on the first line of the procedure.

The completely unnecessary semicolons are just one of the examples that make the Rust syntax heavyweight and needless noisy for no good reason. I don't get how a modern language can fall back to such antique syntax.

The very rare use-case where you really want to write some comprehensive one-liner could have been easy supported by optional semicolons. But in the general case one just doesn't need that line noise.

Rust is a great language, really! But they obviously didn't put any effort into the syntax. The result is that the language reads partly like C++, and I guess almost everybody could agree that C++ has one of the most terrible syntax out there.

Rust is "modern" language with a stone age look & feel. That's a big missed opportunity, imho.

[brundolf]

> they obviously didn't put any effort into the syntax

This is an incredibly arrogant and ignorant statement to make, especially for someone who self-describes as "looking only occasionally into Rust". A whole lot of thought has been put into Rust's syntax.

> The result is that the language reads partly like C++

My impression is that a certain amount of this was intentional; if their goal is to attract C++ developers, they can't scare them off with syntax that's wildly alien. Rust took the parts of C++ syntax that made sense to keep and that fit into Rust's semantics, refined/modernized/distilled them, sanded off the rough edges and ambiguities, and presented something cohesive that's still familiar.

The syntax isn't without warts - turbofish comes to mind - but overall I find it pleasant and comfy (and I'm not even a C++ developer). I appreciate that it makes a lot of things explicit that should be explicit. Fewer characters doesn't automatically mean better readability; in many cases it can mean the opposite.

[still_grokking]

>> they obviously didn't put any effort into the syntax

> This is an incredibly arrogant and ignorant statement to make, especially for someone who self-describes as "looking only occasionally into Rust".

There is nothing arrogant or especially ignorant about my statement.

I'm primary using a language that has a shitload more features than Rust but gets along with a fraction of syntax.

So from my standpoint this is clearly something to criticize Rust for.

And this is very sad imho as I think Rust is a great language as such. A great language with a miserable syntax!

That's especially unfortunate as there are today no technical reasons to make ugly languages given how fast our computers are.

> A whole lot of thought has been put into Rust's syntax.

Who knows, maybe you're even right, idk.

But at least the result does not show, and that's the only relevant part.

> My impression is that a certain amount of this was intentional; if their goal is to attract C++ developers, they can't scare them off with syntax that's wildly alien.

That's imho nonsense. You can't "scare" C++ developers with syntax. They already endure one of the most broken syntaxes out there.

One does not use C++ because of its syntax, but in spite of that monstrosity!

One endures it as the language has other until lately unmatched properties. But C++'s look & feel is just a horrible historical accident all in all.

Rust would be attractive for its features no mater the syntax.

As we see it gets hyped and does very well for a newcomer even it's overly and needlessly ugly.

> Fewer characters doesn't automatically mean better readability; in many cases it can mean the opposite.

Sure.

But it's Rust that uses almost every ASCII char for some special purposes; imitating by doing so one or two of the worst examples history ever created.

The other thing is: Putting outright line noise everywhere only because that makes reading the code simpler for the machine is just the completely wrong priority. Less line noise makes reading code definitely simpler for humans. It has reasons why math notation looks like it looks after hundreds of years of optimization…

The whole point of good syntax is that you can mostly ignore the syntax and concentrate on the message. But Rust is like C++, you can often hardly see the actual content as it's burrowed under a pile of ugly needless syntax noise.

Copying a bad example is definitely nothing to be proud of. Rust failed in that regard miserably, imho. For completely incomprehensible reasons—which make it especially bad.

It's a real pity such a great language looks like a archaic accident!

[Quekid5]

> But they obviously didn't put any effort into the syntax.

Ackshually moment here, but they did put a lot of effort into chosing syntax which would require very little look-ahead on the part of the parser (given current or even decade+ old parser tech). I don't understand their reasons for doing so at all, but that's what they did.

The result is... not very human-friendly IMO.

[still_grokking]

Exactly my point. This syntax was made for machines, not for humans. That's just not reasonable given how fast our computers are, and where the actual work for a modern compiler lies.

But I don't get that either: Parsing is today the least problem. The time you spend parsing is negligible (if you didn't mess up the language completely, of course) compared to the time for type-checking and optimizations.

Avoiding look-ahead (or especially the need to re-parse parts recursively) is a very good rule of thumb, sure. But when you need to decide whether you make the language simpler to read for the machine or more heavyweight for the human the answer should be absolute clear.

A modern compiler spends anyway most of its time in the semantic analysis (and depending on language, later optimizing the output). Optimizing the lexical part for the win of a few milliseconds on tens of thousands of lines just makes no sense. Today's computers are even fast enough to parse spoken human language fast enough. Again it's the analysis that takes time there.

The thing with Rust's syntax is especially annoying as almost everything else in that language makes a lot of sense. The concepts are neatly put together. It's explicit about the right things. It's considerably small and simple. It's almost a kind of sweet spot in language design, imho. And than it was hit hard with the ugly stick. That's a really sad point. And so needless.

I still hope they will come to their mind some day, and will start to offer a kind of "light" syntax at some point.

I really wish Rust could be more like Scala 3 on the outside, with a clean, minimal pythonic look & feel, and not like how someone put it before in a comment in this thread "When I look at Rust, all I see is `{};`". The later is also exactly my impression, sadly.

[markusde]

Is lifetime syntax so terrible? Personally I like that all the subtyping relations are in the same place (lifetime outlives, polymorphism etc) and that they can be written inline until complicated enough to justify a ``where`` block.

[xigoi]

Semicolons, braces, double colons

Using "<" and ">" as both operators and delimiters

Turbofish

Symbols instead of words (ref -> &, and -> &&, not -> !, …)

Inconsistency (Why [i64; 5] and not something like array<i64, 5>?)

[Gibbon1]

I have this thought of solving this sort of thing via emoji's. It's gross but at least you would have a syntax that doesn't grossly overload symbols.

[xigoi]

https://www.emojicode.org/

[aaaaaaaaaaab]

The community.

[dhosek]

What I’ve found is that Rust people on stackoverflow not so great, Rust people on Reddit pretty pretty good.

[EugeneOZ]

Well, the Reddit community is getting worse with time also.

[IshKebab]

I assume he means the basic syntax like the fact that everything is an expression, `name: type` not requiring brackets for `if` and `for` etc. Most of the ugly Rust syntax is for advanced features like lifetimes and generics.