type erasure (closure type) in rust

main.rs

trait AnimalExt {
    type Food;
    
    fn eat(&self, food: Self::Food);
}

struct Dog;

impl AnimalExt for Dog {
    type Food = String;

    fn eat(&self, food: String) {
        println!("Dog eats {:?}", food);
    }
}

struct Cat;

impl AnimalExt for Cat {
    type Food = u32;

    fn eat(&self, food: u32) {
        println!("Cat eats {:?}", food);
    }
}

struct AnyAnimal<T> {
    eat: Box<Fn(T)>,
}

impl<T> AnyAnimal<T> {
    fn new<A>(animal: A) -> Self
    where
        A: AnimalExt<Food=T> + 'static,
    {
        AnyAnimal {
            eat: Box::new(move |food| animal.eat(food)),
        }
    }
}

impl<T> AnimalExt for AnyAnimal<T> {
    type Food = T;

    fn eat(&self, food: T) {
        (self.eat)(food)
    }
}

fn main() {
    let dog = AnyAnimal::new(Dog);
    dog.eat("meet".to_string());

    let cat = AnyAnimal::new(Cat);
    cat.eat(1);

    // cat.eat("Dog food"); <- compile error
}