//! Simplest sync [Monad].
//!
//! For async, see [`super::future`].

use crate::func::*;

#[derive(SharedFunctor, CovariantFunctor)]
pub struct SoloClass;

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

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

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

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

impl Pure for SoloClass {
    fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A> {
        a
    }
}

impl ApplicativeSeq for SoloClass {
    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> {
        ff(fa)
    }
}

impl ApplicativeLA2 for SoloClass {
    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> {
        f(fa, fb)
    }
}

impl ApplicativeTuple for SoloClass {
    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,
    {
        (fa, fb)
    }
}

impl Applicative for SoloClass {
    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 SoloClass {
    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 iterate_mut<'a, A: 'a, B: 'a>(
        mut a: A,
        mut f: impl 'a + FnMut(A) -> Self::F<'a, ControlFlow<B, A>>,
    ) -> Self::F<'a, B>
    where
        Self: 'a,
    {
        loop {
            match f(a) {
                ControlFlow::Continue(next_a) => a = next_a,
                ControlFlow::Break(b) => return b,
            };
        }
    }

    fn iterate_argument<'a, A: 'a, B: 'a>(
        mut a: A,
        mut f: impl AIterative<'a, T = Self, A = A, B = B>,
    ) -> Self::F<'a, B>
    where
        Self: 'a,
    {
        loop {
            match f.next(a) {
                ControlFlow::Continue((new_a, new_f)) => (a, f) = (new_a, new_f),
                ControlFlow::Break(b) => return b,
            }
        }
    }

    fn iterate<'a, B: 'a>(mut f: impl Iterative<'a, T = Self, B = B>) -> Self::F<'a, B>
    where
        Self: 'a,
    {
        loop {
            match f.next() {
                ControlFlow::Continue(next_f) => f = next_f,
                ControlFlow::Break(b) => return b,
            }
        }
    }

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

impl LocalFunctor for SoloClass {
    fn unstuff<'a, A: 'a, B: 'a>(
        state: Self::F<'a, ControlFlow<B, A>>,
    ) -> ControlFlow<Self::F<'a, B>, A>
    where
        Self: 'a,
    {
        state
    }

    fn stuff<'a, A: 'a, T: 'a + Pure>(fa: Self::F<'a, T::F<'a, A>>) -> T::F<'a, Self::F<'a, A>>
    where
        Self: 'a,
    {
        fa
    }
}

impl Fail<std::convert::Infallible> for SoloClass {
    fn fail<'a, A: 'a>(e: std::convert::Infallible) -> Self::F<'a, A>
    where
        Self: 'a,
        std::convert::Infallible: 'a,
    {
        match e {}
    }
}