[Idea] Fluent Interface for Monad instances.

This is untested at the moment, its just an idea. One advantage FJ has over us at the moment is a fluent interface for their monads (admittably by violating the DRY principle).

Maybe we could design a wrapper to also give us the fluent interface pattern.

One way:

interface FluentInterfaceM<M,A> {
  __<M,A> unbox(Monad<M> mMonad);

  static <A> FluentInterfaceM<M,A> pure(A a) {
    return (Monad<M> mMonad) -> mMonad.pure(a);
  }

  default <B> FluentInterfaceM<M,B> map(F<A,B> f) {
    return (Monad<M> mMonad) ->
      mMonad.map(f, FluentInterface.this.unbox(mMonad))
  }

  default <B> FluentInterfaceM<M,B> bind(F<A,FluentInterfaceM<M,B>> f) {
    return (Monad<M> mMonad) ->
      mMonad.bind(
        FluentInterface.this.unbox(mMonad)
        (A x) -> f.f(x).unbox(mMonad)
      );
  }
}

Example use:

__<__<__<StateT.Mu,Integer>,Maybe.Mu>,Unit> test =
  FluentInterfaceM.pure(5)
    .map((Integer x) -> x + 1)
    .map((Integer x) -> x * 2)
    .map((Integer x) -> x - 3)
    .unbox(StateT.monad(Maybe.monad));

Maybe FIM instead of FluentInterfaceM to keep it short.

[DanielGronau]

How about this:

   interface MonadW<M, A, MM extends Monad<M>> {
        static <M, A, MM extends Monad<M>> MonadW<M, A, MM> pure(A a) {
            return mMonad -> mMonad.pure(a);
        }

        default <B> MonadW<M, B, MM> bind(Function<A, MonadW<M, B, MM>> f) {
            return mMonad -> mMonad.bind(
                    MonadW.this.unbox(mMonad),
                    (A x) -> f.apply(x).unbox(mMonad)
                    );
        }

        default <B> MonadW<M, B, MM> map(Function<A, B> f) {
            return mMonad -> mMonad.map(f, MonadW.this.unbox(mMonad));
        }

        __<M, A> unbox(MM mMonad);
    }

    interface MonadPlusW<M, A, MP extends MonadPlus<M>> extends MonadW<M, A, MP> {
        @Override
        __<M, A> unbox(MP mMonadPlus);

        default MonadPlusW<M,A, MP> mzero() {
            return mPlus -> mPlus.mzero();
        }
    }

[clinuxrulz]

Version 3 of do notation now has a fluent style. Making monad wrappers less important. But I’ll leave this open for discussion of other kinds of wrappers for other type-classes.