use crate::func::*;

pub struct ResultClass<E: 'static>(E);

impl<E> WeakFunctor for ResultClass<E> {
    type F<'a, A: 'a> = Result<A, E>;
}

impl<E> Functor for ResultClass<E> {
    fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B> {
        fa.map(f)
    }

    fn replace<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, b: B) -> Self::F<'a, B> {
        fa.map(|_| b)
    }
}

impl<E> ApplicativeSeq for ResultClass<E> {
    fn seq<'a, A: 'a, B: 'a>(
        ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
        fa: Self::F<'a, A>,
    ) -> Self::F<'a, B> {
        Self::pure(ff?(fa?))
    }
}

impl<E> ApplicativeLA2 for ResultClass<E> {
    fn la2<'a, A: 'a, B: 'a, C: 'a>(
        f: impl 'a + FnOnce(A, B) -> C,
        fa: Self::F<'a, A>,
        fb: Self::F<'a, B>,
    ) -> Self::F<'a, C> {
        Self::pure(f(fa?, fb?))
    }
}

impl<E> ApplicativeTuple for ResultClass<E> {
    fn tuple<'a, A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
    where
        Self: 'a,
    {
        Self::pure((fa?, fb?))
    }
}

impl<E> Applicative for ResultClass<E> {
    fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A> {
        Ok(a)
    }

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

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

impl<E> Monad for ResultClass<E> {
    fn bind<'a, A: 'a, B: 'a>(
        fa: Self::F<'a, A>,
        f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
    ) -> Self::F<'a, B> {
        f(fa?)
    }

    fn join<'a, A: 'a>(ffa: Self::F<'a, Self::F<'a, A>>) -> Self::F<'a, A> {
        ffa?
    }
}