applicative

Yes, applicative code is a relatively new development in Haskell: applicative functors were discovered only in 2008.

For OCaml: - row polymorphism (in particular polymorphic variants) - higher-order and applicative functors (not the Haskell thing).

Or the whole thing is an applicative if you take at face value his claim that add is pure.

Sure, being able to use Applicative reduces lots of code duplication, brings in better clarity and all..

I think the issue is whether the usage of applicative functors was necessary or just for the sake of being clever for no added benefit.

Without that context, all that can be done are superficial changes like monad/applicative; which in this case are very minor.

Habitually rewriting things in applicative and/or pointfree is a sure sign of a junior Haskell dev.

I don't know Alice ML but one advantage of using abstractions like Applicative is that you can write code which is polymorphic in the particular applicative you choose.

The use of Applicative is actually an attempt at clarity, by restricting the kinds of things that the code can actually do.

The author appears to be an experienced Haskeller, so I'm sure they're aware of applicative functors.

If you want to program in Haskell, you need to understand the languange's core abstractions—and, yes, applicative style is one of them at this point.

Now, if you're a beginner and you understand monads but not applicatives, you have an argument—the monadic code is familiar, and the applicative code isn't—but that just means you have more to learn.

The change they made was from a monad to an applicative, which is less "hands on", thus preferred.

As it name implies, Applicative is a kind of "effectful application".

Applicative> (fmap head (fmap lines (readFile "/etc/issue"))) "Ubuntu 15.04 \ \\l" The duplication of fmap is getting kind of tedious to me.

Applicative is basically a "static" data-flow graph; ie.

Applicative> addFiveSubtract3 0 Now you know (hopefully) how function composition works, how can you use it for real stuff?

If you can do that sensibly for any number of function arguments, you have an Applicative.

This would be a great pain if there weren't helpful ways (see Monad, Functor, and Applicative) to apply pure functions to them.