F#
Valutazione pigra

Introduzione alla valutazione pigra

La maggior parte dei linguaggi di programmazione, incluso F #, valuta immediatamente i calcoli in base a un modello chiamato Strict Evaluation. Tuttavia, in Lazy Evaluation, i calcoli non vengono valutati fino a quando non sono necessari. F # ci consente di utilizzare la valutazione lazy attraverso sia la parola chiave lazy che le sequences .

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

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

Inoltre, quando si utilizza Lazy Evaluation, i risultati del calcolo vengono memorizzati nella cache, quindi se si forza il risultato dopo la prima istanza di forzatura, l'espressione stessa non verrà valutata di nuovo

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()

Introduzione alla valutazione pigra in F #

F #, come la maggior parte dei linguaggi di programmazione, utilizza la valutazione rigorosa per impostazione predefinita. In Strict Evaluation, i calcoli vengono eseguiti immediatamente. Al contrario, Lazy Evaluation, rimuove l'esecuzione dei calcoli fino a quando i loro risultati sono necessari. Inoltre, i risultati di un calcolo in Lazy Evaluation vengono memorizzati nella cache, ovviando così alla necessità di rivalutare un'espressione.

Possiamo utilizzare la valutazione Lazy in F # tramite la parola chiave lazy e 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()