Question

I’m just beginning F# so please be kind if this is basic.

I’ve read that a function marked lazy is evaluated only once and then cached. For example:

let lazyFunc = lazy (1 + 1)
let theValue = Lazy.force lazyFunc

Compared to this version which would actually run each time it’s called:

let eagerFunc = (1 + 1)
let theValue = eagerFunc

Based on that, should all functions be made lazy? When would you not want to? This is coming from material in the book “Beginning F#”.

Answer 1

First of all, it may be helpful to note that none of the things you have defined is a function – eagerFunc and theValue are values of type int and lazyFunc is a value of type Lazy<int>. Given

let lazyTwo = lazy (1 + 1)

and

let eagerTwo = 1 + 1

the expression 1 + 1 will not be evaluated more than once no matter how many times you use eagerTwo. The difference is that 1 + 1 will be evaluated exactly once when defining eagerTwo, but will be evaluated at most once when lazyTwo is used (it will be evaluated the first time that the Value property is accessed, and then cached so that further uses of Value do not need to recalculated it). If lazyTwo‘s Value is never accessed, then its body 1 + 1 will never be evaluated.

Typically, you won’t see much benefit to using lazy values in a strict language like F#. They add a small amount of overhead since accessing the Value property requires checking whether the value has already been calculated. They might save you a bit of calculation if you have something like let lazyValue = lazy someVeryExpensiveCalculationThatMightNotBeNeeded(), since the expensive calculation will only take place if the value is actually used. They can also make some algorithms terminate which otherwise would not, but this is not a major issue in F#. For instance:

// throws an exception if x = 0.0
let eagerDivision x =
    let oneOverX = 1.0 / x
    if x = 0.0 then
        printfn "Tried to divide by zero" // too late, this line is never reached
    else
        printfn "One over x is: %f" oneOverX

// succeeds even if x = 0.0, since the quotient is lazily evaluated
let lazyDivision x =
    let oneOverX = lazy (1.0 / x)
    if x = 0.0 then
        printfn "Tried to divide by zero"
    else
        printfn "One over x is: %f" oneOverX.Value