Specialise function implementation for a struct implementation

Question

I am implementing a struct with a generic bounded to a trait, but that implementation is desirable to feature functions that bound the generic even more. Below is the example:

struct A<T> {
   data: T
}

impl <T: AsRef<[u8]>> A<T> {
    fn test(&self, t: &T) {}
    fn more_bound<S: AsRef<[u8]> + PartialEq>(&self, t: &S) {
        self.test(t);  
    }
}

Playground

I cannot really use a specialization as I don't implement a trait. Neither would I like to define a trait. Are there any other options except changing the signature of test to fn test(&self, t: &impl AsRef<[u8]>) {}? Because such an approach seems to defeat the purpose of generics (in this case).

Does this answer your question? Can a trait give default implementation for *some* methods of a parent trait? — Chayim Friedman
– Chayim Friedman, Commented Dec 5, 2021 at 13:50
Not entirely, my design goal is to not introduce traits (let alone the trait inheritance), but have specializations in struct's impl. — Victor Ermolaev
– Victor Ermolaev, Commented Dec 6, 2021 at 8:37
Trait inheritance can be eliminated, but I didn't saw you don't use traits. — Chayim Friedman
– Chayim Friedman, Commented Dec 6, 2021 at 10:16

user2722968 · Accepted Answer · 2021-12-05 12:07:23Z

2

The compiler throws an error because in more_bound you take an S and then pass it into test, which requires a T. The fact that S and T are both AsRef<[u8]> (and T is weaker than S) is irrelevant since those generics have to match a fixed, concrete type (you promised a &T but gave an &S - who knows what &S is).

You can simply split the impl into two parts:

impl<T: AsRef<[u8]>> A<T> {
    fn test(&self, t: &T) {}
}

impl<T: AsRef<[u8]> + PartialEq> A<T> {
    fn more_bound(&self, t: &T) {
        self.test(t);
    }
}

The second impl will only be applicable for a T that is AsRef<[u8]> + PartialEq. As this bound guarantees that this T is AsRef<[u8]>, the more_bound method can call test, defined in the first impl.

If your original goal was to allow more_bound to be called with different types, you'll have to do the type-conversion via AsRef yourself:

impl <T: AsRef<[u8]>> A<T> {
    // Notice `test`takes the target of `AsRef<[u8]>`
    fn test(&self, t: &[u8]) {}

    fn more_bound<S: AsRef<[u8]> + PartialEq>(&self, t: &S) {
        // `S` can be whatever we want, it never "meets" `T`.
        self.test(t.as_ref()); 
    }
}

answered Dec 5, 2021 at 12:07

user2722968

17.4k5 gold badges58 silver badges77 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Victor Ermolaev Over a year ago

Wow, so simple. Not sure why I did not try it myself!

Collectives™ on Stack Overflow

Specialise function implementation for a struct implementation

1 Answer 1

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related