monads

template <class <typename> F>
struct Functor : private Applicative<F> {
    template <typename T, typename Function>
    static F<T> fmap(Function&& f, F<T> x) {
        return ap(pure(move(f)), move(x));
    }
};

template <class <typename> M>
struct Applicative<M> : private Monad<M> {
    template <typename T>
    static M<T> pure(T&& x) {
        return ret(forward<T>(x));
    }

    template <typename Function, typename T>
    static M<T> ap(M<Function> mf, M<T> mx) {
        return bind(move(x), [&mx](Function f) {
            return bind(
                move(mx),

                [&f](T x) {
                    return ret(f(move(x)));
                }
            );
        }
    }
};