F#
Luie evaluatie

Lazy Evaluatie Inleiding

De meeste programmeertalen, waaronder F #, evalueren berekeningen onmiddellijk volgens een model met de naam Strikte Evaluatie. In Lazy Evaluation worden berekeningen echter pas geëvalueerd als ze nodig zijn. Met F # kunnen we luie evaluatie gebruiken via zowel het lazy trefwoord als de sequences .

// define a lazy computation
let comp = lazy(10 + 20)

// we need to force the result
let ans = comp.Force()

Bovendien worden bij het gebruik van Lazy Evaluation de resultaten van de berekening in de cache opgeslagen, dus als we het resultaat afdwingen na onze eerste keer forceren, wordt de uitdrukking zelf niet opnieuw geëvalueerd

let rec factorial n = 
  if n = 0 then 
    1
  else 
    (factorial (n - 1)) * n


let computation = lazy(printfn "Hello World\n"; factorial 10)

// Hello World will be printed
let ans = computation.Force()

// Hello World will not be printed here
let ansAgain = computation.Force()

Inleiding tot Lazy Evaluation in F #

F # maakt, net als de meeste programmeertalen, standaard gebruik van strikte evaluatie. In Strict Evaluation worden berekeningen onmiddellijk uitgevoerd. Lazy Evaluation daarentegen stelt de uitvoering van berekeningen uit totdat hun resultaten nodig zijn. Bovendien worden de resultaten van een berekening onder Lazy Evaluation in de cache opgeslagen, waardoor de noodzaak voor een herevaluatie van een uitdrukking overbodig wordt.

We kunnen Lazy-evaluatie in F # gebruiken via zowel het lazy trefwoord als Sequences

// 23 * 23 is not evaluated here
// lazy keyword creates lazy computation whose evaluation is deferred 
let x = lazy(23 * 23)

// we need to force the result
let y = x.Force()

// Hello World not printed here
let z = lazy(printfn "Hello World\n"; 23424)

// Hello World printed and 23424 returned
let ans1 = z.Force()

// Hello World not printed here as z as already been evaluated, but 23424 is
// returned
let ans2 = z.Force()