#[derive(Clone)]
pub struct Foobar {
    first: String,
    second: String,
    third: String,
}

fn grab_first(foobar: &Foobar) -> &str {
    &foobar.first
}

#[derive(PartialEq)]
pub struct Wrapper<'a>(&'a str);

fn grab_first_wrapper(foobar: &Foobar) -> Wrapper {
    Wrapper(&foobar.first)
}

pub trait CompareCallback<'a> {
    type Output: 'a + PartialEq;
    fn call(&'a self, arg: &'a Foobar) -> Self::Output;
}
impl<'a, R: 'a, F> CompareCallback<'a> for F
where
    F: Fn(&'a Foobar) -> R,
    R: PartialEq,
{
    type Output = R;
    fn call(&'a self, arg: &'a Foobar) -> R {
        self(arg)
    }
}

pub fn go<F>(lhs: Foobar, rhs: Foobar, f: F) -> bool
where
    F: for<'a> CompareCallback<'a>,
{
    f.call(&lhs) == f.call(&rhs)
}

fn main() {
    let a = Foobar {
            first: "alpha".to_owned(),
            second: "beta".to_owned(),
            third: "gamma".to_owned()
        };
    let b = Foobar {
            first: "alpha".to_owned(),
            second: "delta".to_owned(),
            third: "epsilon".to_owned()
        };
    dbg!(go(a.clone(), b.clone(), grab_first));
    dbg!(go(a.clone(), b.clone(), grab_first_wrapper));
}