Principe de l'évaluation partielle

Le texte décrit l'évaluation partielle comme l'exécution, à la compilation, de toutes les parties d'un programme dont les valeurs sont connues statiquement. L'exemple

function factorial(n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}
factorial(5);
montre que l’appel factorial(5) peut être entièrement résolu pendant la phase de construction, produisant la valeur 120 sans aucune instruction d’exécution au moment de l’exécution.

Lorsque seules certaines entrées sont dynamiques, l’évaluation partielle réduit le programme aux parties réellement dépendantes de ces entrées. L’exemple

function power(base, exponent) {
  if (exponent === 0) return 1;
  return base * power(base, exponent - 1);
}
power(process.argv[2], 5);
illustre la transformation en process.argv[2] * (process.argv[2] * … * 1), où le facteur process.argv[2] reste dynamique tandis que la structure de la multiplication est statiquement résolue.

Implémentation dans un interpréteur JavaScript

L’auteur mentionne le projet prepack, un évaluateur partiel revu pour JavaScript par Meta. Bien que le texte indique que prepack n’a pas atteint les attentes esthétiques, il sert de référence concrète à la capacité d’un compilateur JavaScript d’appliquer l’évaluation partielle.

Un second exemple propose un petit interpréteur arithmétique :

function calculate(expr) {
  if (typeof expr === "number") return expr;
  switch (expr[0]) {
    case "+": return calculate(expr[1]) + calculate(expr[2]);
    case "-": return calculate(expr[1]) - calculate(expr[2]);
    case "*": return calculate(expr[1]) * calculate(expr[2]);
    case "/": return calculate(expr[1]) / calculate(expr[2]);
    default: throw new Error("Unknown operator");
  }
}
calculate(["+", 1, ["*", 2, 3]]);
L’évaluation partielle parcourt l’arbre syntaxique, calcule les sous‑expressions entièrement connues et ne laisse que les nœuds dépendant d’une valeur d’entrée inconnue, comme Number(process.argv[2]). Cette approche montre comment un interpréteur peut être transformé en code plus linéaire avant l’exécution.

Cas d’étude : interpréteur Brainfuck

L’article présente un interpréteur Brainfuck complet en JavaScript :

function brainfuck(code, input = "") {
  const tape = new Uint8Array(30000);
  const jumps = {}, stack = [];
  let pointer = 0, inputPointer = 0, output = "";
  for (let i = 0; i < code.length; i++) {
    if (code[i] === "[") stack.push(i);
    if (code[i] === "]") {
      const start = stack.pop();
      jumps[start] = i;
      jumps[i] = start;
    }
  }
  for (let i = 0; i < code.length; i++) {
    switch (code[i]) {
      case ">": pointer++; break;
      case "<": pointer--; break;
      case "+": tape[pointer]++; break;
      case "-": tape[pointer]--; break;
      case ".": output += String.fromCharCode(tape[pointer]); break;
      case ",":
        tape[pointer] = inputPointer < input.length
          ? input.charCodeAt(inputPointer++)
          : 0;
        break;
      case "[": if (!tape[pointer]) i = jumps[i]; break;
      case "]": if (tape[pointer]) i = jumps[i]; break;
    }
  }
  return output;
}
brainfuck("++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.");
Le programme Brainfuck fourni ne requiert aucune entrée. Une évaluation partielle pourrait donc pré‑calculer les effets de chaque instruction, éliminant la boucle d’interprétation au moment de l’exécution et ne conservant que le flux de sortie final.

Limites et perspectives pratiques

Le texte souligne que l’évaluation partielle dépend fortement de la capacité du compilateur à identifier les valeurs statiques. Dans les cas où les entrées proviennent de l’environnement d’exécution (par exemple process.argv), le compilateur ne peut pas éliminer toutes les branches conditionnelles. De plus, la complexité de l’analyse augmente avec la taille du programme et la profondeur des structures de contrôle, ce qui peut rendre l’optimisation coûteuse en temps de compilation.

En pratique, les outils comme prepack démontrent que l’évaluation partielle peut réduire la taille du bundle JavaScript et accélérer le démarrage d’une application, mais ils restent limités aux patterns de code prévisibles. L’article invite donc les développeurs à expérimenter avec de petites fonctions ou des DSL internes afin de mesurer les gains réels avant d’envisager une intégration à grande échelle.