Announcing Rust 1.86.0 (blog.rust-lang.org)
from neme@lemm.ee to rust@programming.dev on 03 Apr 11:30
https://lemm.ee/post/60264072

#rust

threaded - newest

livingcoder@programming.dev on 03 Apr 12:12 next collapse

Wow, that trait feature is great. I’ve been eagerly waiting for that one for a long time. Thank you to everyone who made that possible.

INeedMana@lemmy.world on 08 Apr 13:34 collapse

If a trait has a supertrait you can coerce a reference to said trait object to a reference to a trait object of the supertrait

As someone that just started learning Rust: wha?

livingcoder@programming.dev on 08 Apr 14:28 collapse

Basically, you can generalize your trait types into their parent (super) traits for situations when functionality is specific to those supertrait objects.

As an example, if you have a trait CanBark and it is a super trait for the trait IsDog, you can coerce your references of &dyn IsDog into a &dyn CanBark. You can then work with other trait types that share a super trait.

trait CanBark {
    fn bark(&self);
}
trait IsSeal: CanBark { }
trait IsDog: CanBark { }

fn bark_as_group(barkers: &Vec<&dyn CanBark>) {
    for barker in barkers {
        barker.bark();
    }
}

let spot: &dyn IsDog = get_spot();
let seal: &dyn IsSeal = get_seal();
let barkers: Vec<&dyn CanBark> = Vec::new();
barkers.push(spot);  // coerced
barkers.push(seal);  // coerced
bark_as_group(&barkers);

At least, I hope this is possible now. If it’s purely “you can return a coerced type from a function”, that is less useful.

INeedMana@lemmy.world on 09 Apr 10:49 collapse

Thank you

So basically, it’s like inheritance but for traits?

livingcoder@programming.dev on 09 Apr 12:31 collapse

Exactly. The functions of the super trait are also required when implementing the child trait’s functions, as you would expect from inheritance.

sugar_in_your_tea@sh.itjust.works on 24 Apr 02:17 collapse

HashMaps and slices now support indexing multiple elements mutably

This is kinda neat. I was hoping for something more generic, so hopefully this is a step toward that.

Allow safe functions to be marked with the #[target_feature] attribute.

This seems huge for library authors! That’s not me as of yet, but maybe soon. 😀

Congrats on the release!