Difference between applicative and monadic computation in scala

Question

Given this simple computation i can not clearly see the difference between using applicative style over monadic style. Are there some better examples out there ( in scala ) when to use the one over the other.

    println( (3.some |@| none[Int] |@| 4.some )( (a:Int,b:Int,c:Int) => {  a + b + c } )  ) // prints None

    println( for( 
     a <- Some(3);
     b <- none[Int];
     c <- Some(4)
   ) yield( a + b + c ) ) // prints None

Both computations ending up in a None so the end result is the same. The only difference i can see ist that there is no temporaray access to those vars in the for comprehension when using the applicative syntax.

Furthermore having one None value stops the whole computation. I thought applicative means "not dependent on the result of the computation before"

Answer 1

The applicative builder syntax will evaluate each term and can not use the result of a prior computation. However, even if the first result is None, all the other expressions will still be evaluated.

Whereas, with the for comprehension, it will 'fail fast' (it will not evaluate any further expressions after a None, in your case), plus you can access the results of previous computations.

Don't think of these things as simply different styles, they are calling different functions with different behaviours: i.e. flatMap vs apply

Answer 2

Monads represent sequential computations where each next computation depends on previous ones (if previous computation is empty you can't proceed, so you "fail fast"), more generic example of monadic computation:

println( for( 
     a <- Some(1);
     b <- Some(a);
     c <- Some(a + b)
   ) yield( a + b + c ) ) //=> 4

Applicative is just fmap on steroids where not only an argument, but a mapping function itself can be empty. In your case it can be rewritten as:

4.some <*>
  { none[Int] <*>
    { 3.some <*> 
      { (_: Int) + (_: Int) + (_: Int) }.curried.some } }

On some step your function becomes Option[Int => Int] = None, but it doesn't stop from applying it to 4.some, only the result is None as expected. You still need to know the value of 4.some.