Ajout de l'underscore dans le let in, et du prInt dans les let.

Rendu0/expr.ml

@@ -103,7 +103,7 @@ and eval e env = match e with
         | VInt k -> VInt k
         | x -> raise (InvalidTypeException ("Int",x)))
     | Var(v) -> readVar env v (UnknownVariableException (v,env))
-    | LetIn(v,e0,e1) -> eval e1 ((v,eval e0 env)::env)
+    | LetIn(v,e0,e1) -> eval e1 (let x=(eval e0 env) in if v="_" then env else (v,x)::env) (* Le let est là pour forcer l'évaluation *)
     | App(e0,e1) -> (match (eval e0 env) with
         | VFunc(v,e) -> eval (LetIn(v,e1,e)) env (* On utilise l'équivalence (fun x->e) y <=> let x=y in e *)
         | x -> raise (InvalidTypeException ("Func",x)))

Rendu0/lexer.mll

@@ -33,5 +33,5 @@ rule token = parse    (* la "fonction" aussi s'appelle token .. *)
   | "in"            { IN }
   | "fun"           { FUN }
   | "->"            { MAPSTO }
-  | ['a'-'z']+ as v { VAR (v) }
+  | (['a'-'z' 'A'-'Z' '_'])(['a'-'z' 'A'-'Z' '0'-'9' '_'])* as v { VAR (v) }
   | eof             { raise Eof } (* fin du fichier *)

Rendu0/main.ml

@@ -37,14 +37,14 @@ let rec affiche_printexpr e env = begin
         | Band(e1,e2) -> affiche_printexpr e1 env;affiche_printexpr e2 env
         | Bor(e1,e2) -> affiche_printexpr e1 env;affiche_printexpr e2 env
         | ITE(ec,e1,e2) -> affiche_printexpr ec env;affiche_printexpr e1 env;affiche_printexpr e2 env
-        | _ -> ()
-    end;
-    begin
-    match e with
-    | PrInt e -> (match (eval e env) with
-        | VInt(k) -> print_int k;print_newline ()
-        | x -> raise (InvalidTypeException ("Int",x)))
-    | _ -> ()
+        | PrInt (e) -> (match (eval e env) with
+            | VInt(k) -> print_int k
+            | x -> raise (InvalidTypeException ("Int",x)));affiche_printexpr e env
+        | LetIn(v,e0,e) -> affiche_printexpr e0 env;affiche_printexpr e (let x=(eval e0 env) in if v="_" then env else (v,x)::env)
+        | App(e0,e1) -> affiche_printexpr e0 env;(match (eval e0 env) with
+            | VFunc(v,e) -> affiche_printexpr (LetIn(v,e1,e)) env (* On utilise l'équivalence (fun x->e) y <=> let x=y in e *)
+            | x -> raise (InvalidTypeException ("Func",x)))
+        | Const(_) | BConst(_) | Fun (_,_) | Var(_) -> ()
     end
 (* le traitement d'une expression en entrée *)   
 let execute e =

Rendu0/tests/func.ml

@@ -0,0 +1 @@
+(fun x -> fun y -> fun x -> x+y*2) 0 19 4