Would not be part of the core language. Quite feasible as a package or plugin, and I think under development.
> pure functional programming (enforcing it in an isolated subset of the code)
I don't believe Rust has a way to enforce purity of a function, but the type system could certainly help you out. Rust's type system doesn't have HKTs, so you can't do generic monads, but you could probably do an IO-specific monad.
>laziness
Already implemented in the loose sense with e.g. lazy iterators. Thunk-based evaluation could be implemented using operator overloading, lazy data structures, etc.
>(clean) meta-programming
I haven't used it a whole lot, but Rust's macro system seems clean and powerful.
>introspection
Could you expand a bit on what you mean by this? The kind of introspection I'm thinking of seems to run counter to the strict correctness and isolation principles espoused by Rust.
>garbage collection
This would be implemented using a custom wrapper type. I think it's in the works. However, the need for GC is mostly obviated by the statically checked lifetime system.
>Also, how does Rust compare to other modern languages, like Scala?
Rust, obviously, does not run on the JVM.
The type system is similarly rich, although (being HM-based) does not support subtyping (instead opting for the interface/typeclass/trait-only approach used by e.g. Haskell). The most obvious improvement over Scala is substantially improved type inference.
Scala absolutely requires heavy heap usage and GC. Rust requires no heap usage and absolutely no GC. All that stuff is determined at compile time, which is great for determinism and performance. The downside is that it requires some more effort from the programmer to think about lifetimes and such.
Rust has a substantially lower-level focus than languages like Scala or Haskell. It aims to be a C(++) replacement, not a Java replacement.
Would not be part of the core language. Quite feasible as a package or plugin, and I think under development.
> pure functional programming (enforcing it in an isolated subset of the code)
I don't believe Rust has a way to enforce purity of a function, but the type system could certainly help you out. Rust's type system doesn't have HKTs, so you can't do generic monads, but you could probably do an IO-specific monad.
>laziness
Already implemented in the loose sense with e.g. lazy iterators. Thunk-based evaluation could be implemented using operator overloading, lazy data structures, etc.
>(clean) meta-programming
I haven't used it a whole lot, but Rust's macro system seems clean and powerful.
>introspection
Could you expand a bit on what you mean by this? The kind of introspection I'm thinking of seems to run counter to the strict correctness and isolation principles espoused by Rust.
>garbage collection
This would be implemented using a custom wrapper type. I think it's in the works. However, the need for GC is mostly obviated by the statically checked lifetime system.
>Also, how does Rust compare to other modern languages, like Scala?
Rust, obviously, does not run on the JVM.
The type system is similarly rich, although (being HM-based) does not support subtyping (instead opting for the interface/typeclass/trait-only approach used by e.g. Haskell). The most obvious improvement over Scala is substantially improved type inference.
Scala absolutely requires heavy heap usage and GC. Rust requires no heap usage and absolutely no GC. All that stuff is determined at compile time, which is great for determinism and performance. The downside is that it requires some more effort from the programmer to think about lifetimes and such.
Rust has a substantially lower-level focus than languages like Scala or Haskell. It aims to be a C(++) replacement, not a Java replacement.