Is there a way other than traits to add methods to a type I don't own?

I'm trying to extend the Grid struct from the piston-2dgraphics library. There's no method for getting the location on the window of a particular cell, so I implemented a trait to calculate that for me. Then, I wanted a method to calculate the neighbours of a particular cell on the grid, so I implemented another trait.

Something about this is ugly and feels unnecessary seeing as how I'll likely never use these traits for anything other than this specific grid structure. Is there another way in Rust to extend a type without having to implement traits each time?

Solution 1:

As of Rust 1.27, no, there is no other way. It's not possible to define inherent methods on a type defined in another crate.

You can define your own trait with the methods you need, then implement that trait for an external type. This pattern is known as extension traits. The name of extension traits, by convention, ends with Ext, to indicate that this trait is not meant to be used as a generic bound or as a trait object. There are a few examples in the standard library.

trait DoubleExt {
    fn double(&self) -> Self;
}

impl DoubleExt for i32 {
    fn double(&self) -> Self {
        *self * 2
    }
}

fn main() {
    let a = 42;
    println!("{}", 42.double());
}

Other libraries can also export extension traits (example: byteorder). However, as for any other trait, you need to bring the trait's methods in scope with use SomethingExt;.

Solution 2:

No. Currently, the only way to write new methods for a type that has been defined in another crate is through traits. However, this seems too cumbersome as you have to write the both the trait definition and the implementation.

In my opinion, the way to go is to use free functions instead of methods. This would at least avoid the duplication caused by traits.