(*** Evaluation des expressions simples ***)

(* Module abstrayant les expressions simples *)
module type ExprSimple =
sig
  type t
  val const : int -> t
  val plus : t -> t -> t
  val mult : t -> t -> t
end

(* Module réalisant l'évaluation d'une expression *)
module EvalSimple : ExprSimple with type t = int =
struct
  type t = int
  let const c = c
  let plus e1 e2 = e1 + e2
  let mult e1 e2 = e1 * e2
end

(* Module réalisant l'affichage d'une expression *)
module PrintSimple : ExprSimple with type t = string =
struct
  type t = string
  let const c = (string_of_int c)
  let plus e1 e2 = "(" ^ e1 ^ "+" ^ e2 ^ ")"
  let mult e1 e2 = "(" ^ e1 ^ "*" ^ e2 ^ ")"
end

(* Module comptant le nombre d'opérations d'une expression *)
module CompteSimple : ExprSimple with type t = int =
struct
  type t = int
  let const c = 0
  let plus e1 e2 = e1 + e2 + 1
  let mult e1 e2 = e1 + e2 + 1
end

(* Solution 1 pour tester *)
(* A l'aide de foncteur *)

(* Définition des expressions *)
module ExemplesSimples (E:ExprSimple) =
struct
  (* 1+(2*3) *)
  let exemple1  = E.(plus (const 1) (mult (const 2) (const 3)) )
  (* (5+2)*(2*3) *)
  let exemple2 =  E.(mult (plus (const 5) (const 2)) (mult (const 2) (const 3)) )
end

(* Module d'évaluation des exemples *)
module EvalExemples = ExemplesSimples (EvalSimple)
let%test _ = (EvalExemples.exemple1 = 7)
let%test _ = (EvalExemples.exemple2 = 42)

(* Module d'affichage des exemples *)
module PrintExemples = ExemplesSimples (PrintSimple)
let%test _ = (PrintExemples.exemple1 = "(1+(2*3))")
let%test _ = (PrintExemples.exemple2 = "((5+2)*(2*3))")

(* Module de comptage des exemples *)
module CompteExemples = ExemplesSimples (CompteSimple)
let%test _ = (CompteExemples.exemple1 = 2)
let%test _ = (CompteExemples.exemple2 = 3)

(*** Evaluation des variables aux expressions ***)

(* Module abstrayant les expressions complété avec les variables *)
module type ExprVar =
sig
  type t
  type nom = string
  val def : nom -> t -> t -> t
  val var : nom -> t
end

(* Module abstrayant les expressions *)
module type Expr =
sig
  include ExprSimple
  include (ExprVar with type t:=t) 
end

(* Module réalisant l'affichage d'une expression complété de variables *)
module PrintVar : ExprVar with type t = string and type nom = string =
struct
  type t = string
  type nom = string
  let def s e1 e2 = "let " ^ s ^ " = " ^ e1 ^ " in " ^ e2
  let var e = e
end

(* Module réalisant l'affichage d'une expression complété de variables *)
(* module EvalVar : ExprVar with type t = int and type nom = string =
struct
  type t = int
  type nom = string
  let def s e1 e2 = e2 ((s e1 env)::env)
  let var e = List.assoc e env
end *)

(* Module réalisant le comptage des opérations d'une expression complété de variables *)
module CompteVar : ExprVar with type t = int and type nom = string =
struct
  type t = int
  type nom = string
  let def s e1 e2 = e1 + e2 + 3
  let var e = 0
end

(* Module réalisant le compte des opérations d'une expression *)
module Compte : Expr with type t = int and type nom = string =
struct
  include CompteVar
  include (CompteSimple:ExprSimple with type t:=t)
end

(* Module réalisant l'affichage d'une expression *)
module Print : Expr with type t = string and type nom = string =
struct
  include PrintVar
  include (PrintSimple:ExprSimple with type t:=t)
end

(* Module réalisant l'évaluation d'une expression *)
(* module Eval : Expr with type t = string and type nom = string =
struct
  include EvalVar
  include (EvalSimple:ExprSimple with type t:=t)
end *)

(* Définition des expressions avec variables *)
module Exemples (E:Expr) =
struct
  (* 1+(2*3) *)
  let exemple1  = E.(plus (const 1) (mult (const 2) (const 3)) )
  (* (5+2)*(2*3) *)
  let exemple2 =  E.(mult (plus (const 5) (const 2)) (mult (const 2) (const 3)) )
  (* let x = 1+2 in x*3 *)
  let exemple3 = E.(def "x" (plus (const 1) (const 2)) (mult (var "x") (const 3)) )
  (* let okay = (3+4)*5 in (x*7)+x *)
  let exemple4 = E.(def "x" (mult (plus (const 3) (const 4)) (const 5)) (plus (mult (var "x") (const 7)) (var "x")) )
end

(* Module d'affichage des exemples + test de non regression *)
module PrintExemples2 = Exemples (Print)
let%test _ = (PrintExemples2.exemple1 = "(1+(2*3))")
let%test _ = (PrintExemples2.exemple2 = "((5+2)*(2*3))")
let%test _ = (PrintExemples2.exemple3 = "let x = (1+2) in (x*3)")
let%test _ = (PrintExemples2.exemple4 = "let x = ((3+4)*5) in ((x*7)+x)")

(* Module de comptage des exemples + test de non regression*)
module CompteExemples2 = Exemples (Compte)
let%test _ = (CompteExemples2.exemple1 = 2)
let%test _ = (CompteExemples2.exemple2 = 3)
let%test _ = (CompteExemples2.exemple3 = 5)
let%test _ = (CompteExemples2.exemple4 = 7)

(* Module de d'evaluation des exemples + test de non regression*)
(* module EvalExemples2 = Exemples (Eval)
let%test _ = (EvalExemples2.exemple1 = 7)
let%test _ = (EvalExemples2.exemple2 = 42)
let%test _ = (EvalExemples2.exemple3 = 9)
let%test _ = (EvalExemples2.exemple4 = 280) *)