[Dig1t]

I like the idea of Rust, its technical merits etc, but good lord this language has some crazy weird and intimidating syntax. I read the code snippets and am just confused as heck.

Did it really have to look like this?

[duped]

No, the code you're looking at is using a bunch of macros to implement an embeded DSL on top of Rust.

For example this:

    #[get("/echo")]
    fn echo_stream(ws: WebSocket) -> Stream!['static] {
        Stream! { ws =>
            for await message in ws {
                yield message?;
            }
        }
    }

Is not valid Rust code. The `for await message in ws` is particularly egregious.

[zamalek]

Once you get over the initial hurdle, the syntax is extremely consistent and "guessable." By which I mean, once you know the basics you can guess how to do things that you have never done before - and if it doesn't work there's probably a pending RFC that matches your expectations.

For example, you might learn that you can do `if let Some(foo) = option` to check if some option is Some, but to also extract the value from it. Now you might guess that the let conditionals might work elsewhere, and you'd be right! `while let Some(line) = reader.read()` totally works.

Now compare this to the likes of C, where for example `break` appears in a `switch` for some bizarre reason (yes, I know the actual reason) and `case`s don't have braces.

[drewtato]

This is definitely not helped by Rocket. Even I, knowing Rust well, don't enjoy the way Rocket puts so much logic into attribute macros and function signatures.

[xcdzvyn]

Yeah, I generally have no issue with Rust's syntax but Rocket's API is certainly something.

[speed_spread]

It really depends on where you're coming from and if you understand the problems Rust is trying to solve. Rust is a strongly typed language that promotes explicitness over ambiguity, making actual application code look quite different from JS or Python which provide a lot of shortcuts but also have plenty of hidden trapdoors.

Some say that Rust naming conventions actually uses snake_case in variables because each underscore is a little trapdoor that's made apparent so you don't fall in it!

Being mainly imperative with some functional and OO niceties, it's also much less weird than many other languages. Try reading some Haskell or Erlang before judging how weird a language looks...

[unshavedyak]

I'd be curious how you rewrite the syntax to have the same features but less syntax choices. Especially if it was made in the same way, organic evolution over the years.

I suspect it might look different. Not better or worse, just.. different. Same core complaints.

Now what if it was written from scratch today? That would prob miss a lot of the warts you don't like. But it still represents a lot of complexity in all the features the language presents, so it wouldn't be Python - for sure.

Personally i love the syntax, but /shrug