use crate::func::*;

struct LazyClass;

impl WeakFunctor for LazyClass {
    type F<'a, A> = Box<dyn 'a + FnOnce() -> A>;
}

impl Functor for LazyClass {
    fn fmap<'a, A: 'a, B: 'a, F: 'a + FnOnce(A) -> B>(f: F, fa: Self::F<'a, A>) -> Self::F<'a, B> {
        Box::new(|| f(fa()))
    }

    fn replace<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, b: B) -> Self::F<'a, B> {
        drop(fa);
        Box::new(|| b)
    }

    fn void<'a, A: 'a>(fa: Self::F<'a, A>) -> Self::F<'a, ()> {
        drop(fa);
        Box::new(|| ())
    }
}

impl ApplicativeSeq for LazyClass {
    fn seq<'a, A: 'a, B: 'a, F: 'a + FnOnce(A) -> B>(
        ff: Self::F<'a, F>,
        fa: Self::F<'a, A>,
    ) -> Self::F<'a, B> {
        Box::new(|| ff()(fa()))
    }
}

impl ApplicativeLA2 for LazyClass {
    fn la2<'a, A: 'a, B: 'a, C: 'a, F: 'a + FnOnce(A, B) -> C>(
        f: F,
        fa: Self::F<'a, A>,
        fb: Self::F<'a, B>,
    ) -> Self::F<'a, C> {
        Box::new(|| f(fa(), fb()))
    }
}

impl Applicative for LazyClass {
    fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A> {
        Box::new(|| a)
    }

    fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {
        drop(fa);
        fb
    }

    fn discard_second<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, A> {
        drop(fb);
        fa
    }
}

impl Monad for LazyClass {
    fn bind<'a, A: 'a, B: 'a, F: 'a + FnOnce(A) -> Self::F<'a, B>>(
        fa: Self::F<'a, A>,
        f: F,
    ) -> Self::F<'a, B> {
        Box::new(|| f(fa())())
    }

    fn join<'a, A: 'a>(ffa: Self::F<'a, Self::F<'a, A>>) -> Self::F<'a, A>
    where
        Self::F<'a, A>: 'a,
    {
        Box::new(|| ffa()())
    }
}