Functional Programming style: How to write functions - explicit currying, implicit currying or lamdas?

Question

So I have been using F# for a while and studying a bit of Haskell on the side and I have realized I could rewrite the exact same function one of three different ways.

Either with implicit currying, explicit currying, or with lambda expressions.

//lambdas
let add'  =  fun x -> fun y -> x + y

//explicit currying
let add' x  =     
   let subFunction y = 
      x + y                    
   subFunction   

//implicit currying
let add' x y = x + y

All of these have the signature int -> int -> int. All of them do the same thing.

Which one should I use in which case?

Answer 1

In the situations similar to the one you've described you should always use the third option, or, better yet, just let add' = (+) (but beware of Monomorhism Restriction). I see no sense in the other two definitions you have provided.

However, it's common to use nested functions in a way similar to your second example if the nested function takes auxiliary arguments, such as an accumulator in tail-recursive functions.

Answer 2

The answer to your question is the "implicit currying" option. However, there are times where you would use the second option.

In Haskell, for performance, you may want to share some work in the partially applied result. (Note, nothing in the Report guarantees this sharing or precludes the compiler from lifting out the work itself. In practice, GHC doesn't do these sorts of transformations for good reasons.)

addC x = let c = large computation x in \y -> x + y + c

In Haskell this is semantically equivalent to the following though in practice will have different performance characteristics.

addC x y = let c = large computation x in x + y + c

In F# the difference can be semantically meaningful.

let foo x = let rx = ref x in fun y -> rx := !rx + 1; !rx + y;;

is very different from

let foo x y = let rx = ref x in rx := !rx + 1; !rx + y;;