diff --git a/flap/src/hopix/hopixLexer.mll b/flap/src/hopix/hopixLexer.mll
index f8a4112..59d6481 100644
--- a/flap/src/hopix/hopixLexer.mll
+++ b/flap/src/hopix/hopixLexer.mll
@@ -20,82 +20,88 @@ let hexa = "0x" ['0'-'9' 'a'-'f' 'A'-'F']
 let bina = "0b" ['0'-'1']
 let octa = "0o" ['0'-'7']
 
-let integers = '-'? (digit+
-             | hexa+
-             | bina+
-             | octa+)
+let printable = [' ' '\t' '\n' '\r' (* 33-126 *)] (* pas sûr *)
 
-let printable = [' ' '\t' '\n' '\r' (*33-126*)] (*pas sûr*)
-let ident = ['a'-'z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
-let constr_id = ['A'-'Z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
-let type_variable = ['\'']['a'-'z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
 (* On ne peut pas différencier au niveau du lexer var_id label_id et type_con,
- * il faudra le faire à l'analyseur syntaxique *)
+ * il faudra le faire à l'analyseur syntaxique. On fait donc un "ident" pour
+ * identificateur *)
+let ident = ['a'-'z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
 
 let atom = '"'
-let char = ['\'']atom['\'']
-let string = ['\"']((atom | '\'' | "\\\""))['\"']
+
+let constr_id = ['A'-'Z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
+let type_variable = '`' ['a'-'z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
+let int = '-'? (digit+ | hexa+ | bina+ | octa+)
+let char = '\'' atom '\''
+let string = '\"' ((atom | '\'' | "\\\"")) '\"'
 
 (* let binop = '+' | '-' | '*' | '/' | "&&" | "||"| "=?"| "<=?" |">=?" |"<?" |">?" *)
 
 
 rule token = parse
   (** Layout *)
-  | newline         { next_line_and token lexbuf      }
-  | blank+          { token lexbuf                    }
-  | eof             { EOF                             }
-  | "{*"            { commentary lexbuf; token lexbuf }
-  | "##"            { commentary_line lexbuf          }
+  | newline            { next_line_and token lexbuf      }
+  | blank+             { token lexbuf                    }
+  | eof                { EOF                             }
+  | "{*"               { commentary lexbuf               }
+  | "##"               { commentary_line lexbuf          }
 
   (** Keywords *)
-  | "let"           { LET    }
-  | "type"          { TYPE   }
-  | "extern"        { EXTERN }
-  | "fun"           { FUN    }
-  | "match"         { MATCH  }
-  | "if"            { IF     }
-  | "then"          { THEN   }
-  | "else"          { ELSE   }
-  | "ref"           { REF    }
-  | "while"         { WHILE  }
-  | "do"            { DO     }
-  | "until"         { UNTIL  }
-  | "for"           { FOR    }
-  | "from"          { FROM   }
-  | "to"            { TO     }
-  | "and"           { AND    }
-  | "for"           { FOR    }
+  | "let"              { LET    }
+  | "type"             { TYPE   }
+  | "extern"           { EXTERN }
+  | "fun"              { FUN    }
+  | "match"            { MATCH  }
+  | "if"               { IF     }
+  | "then"             { THEN   }
+  | "else"             { ELSE   }
+  | "ref"              { REF    }
+  | "while"            { WHILE  }
+  | "do"               { DO     }
+  | "until"            { UNTIL  }
+  | "from"             { FROM   }
+  | "to"               { TO     }
+  | "and"              { AND    }
+  | "for"              { FOR    }
   (* Fini ? *)
 
-  (** Binar operation : pas sûr pour celui là*)
-  (* | binop as b      { BINOP (* TODO *) } *)
+  (** Binar operation : pas sûr pour celui là *)
+  (* | binop as b         { BINOP b } *)
 
   (** Operators *)
-  (* | '='             { EQUAL } *)
+  (* | '='                { EQUAL } *)
 
-  (* ponctuation *)
-  | '('             { LPAREN   }
-  | ')'             { RPAREN   }
-  | '['             { LBRACK   }
-  | ']'             { RBRACK   }
-  | '_'             { WILDCARD }
-  | ':'             { DPOINT   }
-  |  "->"           { ARROW    }
-  | "<"             { INFERIOR }
-  | ">"             { SUPERIOR }
+  (** Ponctuation *)
+  | '('                { LPAREN   }
+  | ')'                { RPAREN   }
+  | '['                { LBRACK   }
+  | ']'                { RBRACK   }
+  | '_'                { WILDCARD }
+  | ':'                { DPOINT   }
+  | "->"               { ARROW    }
+  | "<"                { INFERIOR }
+  | ">"                { SUPERIOR }
 
   (** Values *)
-  | integers as i   { INT (Mint.of_string i) }
-  | ident as s      { ID s                   }
+  | int as i           { INT (Mint.of_string i) }
+  | ident as s         { ID s                   }
+  | type_variable as s { TID s                  }
 
   (** Lexing error *)
-  | _               { error lexbuf "unexpected character." }
+  | _                  { error lexbuf "unexpected character." }
 
-  and commentary = parse
-  | "*}"            { ()                                   }
-  | "{*"            { commentary lexbuf; commentary lexbuf }
-  | _               { commentary lexbuf                    }
+(* TODO: Gérer les imbrications de commentaires *)
+and commentary = parse
+  | "*}"               { token lexbuf                         }
+  | newline            { next_line_and commentary lexbuf      }
 
-  and commentary_line = parse
-  | '\n'            { next_line_and token lexbuf }
-  | _               { commentary_line lexbuf     }
+  (** Error  *)
+  | eof                { error lexbuf "unclosed commentary."  }
+
+  (** Commentary content *)
+  | _                  { commentary lexbuf                    }
+
+and commentary_line = parse
+  | newline            { next_line_and token lexbuf }
+  | eof                { EOF                        }
+  | _                  { commentary_line lexbuf     }
diff --git a/flap/src/hopix/hopixParser.mly b/flap/src/hopix/hopixParser.mly
index 666b13e..7f762be 100644
--- a/flap/src/hopix/hopixParser.mly
+++ b/flap/src/hopix/hopixParser.mly
@@ -48,7 +48,7 @@ fundef:
     FunctionDefinition(p, e)
   }
 /* ts est temp */
-| DPOINT ts=located(type_scheme) i=located(identifier) p=pattern EQUAL e=located(expression) {
+| DPOINT ts=located(type_scheme) i=located(identifier) p=located(pattern) EQUAL e=located(expression) {
     FunctionDefinition(p, e)
   }
 
@@ -63,18 +63,19 @@ pattern:
 
 
 ty:
-| tc = type_constructor {
+/* Temporaire None - compile pas */
+/* | tc=type_constructor {
     TyCon(tc, None)
-  }
+  } */
 
-(* Todo version avec l'optionnel*)
+/* Todo version avec l'optionnel */
 | ty1=located(ty) ARROW ty2=located(ty) {
     TyArrow(ty1, ty2)
   }
 | ty1=located(ty) STAR ty2=located(ty) {
     TyTuple([ty1; ty2])
   }
-| ty1=located(ty) STAR ty2=located(ty) STAR liste_ty = separated_list(STAR,located(ty)) {
+| ty1=located(ty) STAR ty2=located(ty) STAR liste_ty=separated_list(STAR, located(ty)) {
     TyTuple(ty1::ty2::liste_ty)
   }
 | LPAREN type_var=type_variable RPAREN {
@@ -83,8 +84,8 @@ ty:
 
 
 type_scheme:
-(* il faut peut être modifié le séparateur*)
-| LBRACK liste_typevar=separated_list(COMMA,located(type_variable)) RBRACK ty=located(ty) {
+/* il faut peut être modifié le séparateur */
+| LBRACK liste_typevar=separated_list(COMMA, located(type_variable)) RBRACK ty=located(ty) {
     ForallTy(liste_typevar, ty)
   }
 | ty=located(ty) {
@@ -99,7 +100,7 @@ type_variable:
 
 
 type_constructor:
-| tcon = TID {
+| tcon=TID {
     TCon tcon
   }