Module Lib.Closed

Ce module définit la syntaxe abstraite du langage intermédiaire (type t) ainsi que divers types et fonctions auxiliaires.

La sémantique du langage est définie par le sous-module Eval.

À la différence du langage Skimmel, ce langage Closed ne dispose plus de fonctions anonymes : les fonctions doivent être définies à la surface (top-level) du programme, et ne peuvent être imbriquées. Le corps de ces fonctions ne peuvent donc faire référence qu'à d'autres fonctions définies précédemment.

Une autre différence est la présence de constructions permettant la manipulation de blocs. Un bloc est essentiellement une séquence contiguë de taille fixe découpée en cellules contenant des valeurs arbitraires. Vous pouvez y penser comme à des tableaux hétérogènes (au sens où les cellules peuvent stocker des valeurs de types distincts). Les blocs existent comme des objets modifiables en mémoire, voir le module Eval pour une sémantique de référence qui rend cette idée précise.

type exp =
  1. | Var of Id.t
    (*

    Une occurrence de variable.

    *)
  2. | Lit of int
    (*

    Une constante littérale.

    *)
  3. | Builtin of Builtin.t * exp list
    (*

    Une application d'opérateur prédéfini avec ses arguments.

    *)
  4. | App of exp * exp
    (*

    Une application avec ses arguments.

    *)
  5. | Let of exp * exp Id.Scoped.t
    (*

    Une définition de variable locale.

    *)
  6. | Seq of exp * exp
    (*

    Une séquence.

    *)
  7. | If of exp * exp * exp
    (*

    Une expression conditionnelle.

    *)
  8. | Pair of exp * exp
    (*

    Une paire.

    *)
  9. | Proj of bool * exp
    (*

    Une projection.

    *)
  10. | Allocate of exp
    (*

    Une allocation de bloc. La taille du bloc est donnée par la valeur de la sous-expression. Les valeurs initiales des cellules sont indéfinies.

    *)
  11. | Read of exp * exp
    (*

    Une lecture d'un bloc donné par la première sous-expression à un indice donné par la seconde sous-expression.

    Lire une cellule dans laquelle on n'a jamais écrite fournit un résultat non spécifié.

    *)
  12. | Write of exp * exp * exp
    (*

    Une écriture de bloc à un indice fixé, la troisième sous-expression fournissant la valeur à écrire. Cette expression s'évalue vers un entier non spécifié (en plus de modifier le bloc en mémoire).

    *)

Le type des expressions, quasiment identique au type Skimmel.t à l'exception de l'absence de fonctions anonymes.

val pp_exp : Format.formatter -> exp -> unit

Les expressions sont affichables.

type fundef = {
  1. name : Id.t;
    (*

    Le nom de la fonction.

    *)
  2. is_rec : bool;
    (*

    La fonction est-elle récursive ?

    *)
  3. params : Id.t list;
    (*

    La liste des paramètres de la fonction.

    *)
  4. body : exp;
    (*

    Le corps de la fonction.

    *)
}

Le type des définitions de fonctions.

val pp_fundef : Format.formatter -> fundef -> unit

Les définitions de fonction sont affichables.

type t = {
  1. defs : fundef list;
    (*

    Les fonctions définies à top-level.

    *)
  2. body : exp;
    (*

    L'expression principale qui détermine le résultat du programme.

    *)
}

Un programme du langage implémenté par le présent module comprend une liste de définitions de fonctions données à top-level ainsi qu'une expression principale.

val pp : Format.formatter -> t -> unit

Les programmes sont affichables.

module Eval : sig ... end

Le module Eval fournit un interprète pour Closed.

module Build : sig ... end

Le module qui suit offre des fonctions utilitaires qui facilitent la construction d'expressions Closed par rapport à l'usage direct des constructeurs du type exp.