Re: Dans l'art voluptueuse de ne rien comprendre

Je connais pas ton code, mais (il me semble que) la transformation revient à transformer tous les constructeurs des nodes de ton arbre en un fonctions sur un évaluateur. Par exemple si tu avais:

type arbre = NodeTerm | ...
let node (e1,e2,e3) = NodeTerm(e1,e2,e3)
...

Tu le changes en

type 'a evaluator = { node : ('a,'a,'a) -> 'a; ...}
let node (e1,e2,e3) evaluator = evaluator.node (e1 evaluator, e2 evaluator, e3 evaluator)

Et tu changes tes evals

let eval_string = function
| NoteTerm(e1,e2,e3) -> "NodeTerm("^(eval_string e1)^...")"
let eval_bool = function
| NodeTerm(_) -> true/false

comme ceci

let eval_string = {node = function (v1,v2,v3) -> "NodeTerm("^v1^","^v2^","^v3^")" (*pas de récursion, v1-v3 déja évalués! *)
let eval_bool = {node = function _ -> true/false}

Chaque match de ton eval devient une fonction différente dans ton évaluateur (ça n'est pas pour rien qu'Oleg l'appelle expr_dict dans son exemple...) Par contre ce journal a utilisé un tuple, mais bon ça n'est pas très pratique à utiliser amha.

Donc en gros tu changes tes constructeurs en closures sur l'évaluateur. Tu construits ton abre en faisant une application partielle des tes fonctions de construction. Donc toutes tes expressions deviennent des fonctions d'un évaluateur vers un résultat, soit le fameux type de ce journal type expr = forall 'a . 'a algebre -> 'a. C'est plus clair ? À toi de nous dire si cette réécriture t'apporte quelque chose de mieux ?