Hacker News Reader

Comment by dist1ll | Hacker News Reader

What I like about this language is the crazy amount of creative and insightful discussions about language features and stabilization.

It's because Rust hits the spot for MANY different domains and people. System programmers, functional programmers, backend, db engineers, GUI, devs from the formal verification/mission critical camp, OS devs, graphics and even frontend with WASM.

For me personally, the thing I miss in Rust is better const fn/comptime/metaprogramming (like in C++). Without them, I find writing generic high-perf data structures quite tedious (and proc macros just aren't a suitable replacement for generics)

View on HN

I love Rust, but I kind of believe in the conspiracy that comptime code features are less loved by the Rust language maintainers because they increase compile time even more.

That directly contradicts in-progress efforts to make `const` better. Things like `const trait`, `const Allocators`, etc are all in progress.

Some const features seem like big anti-patterns though. One example is the unstable feature `generic_const_exprs` which I think is a bit short-sighted.

What seems short-sighted about that to you? I'm not super familiar, but it seems like something you'd want if you're using const generics.

"In progress" does not (by itself anyway) contradict "less-loved". Something can be in progress but making slower progress than it would if people were really excited about it.

This isn't the case, it's just that the approach to bring comp time evaluation to Rust is difficult because we're trying to side step potential back compat or ambiguous restrictions that we otherwise would have. Rust follows the "when it's ready" delivery approach wich means that some eagerly awaited features take much longer than us, as users, would want.

Which I appreciate. I don't want Rust turning into another C++ in 20 years.

I write a lot of Rust these days and unfortunately really great FP stuff is pretty damn cumbersome to write.

I found this viewpoint about FP in Rust pretty interesting. Can you elaborate?

One, the lack of support for HKT isn’t great. There are some work arounds, but they aren’t particularly safe and end up being pretty cumbersome to implement.

Another big one is while the language supports lambdas and closures, it’s highly recommended to not perform any currying.

Reply on news.ycombinator.com