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

[phoronix]

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

The developers behind the Rust programming language have put out a road-map for the year as well as details on the forthcoming "Rust 2018" Edition that succeeds the 1.x release series...

http://www.phoronix.com/scan.php?page=news_item&px=Rust-2018-Roadmap

[uid313]

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.

[mmstick]

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.

How is it reminiscent of Ruby? There's no comparison -- completely different syntax.

[shmerl]

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

[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.

[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 ?

[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?

[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

[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]

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.