use std::ops::Add;

struct A;
struct B;

impl Add<B> for A {
    type Output = &'static str;

    fn add(self, _: B) -> &'static str {
        "A + B"
    }
}

impl<'a> Add<&'a B> for A {
    type Output = &'static str;

    fn add(self, _: &'a B) -> &'static str {
        "A + &B"
    }
}

impl<'a> Add<B> for &'a A {
    type Output = &'static str;

    fn add(self, _: B) -> &'static str {
        "&A + B"
    }
}

impl<'a, 'b> Add<&'b B> for &'a A {
    type Output = &'static str;

    fn add(self, _: &'b B) -> &'static str {
        "&A + &B"
    }
}

struct Sneaky;

impl Add for Sneaky {
    type Output = &'static str;

    fn add(self, _: Sneaky) -> &'static str {
        "Sneaky + Sneaky"
    }
}

impl Sneaky {
    fn add(self, _: Sneaky) -> &'static str {
        "Boo!"
    }
}

fn main() {
    let a = &A;
    let b = &B;

    println!("{}", A + B);
    println!("{}", A.add(B));
    println!("{}", Add::add(A, B));
    println!("{}", <A as ::std::ops::Add<B>>::add(A, B));

    println!("{}", A + b);
    println!("{}", A.add(b));
    println!("{}", Add::add(A, b));
    println!("{}", <A as ::std::ops::Add<&B>>::add(A, b));

    println!("{}", a + B);
    println!("{}", a.add(B));
    println!("{}", Add::add(a, B));
    println!("{}", <&A as ::std::ops::Add<B>>::add(a, B));

    println!("{}", a + b);
    println!("{}", a.add(b));
    println!("{}", Add::add(a, b));
    println!("{}", <&A as ::std::ops::Add<&B>>::add(a, b));

    println!("{}", Sneaky + Sneaky);
    println!("{}", Sneaky.add(Sneaky));
    println!("{}", Add::add(Sneaky, Sneaky));
    println!("{}", <Sneaky as ::std::ops::Add<Sneaky>>::add(Sneaky, Sneaky));

}