multiple implementations of same generic trait and how to apply

rust_generictrait_eg.rs

pub enum Entity {
    Foo,
    Bar,
}
pub trait ExtractEntity<T> {
    fn extract_entity(&self, out: Entity) -> Option<T>;
} 


pub trait ExtractEntity2<T> {
    fn extract_entity2(&self) -> T;
} 

#[derive(Debug)]
struct Foo {
    foo_name: String
}

impl Foo {
    pub fn new(foo_name: String) -> Foo {
        Foo { foo_name } 
    }
}

#[derive(Debug)]
pub struct Bar {
    bar_name: String
}

impl Bar {
    pub fn new(bar_name: String) -> Bar {
        Bar { bar_name } 
    }
}

#[derive(Debug)]
struct Bla {
    foo: Foo,
    bar: Bar,
}

impl ExtractEntity<Bar> for Bla {
    fn extract_entity(&self, out: Entity) -> Option<Bar> {
        if let Entity::Bar = out {
         Some(Bar::new(self.bar.bar_name.clone()))
        } else {
            None
        }
    }
}


impl ExtractEntity2<Bar> for Bla {
    fn extract_entity2(&self) -> Bar {
       
         Bar::new(self.bar.bar_name.clone())
       
    }
}

impl ExtractEntity<Foo> for Bla {
    fn extract_entity(&self, out: Entity) -> Option<Foo> {
        if let Entity::Foo = out {
         Some(Foo::new(self.foo.foo_name.clone()))
        } else {
            None
        }
    }
}


impl ExtractEntity2<Foo> for Bla {
    fn extract_entity2(&self) -> Foo {
       
         Foo::new(self.foo.foo_name.clone())
       
    }
}

fn main () {
   let bla = Bla { foo: Foo{foo_name: "FOO".to_string()}, bar: Bar{bar_name: "BAR".to_string()}};
    println!("{:?}", bla);
    //let mut bar: Bar = Bar::new(String::new());
    let bar: Bar = bla.extract_entity2();
    let foo: Foo = bla.extract_entity2();
    println!("foo {:?}  bar {:?}", foo, bar);
}