Rust Gets A 2018 Roadmap, Big "Productivity" Edition Planned This Year

[Luke_Wolf]

Technically it seems like an amazing language with the things it offers, like it offers safety and security.
But as a developer, it looks really tricky to use and with an awkward syntax reminiscent of Ruby, yuck.

It's not C-Style syntax but I would be loathe to call it awkward, anyone who knows a language using C-Style syntax can quite easily piece together what is going on in Rust code and it is no harder to write than C-Style syntax, we're not exactly talking Lisp here. it's a really easy transition.

Now on the other hand learning to write correct code is a pain in the ass, and that's the biggest challenge Rust gives you.

Idiots who think that OOP is about class hierarchies will have to wake up to the fact that no that's not what it means (it means modelling your programs around real world objects and concepts, rather than focusing on the procedures), and everyone and their mother is using Interface-Based-Polymorphism nowadays instead, with traits being a vastly more powerful version of the interface concept... but again that's about learning to write correct code.

[Khrundel]

Looks like there will be some breaking changes. They mention opt-in editions, to use new features one must add edition="2018" to cargo.toml

[GunpowaderGuy]

Compile-time executions & pi types won't make any existing features redundant. They solve different problems.

ctfe can be used to build a borrow checker as a library ( https://medium.com/@bhuztez/emulate-...g-db4b5e94449f ); first class types can make generics redundant ( as explained in the zig programing language website ) , if my understanding is correct , both features coupled with first class modules can be used to emulate traits / classes ; and they also reduce the need for macros , directly ( again , as in zig ) , and indirectly ( no traits means no custom derive )

Edit : almost forgot , cfte can also be used as a replacement for link time optimization , which cretonne is going to lack

[mmstick]

thank you for sharing that ! Any idea what will happen to the soon to be redundant features ? Or which of the ones i mentioned have been discussed as being potentially redundant ?

Compile-time executions & pi types won't make any existing features redundant. They solve different problems.

[GunpowaderGuy]

thank you for sharing that ! Any idea what will happen to the soon to be redundant features ? Or which of the ones i mentioned have been discussed as being potentially redundant ?

[mmstick]

I wonder if they would accept some features such as compile time function execution and first class types ( aka https://ziglang.org/) with the goal of obsoleting many more ( macros , generics , procedural macros , maybe converting the implementation of traits and the borrow checker into libraries ) ; maybe in a future version 2.0 ?

This is already being discussed / worked on. There's no need for a 2.0 release, because it can be fully implemented in a forward-compatible manner. The issues to watch are:

- const generics: https://github.com/rust-lang/rust/issues/44580
- const fn: https://github.com/rust-lang/rust/issues/24111
- pi types: https://github.com/rust-lang/rfcs/issues/1930

[jacob]

I wonder if they would accept some features such as compile time function execution and first class types ( aka https://ziglang.org/) with the goal of obsoleting many more ( macros , generics , procedural macros , maybe converting the implementation of traits and the borrow checker into libraries ) ; maybe in a future version 2.0 ?

Rust does have compile-time execution through procedural macros. It's not exactly easy to use or particularly well suited for simple cases such as pre-generating tables etc.; but it's there and many things can be built on top of it. The main shortcoming of Rust's type system is that it doesn't support HKTs as first class types in the way Haskell does. I would love to see this added. The rest of your points don't make much sense to me: the borrow checker is a static analysis pass built into the compiler, how exactly would you "convert that into a library"? Same thing for the traits?

[GunpowaderGuy]

I wonder if they would accept some features such as compile time function execution and first class types ( ala https://ziglang.org/) with the goal of obsoleting many more ( macros , generics , procedural macros , maybe converting the implementation of traits and the borrow checker into libraries ) ; maybe in a future version 2.0 ?

[miabrahams]

Technically it seems like an amazing language with the things it offers, like it offers safety and security.
But as a developer, it looks really tricky to use and with an awkward syntax reminiscent of Ruby, yuck.

The awkward syntax and brutal correctness requirements before the compiler will accept the code are the price you pay to ensure your code is correct when it compiles. You trade off time up front when writing code and the dividend is paid in the form of less debugging after the fact. This is a clear benefit to many projects. If your model is that Rust is "tricky to use" but C is "not tricky to use," then you don't know C very well.

[shmerl]

Doesn't remind me Ruby at all. Except may be for using | | in closures.