How is this legal?

[anon80458984]

pub struct Foo<T> {
    t: T,
}

impl Foo<u32> {
    pub fn a(&self) {}
}

impl Foo<()> {
    pub fn b(&self) {}
}

This code appears to compile. Yet, it confuses me that on a generic, when there are different generic parameters, wee can have different implemented functions. Is there a name for this 'feature' ?

[H2CO3]

Foo<u32> and Foo<()> are different concrete types. There's no name specifically for allowing this as far as I know.

[alice]

See this post of mine:

Building more intuition for `MyType<T>` and `MyTrait<U>`

To explain this, it may be useful to think about the "implements" relation. For each type/trait pair, either the type implements the trait, or it does not. When it does implement it, you can use the (type, trait) pair to look up the implementation, which gives you knowledge of anything inside the impl block (the methods, associated types, associated constants and so on). Notably, a type can only implement a given trait once. How do generics come into the picture? Well, basically, you don't get …

[steffahn]

One typical example of this is types like

pub struct HashMap<K, V, S = RandomState> { /* private fields */ }

which comes with several impl blocks, and some of them are only defined for the S = RandomState case (such as e.g. HashMap::new).

[jdahlstrom]

In C++ this is called explicit specialization, but in Rust the term "specialization" usually refers to overlapping specializations, which C++ supports but stable Rust does not.

In any case, the ability to customize different instances, or sets of instances, of a generic type adds quite a bit of expressive power to generics.

[drmason13]

impl AsRef<String> for Box<String> { ... }
impl AsRef<char> for Box<String> { ... }

I think this is a typo in your linked post, second line should be?

impl AsRef<char> for Box<char> { ... }

Very helpful though, nice post