Thank you very much for your reply! … however my puzzling thing (regardless of representation) is not really about category theory or Haskell representation but rather that M[_] is not necessarily a functor or a monad for that matter. It is just a higher kinded type thus when we compose things we’re not back in the monad’s space that allows us to do further composition unless we wrap it int a Monad either explicitly or using implicit conversions.

In my second example all transformations return an M[T] which must be an Monad M trait refinement thus being easy to see further composition.

Appreciate your thoughts.

Br’s,
Marius

trait Monad[M[_]] extends Functor[M] {
  def unit[A](a: A): M[A]
  def mult(m: M[M[A]]): M[A]
}

This would allow you derive flatMap as you have written.

Alternatively, mult can be derived: m => m.flatMap(x => x). I have no particular preference for either representation, though I suspect there are ultimately practical implications. I’d be interested in knowing if this intuition is correct.

One thing I’m puzzled about

trait Monad[M[_]] {
def flatMap[A, B](a: M[A], f: A => M[B]): M[B]
def unital[A](a: A): M[A]
}

afaik a Monad is a tripple of (endo)functor and two natural transformations (unit and mult). These natural transformations are morphisms between functors (regardless if we represent them as in category theory or as Haskell does) but M[_] is not necessarily a functor. Therefore a call to Monad.flatMap or unital doesn’t really bring us back automatically into the functors space, unless we wrap them again by other monad.

Of course List, Option etc are monadic but for the purpose of generalization I’d appreciate if you could clarify this for me.

I wonder about this form:

trait M[A] {

def map[B](f: A => B) : M[B]
def flatMap[B]( f: A => M[B]): M[B] = mult ( map ( f ) )

def unit(a: A): M[A]
def mult(m: M[M[a]]); M[a]

protected def A get
}

Any thoughts?

Br’s,
Marius

http://paste.pocoo.org/show/198673/

12, however, has me in a bit of a quandry. Hopefully, the type signature should be:

lift2 :: Monad’ m -> (a -> b -> c) -> m a -> m b -> m c

Otherwise, any hints would be gratefully received.

Also watched the Nick Partridge video which you posted - very good. I’m not alone in failing to make the leap between some of the scalaz examples and what this looks like in real code. The best “a ha” moment so far was Nick’s explanation of using validation with the methods.

I also watched your “Monad” presentation and you urge people to play around as then they will discover the usages for themselves. I think a worked example of the introduction of some of these concepts to how a “standard Java guy” might write a small program would be really beneficial in this. But keep up the good work