Does using currying result in lower performance in F#?

  • A+

When writing a function that can accept currying, you can write it as a single-argument function that returns a function. For example,

let add x =     let inner y = x + y     inner 

So you can either do:

add 3 4 


let add3 = add 3 add3 4 

My question, is because you return a function, you are conceptually calling a function twice (the outer function and the inner function). Is this slower than:

let add x y = x + y 

or does the compiler optimise invocations of add 3 4 in the curried definition?


I tested this in LINQPad 5.

When compiler optimizations are turned off, the F# compiler will produce different IL for each snippet. In other words, if there are any optimizations going on, it's left up to the JITter, and it may very well be slower to call the first form.

However, when compiler optimizations are turned on, both forms produce identical IL outputs in every scenario I could think of to test it. In fact, with both forms, calling:

add 3 4 

yields the IL equivalent of a hard-coded 7, with the entire function call optimized away:


In other words, the F# compiler is pretty thorough when it comes to optimizing logically identical code blocks.

This is not an exhaustive answer, of course, and there could be some case where they are actually treated differently by the compiler.


:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: