Re: C'est bien la peine !

Je n'ai toujours pas saisi la finalité de la méthode décrite dans le journal, il va falloir que je médite la vidéo et le code donné en lien à la fin pour mieux saisir.

J'ai l'impression qu'il veut faire de la quantification universelle sur du constructeur (forall a.) ce qui s'appelle du higher-kinded polymorphism et en OCaml on a tendance à utiliser le système des modules pour cela.

D'un autre côte, il semblerait que l'objectif soit aussi d'éviter de construire explicitement l'AST du langage cible pour éviter de l'allocation. Si l'on met de côté cette contrainte, on peut obtenir le résultat qu'il souhaite ainsi sans même passer par les modules :

type expr = Val of int | Op of expr * expr
let rec fold f g e =
 match e with
 | Val i -> f i
 | Op (e1,e2) -> g (fold f g e1) (fold f g e2)
;;
type expr = Val of int | Op of expr * expr
(* oh le joli type de fold ;-) *)
val fold : (int -> 'a) -> ('a -> 'a -> 'a) -> expr -> 'a = <fun>
let e = Op(Val 1, Op(Val 1, Val 2));;
let eval1 = fold (fun i -> i) ( + );;
let eval2 = fold (fun i -> i) ( - );;
let eval3 = fold string_of_int (fun a b -> Printf.sprintf "(%s+%s)" a b);;
(* 1 + (1+2) *)
eval1 e;;
- : int = 4
(* 1 - (1-2) *)
eval2 e;;
- : int = 2
eval3 e;;
- : string = "(1+(1+2))"

Le terme technique pour la fonction fold est bien celui d'un catamorphisme sur la structure d'AST du langage d'experession, que l'on spécialise selon différentes interprétations pour donner eval1, eval2 et eval3.

Sapere aude ! Aie le courage de te servir de ton propre entendement. Voilà la devise des Lumières.