Why can a method with a const generic boolean not call a method that is implemented for both true and false?

Question

This code works perfectly (playground):

struct MyStruct<const B: bool>;

impl MyStruct<false> {
    pub fn bar() {
        println!("false");
    }
}
impl MyStruct<true> {
    pub fn bar() {
        println!("true");
    }
}

impl MyStruct<false> {
    pub fn foo() {
        MyStruct::<false>::bar()
    }
}
impl MyStruct<true> {
    pub fn foo() {
        MyStruct::<true>::bar()
    }
}

fn main() {
    MyStruct::<false>::foo();
    MyStruct::<true>::foo();
}

It results in:

false
true

On the other hand, this code will fail (playground):

struct MyStruct<const B: bool>;

impl MyStruct<false> {
    pub fn bar() {
        println!("false");
    }
}
impl MyStruct<true> {
    pub fn bar() {
        println!("true");
    }
}

impl<const B: bool> MyStruct<B> {
    pub fn foo() {
        MyStruct::<B>::bar()
    }
}

fn main() {
    MyStruct::<false>::foo();
    MyStruct::<true>::foo();
}

Resulting in:

error[E0599]: no function or associated item named `bar` found for struct `MyStruct<B>` in the current scope
  --> src/main.rs:16:24
   |
1  | struct MyStruct<const B: bool>;
   | ------------------------------- function or associated item `bar` not found for this
...
16 |         MyStruct::<B>::bar()
   |                        ^^^ function or associated item not found in `MyStruct<B>`
   |
   = note: the function or associated item was found for
           - `MyStruct<false>`
           - `MyStruct<true>`

I could understand this error in the case of infinitely valued types, but why for booleans?

Is there a way to overcome this?

Answer 1

One has to use a trait and generic type conditioning (playground):

struct MyStruct<const B: bool>;

trait Bar {
    fn bar();
}

impl Bar for MyStruct<false> {
    fn bar() {
        println!("false");
    }
}
impl Bar for MyStruct<true> {
    fn bar() {
        println!("true");
    }
}

impl<const B: bool> MyStruct<B>
where
    MyStruct<B>: Bar,
{
    pub fn foo() {
        MyStruct::<B>::bar()
    }
}

fn main() {
    MyStruct::<false>::foo();
    MyStruct::<true>::foo();
}

---

Of course, the principle is generalizable to other types than bool (playground):

struct MyStruct<const U: usize>;

trait Bar {
    fn bar();
}

impl Bar for MyStruct<0> {
    fn bar() { println!("0"); }
}
impl Bar for MyStruct<1> {
    fn bar() { println!("1"); }
}
impl Bar for MyStruct<100> {
    fn bar() { println!("100"); }
}

impl<const U: usize> MyStruct<U> where MyStruct<U> : Bar {
    pub fn foo() { MyStruct::<U>::bar() }
}

fn main() {
    MyStruct::<0>::foo();
    MyStruct::<1>::foo();
    MyStruct::<100>::foo();
}