F#
Évaluation paresseuse

Évaluation paresseuse Introduction

La plupart des langages de programmation, y compris F #, évaluent les calculs immédiatement en accord avec un modèle appelé Strict Evaluation. Cependant, dans l'évaluation différée, les calculs ne sont pas évalués tant qu'ils ne sont pas nécessaires. F # nous permet d'utiliser l'évaluation paresseuse à la fois par le mot clé et les sequences lazy .

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

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

De plus, lors de l'utilisation de l'évaluation différée, les résultats du calcul sont mis en cache, donc si nous forçons le résultat après notre première instance de forçage, l'expression elle-même ne sera plus évaluée.

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

Introduction à l'évaluation paresseuse en F #

F #, comme la plupart des langages de programmation, utilise Strict Evaluation par défaut. En évaluation stricte, les calculs sont exécutés immédiatement. En revanche, l'évaluation différée diffère l'exécution des calculs jusqu'à ce que leurs résultats soient nécessaires. De plus, les résultats d'un calcul sous évaluation différée sont mis en cache, évitant ainsi la nécessité de réévaluer une expression.

Nous pouvons utiliser l'évaluation paresseuse dans F # à la fois par le mot-clé lazy et les 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()