- Raw-pointer equivalent to lifetime parameters (`GenericStruct<*>`, converts `&'a T` into `*const T` and `&'a mut T` into `*mut T`) - `impl Trait` for associa

- Raw-pointer equivalent to lifetime parameters (`GenericStruct<*>`, converts `&'a T` into `*const T` and `&'a mut T` into `*mut T`) - `impl Trait` for associated types. This lets you workaround async trait functions without boxing the returned futures and also return anonymous closures from traits - And with that, async trait functions trait Foo { async fn hello() -> Bar; } impl Foo for Baz { async fn hello() -> Bar { ... } } // desugars to trait Foo { type __Hello: Future<Output=Bar>; fn hello() -> Self::__Hello; } impl Foo for Baz { type __Hello = impl Future<Output=Bar>; fn hello() -> Self::__Hello { ... } } - Limited support for `impl Trait` with different return types, by returning an enum on traits where all methods can be trivially implemented (see https://crates.io/crates/auto_enums https://crates.io/crates/auto_enums) - Explicitly assert trait variance, and unsafely override trait variance. - Improved compile-time support. In particular, enough support so that you can write functions that generate other functions at compile-time, e.g. `const fn pull_factory(repo_url: &str) -> impl Fn(&mut Repository)`, `const pull_my_repo = pull_factory("https://github.com/my-org/my-repo.git https://github.com/my-org/my-repo.git");` - Remove restriction on `Self` parameters in trait objects, or at least allow `self: &Rc<Self>` and `self: &Arc<Self>`, as `self: Rc<Self>` and `self: Arc<Self>` are allowed - Allow generics in trait objects if the generic parameter is only accessed / returned behind references and raw pointers, as then the compiler should be able to implement by generating 2 specialized variants: one for thin pointers and one for fat pointers. - More declarative macro support, e.g. more types of ASTs as metavars - Partial borrows: https://github.com/rust-lang/rfcs/issues/1215 https://github.com/rust-lang/rfcs/issues/1215 - Mutability variance: e.g. write `fn index<&a>(&a self, idx: Idx) -> &a T`, instead of needing to write `fn index(&self, idx: Idx) -> &T` and `fn index_mut(&mut self, idx: Idx) -> &mut T`) - Built-in unit types (e.g. write `#[unit(ms)] pub struct Milliseconds(usize)`, and then you can write `128ms` => `Milliseconds(128)`)