interface Functor<A> {
        <B> Functor<B> map(Function<A, B> f);
    }

    interface Monad<A, M extends Monad> extends Functor<A> {
        <B> Monad<B, M> bind(Function<A, M> f);
    }

    interface Maybe<A> extends Monad<A, Maybe> {

        static <A> Maybe<A> point(final A a) {
            return a == null ? Nothing : new Just<>(a);
        }

        class Just<A> implements Maybe<A> {
            public final A a;

            public Just(A a) {
                this.a = a;
            }

            @Override
            public <B> Maybe<B> map(final Function<A, B> f) {
                return point(f.apply(a));
            }

            @Override
            public <B> Maybe<B> bind(final Function<A,
                   Maybe> f) { //should be Maybe<B> but can't typed in Java
                return f.apply(a);
            }
        }

        Maybe Nothing = new Maybe() {
            @Override
            public Maybe bind(Function f) {
                return Nothing;
            }

            @Override
            public Maybe map(final Function f) {
                return Nothing;
            }
        };
    }

public interface Fn<A, B> {
    B apply(A a);

    static <X> Fn<X, X> I() {
        return x -> x;
    }

    // Kxy = x

    static <X, Y> Fn<X, Fn<Y, X>> K() {
        return x -> y -> x;
    }

    // Sxyz = xz(yz)

    static <X, Y, Z> Fn<Fn<Z, Fn<Y, X>>,
            Fn<Fn<Z, Y>, Fn<Z, X>>> S() {
        return x -> y -> z ->
                x.apply(z).apply(y.apply(z));
    }

    // Yf=f(Yf)

    interface Y<A> extends Fn<Y<A>, Fn<A, A>> {
        static <A> Y<A> Y() {
            return f -> f.apply(f);
        }
    }

    static <A> Fn<Fn<Fn<A, A>,
            Fn<A, A>>, Fn<A, A>> Y() {
        return g -> Y.<A>Y().apply(f ->
                g.apply(x -> f.apply(f).apply(x)));
    }
}