When are F# function calls evaluated; lazily or immediately?

Question

Curried functions in F#. I get the bit where passing in a subset of parameters yields a function with presets. I just wondered if passing all of the parameters is any different. For example:

let addTwo x y = x + y
let incr a = addTwo 1
let added = addTwo 2 2

incr is a function taking one argument. Is added an int or a function? I can imagine an implementation where "added" is evaluated lazily only on use (like Schroedinger's Cat on opening the box). Is there any guarantee of when the addition is performed?

Please consider editing your question title, see [ask]. – Paul Kertscher Dec 09 '16 at 11:59 — Paul Kertscher, Dec 09 '16 at 11:59
Thanks to all who clarified this for me. – Benboy Dec 12 '16 at 18:29 — Benboy, Dec 12 '16 at 18:29

score 19 · Answer 1 · answered Dec 08 '16 at 21:42

19

added is not a function; it is just a value that is calculated and bound to the name on the spot. A function always needs at least one parameter; if there is nothing useful to pass, that would be the unit value ():

let added () = addTwo 2 2

answered Dec 08 '16 at 21:42

TeaDrivenDev

6,591
33
50

Another option is to use the lazy keyword: ``let added = lazy (addTwo 2 2)``. This way the value will be lazy evaluated but only once. – Gus Dec 09 '16 at 08:47

score 12 · Answer 2 · edited May 23 '17 at 12:24

incr is a function taking one argument. Is added an int or a function?

added, in this case, is a named binding that evaluates to an int. It is not a function.

I can imagine an implementation where "added" is evaluated lazily only on use (like Schroedinger's Cat on opening the box). Is there any guarantee of when the addition is performed?

The addition will be performed immediately when the binding is generated. There is no laziness involved.

As explained by TeaDrivenDev, you can change added to be a bound function instead of a bound value by adding a parameter, which can be unit:

let added () = addTwo 2 2

In this case, it will be a function, so the addition wouldn't happen until you call it:

let result = added () // Call the function, bind output to result

score 12 · Accepted Answer · answered Dec 09 '16 at 06:42

F# is an eagerly evaluated language, so an expression like addTwo 2 2 will immediately be evaluated to a value of the int type.

Haskell, by contrast, is lazily evaluated. An expression like addTwo 2 2 will not be evaluated until the value is needed. The type of the expression would still be a single integer, though. Even so, such an expression is, despite its laziness, not regarded as a function; in Haskell, such an unevaluated expression is called a thunk. That basically just means 'an arbitrarily complex expression that's not yet evaluated'.

score 2 · Answer 4 · answered Dec 09 '16 at 10:09

No. But kind of yes. But really, no.

You can construct a pure functional language that only has functions and nothing else. Lambda calculus is a complete algebra, so the theory is there. In this model, added can be considered a parameter-less function (in contrast to e.g. random(), where there's one parameter of type unit).

But F# is different. Since it's a rather pragmatic mix of imperative and functional programming, the result is not a function[1]. Instead, it's a value, just like a local in C#. This is no implementation detail - it's actually part of the F# specification. This does have disadvantages - it means its possible to have an ambiguous definition, where a definition could be either a value or a function definition (14.6.1).

[1] - Though in a pure functional program, you can't tell the difference - it's the same as just doing a substitution of the function with a cached value, which is perfectly legal.

When are F# function calls evaluated; lazily or immediately?

4 Answers4

Linked