`const fn` in Trait implementation.

[ldm0]

For code like this:

#[derive(Debug, Clone, Copy)]
pub struct Vec3 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

impl std::ops::Add<Vec3> for Vec3 {
    type Output = Vec3;
    const fn add(self, b: Vec3) -> Self::Output {
        Vec3 {
            x: self.x + b.x,
            y: self.y + b.y,
            z: self.z + b.z,
        }
    }
}

This currently emits:

error[E0379]: functions in traits cannot be declared const                                                                                                                                                  
  --> src\main.rs:10:5
   |
10 |     const fn add(self, b: Vec3) -> Self::Output {
   |     ^^^^^ functions in traits cannot be const

error: aborting due to previous error                                                                                                                                                                       

For more information about this error, try `rustc --explain E0379`.

It would be extremely useful if we could have const fn in trait implementation (especially for operator overloading). And I saw this is also mentioned in the RFC 0911.

[ldm0]

Interestingly, I found the #68847 and it has been merged. So now we can have code below compiles:

#![feature(const_fn)]
#![feature(const_trait_impl)]
#[derive(Debug, Clone, Copy)]
pub struct Vec3 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

impl const std::ops::Add<Vec3> for Vec3 {
    type Output = Vec3;
    fn add(self, b: Vec3) -> Self::Output {
        Vec3 {
            x: self.x + b.x,
            y: self.y + b.y,
            z: self.z + b.z,
        }
    }
}

But that have not directly solves the problem in this issue. Since some trait may contains more than one functions and only some of them are able to be const function.

[ecstatic-morse]

@ldm0, rust-lang/rfcs#2632 is still actively being designed. Perhaps you'd like to participate in that discussion?

I'll close this since I don't think it's actionable. If the initial implementation is not working as the RFC specifies, feel free to reopen.