module Utility = Utility
open Types;;

Random.self_init ()

let (let*) = Result.bind


let rec principalTypings (D: ) (e: t_exp) : () result

let evaluate_type (_program: t_exp) (_context: typingshape) : (typingshape, error) result =
  failwith "asd"
  (* match program with *)
  (*   Integer _ -> Ok (VariableMap.empty, IntegerType) *)
  (* | Boolean _ -> Ok (VariableMap.empty, BooleanType) *)
  (* | Variable x -> ( *)
  (*     match (VariableMap.find_opt x (fst context)) with *)
  (*       (None) -> ( *)
  (*         let u = PolimorphicType (Utility.fromIntToString !globalIdentifier) in *)
  (*         globalIdentifier := !globalIdentifier + 1; *)
  (*         Ok (VariableMap.singleton x u, u) *)
  (*       ) *)
  (*     | (Some u) -> Ok (VariableMap.singleton x u, u) *)
  (*   ) *)
  (* | Function (xs, typef, fbody) -> failwith "Not Implemented" *)
  (* | Application (f, xs) -> failwith "Not Implemented" *)
  (* | Plus (x, y) *)
  (* | Minus (x, y) *)
  (* | Times (x, y) *)
  (* | Division (x, y) *)
  (* | Modulo (x, y) *)
  (* | Power (x, y) -> ( *)
  (*     let* partialResx = evaluate_type x context in *)
  (*     let* partialResy = evaluate_type y context in *)
  (*     match (partialResx, partialResy) with *)
  (*       ((conx, IntegerType), (cony, IntegerType)) -> *)
  (*       Ok (VariableMap.union (fun _ x _ -> Some x) conx cony, *)
  (*           FunctionType ([IntegerType; IntegerType], IntegerType)) *)
  (*     | ((conx, PolimorphicType xv), (cony, IntegerType)) -> *)
  (*       Ok (unify ) *)
  (*     | ((_conx, IntegerType), (_cony, PolimorphicType _yv)) *)
  (*     | ((_conx, PolimorphicType _xv), (_cony, PolimorphicType _yv)) -> failwith "ads" *)
  (*     | (_, _) -> Error (`WrongType "The arguments are of the wrong type") *)
  (*   ) *)
  (* | PowerMod (x, y, z) -> failwith "Not Implemented" *)
  (* | Rand (x) -> failwith "Not Implemented" *)
  (* | BAnd (x, y) *)
  (* | BOr (x, y) -> failwith "Not Implemented" *)
  (* | BNot (x) -> failwith "Not Implemented" *)
  (* | Cmp (x, y) *)
  (* | CmpLess (x, y) *)
  (* | CmpLessEq (x, y) *)
  (* | CmpGreater (x, y) *)
  (* | CmpGreaterEq (x, y) -> failwith "Not Implemented" *)
  (* | IfThenElse (guard, if_exp, else_exp) -> failwith "Not Implemented" *)
  (* | LetIn (x, xval, rest) -> failwith "Not Implemented" *)
  (* | LetFun (f, xs, typef, fbody, rest) -> failwith "Not Implemented" *)

let typecheck (_program: t_exp) : (ftype, error) result =
  failwith "Not Implemented"