lci/test/testingTypeFun.ml

open MiniFun.TypeChecker
open MiniFun.Types

(* -------------------------------------------------------------------------- *)
(* Error absent assignment program *)

let program =
  Function
    ("a",
     FunctionType (IntegerType, IntegerType),
     Variable "x"
    )
;;

match typecheck program with
  Error (`AbsentAssignment _) -> Printf.printf "Error absent assignment program: error (success)\n"
| _ -> Printf.printf "Error absent assignment program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Error wrong return type program *)

let program =
  Function
    ("a",
     FunctionType (IntegerType, BooleanType),
     (Variable "a")
    )
;;

match typecheck program with
  Error (`WrongTypeSpecification _) -> Printf.printf "Error wrong return type program: error (success)\n"
| _ -> Printf.printf "Error wrong return type program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Error wrong specification program *)

let program =
  Function
    ("a",
     IntegerType,
     (Variable "a")
    )
;;

match typecheck program with
  Error (`WrongTypeSpecification _) -> Printf.printf "Error wrong specification program: error (success)\n"
| _ -> Printf.printf "Error wrong specification program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Error wrong input type program *)

let program =
  Application (
    Function
      ("a",
       FunctionType (IntegerType, FunctionType (IntegerType, IntegerType)),
       Function ("b", FunctionType (IntegerType, IntegerType), Variable "a")
      ),
    Boolean false
  )
;;

match typecheck program with
  Error (`WrongType _) -> Printf.printf "Error wrong input type program: error (success)\n"
| _ -> Printf.printf "Error wrong input type program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Error not a function program *)

let program =
  Application (
    Integer 0,
    Boolean false
  )
;;

match typecheck program with
  Error (`WrongType _) -> Printf.printf "Error not a function program: error (success)\n"
| _ -> Printf.printf "Error not a function program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Error if branches with different types program *)

let program =
  Function (
    "x",
    FunctionType (IntegerType, IntegerType),
    IfThenElse (Cmp (Integer 1, Integer 2), Boolean true, Integer 1)
  )
;;

match typecheck program with
  Error (`WrongType _) -> Printf.printf "Error if branches with different types program: error (success)\n"
| _ -> Printf.printf "Error if branches with different types program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Error if guard is not a boolean program *)

let program =
  Function (
    "x",
    FunctionType (IntegerType, IntegerType),
    IfThenElse (Integer 1, Integer 2, Integer 1)
  )
;;

match typecheck program with
  Error (`WrongType _) -> Printf.printf "Error if guard is not a boolean program: error (success)\n"
| _ -> Printf.printf "Error if guard is not a boolean program: failed\n"


(* -------------------------------------------------------------------------- *)
(* Identity program *)
let program =
  Function
    ("a",
     FunctionType (IntegerType, IntegerType),
     (Variable "a")
    )
;;

match typecheck program with
  Ok _ -> Printf.printf "Identity program: success\n"
| _ -> Printf.printf "Identity program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Constant program *)
let program =
  Function
    ("a",
     FunctionType (IntegerType, IntegerType),
     (Integer 1)
    )
;;

match typecheck program with
  Ok _ -> Printf.printf "Constant program: success\n"
| _ -> Printf.printf "Constant program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Partial application of function program *)
let program =
  LetIn
    ("f",
     (Function (
         "x",
         FunctionType (IntegerType, FunctionType (IntegerType, IntegerType)),
         Function ("y",
                   FunctionType (IntegerType, IntegerType),
                   Plus (Variable "x", Variable "y")
                  )
               )),
     (Application (Variable "f", Integer 3))
    )
;;

match typecheck program with
  Ok _ -> Printf.printf "Partial application of function program 1: success\n"
| _ -> Printf.printf "Partial application of function program 1: failed\n"

(* -------------------------------------------------------------------------- *)
(* Partial application of function program *)
let program =
  LetFun
    ("f",
     "x",
     FunctionType (IntegerType, FunctionType (IntegerType, IntegerType)),
     (Function ("y",
                FunctionType (IntegerType, IntegerType),
                Plus (Variable "x", Variable "y"))),
     (Application (Variable "f", Integer 3))
    )
;;

match typecheck program with
  Ok _ -> Printf.printf "Partial application of function program 2: success\n"
| _ -> Printf.printf "Partial application of function program 2: failed\n"

(* -------------------------------------------------------------------------- *)
(* Passing functions to functions program *)
let program =
  LetIn
    ("f",
     (Function (
         "z",
         FunctionType (FunctionType (IntegerType, IntegerType), FunctionType (FunctionType (IntegerType, IntegerType), FunctionType (IntegerType, IntegerType))),
         (Function (
             "y",
             FunctionType (FunctionType (IntegerType, IntegerType), FunctionType (IntegerType, IntegerType)),
             Function (
               "x",
               FunctionType (IntegerType, IntegerType),
               (IfThenElse (
                   CmpLess (Variable "x", Integer 0),
                   (Application (Variable "y", Variable "x")),
                   (Application (Variable "z", Variable "x"))
                 )))
           ))
       )),
     (Application
        (
          (Application
             (Variable "f",
              Function ("x", FunctionType (IntegerType, IntegerType), Plus (Variable "x", Integer 1))
             )
          ),
          Function ("x", FunctionType (IntegerType, IntegerType), Minus (Variable "x", Integer 1))
        )
     )
    )
;;

match typecheck program with
  Ok _ -> Printf.printf "Passing functions to functions program: success\n"
| _ -> Printf.printf "Passing functions to functions program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Recursive function program *)
let program =
  LetFun
    ("f",
     "x",
     FunctionType (IntegerType, IntegerType),
     (IfThenElse (CmpLess (Variable "x", Integer 2),Integer 1, Plus (Variable "x", Application (Variable "f", Minus (Variable "x", Integer 1))))),
     (Variable "f")
    )
;;

match typecheck program with
  Ok _ -> Printf.printf "Recursive function program: success\n"
| _ -> Printf.printf "Recursive function program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Scope program *)
let program =
  LetIn
    ("f",
     (LetIn ("a", Integer 1, (Function ("y", FunctionType (IntegerType, IntegerType), Plus (Variable "y", Variable "a"))))),
     (LetIn ("a", Integer 2, Variable "f"))
    )
;;

match typecheck program with
  Ok _ -> Printf.printf "Scope program: success\n"
| _ -> Printf.printf "Scope program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Factorial program *)
let program =
  LetFun (
    "f",
    "x",
    FunctionType (IntegerType, IntegerType),
    (IfThenElse (CmpLessEq (Variable "x", Integer 0), Integer 1, Times (Variable "x", Application (Variable "f", Minus (Variable "x", Integer 1))))),
    (Variable "f")
  )
;;

match typecheck program with
  Ok _ -> Printf.printf "Factorial program: success\n"
| _ -> Printf.printf "Factorial program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Hailstone sequence's lenght program *)

let program =
  LetFun (
    "collatz",
    "input",
    FunctionType (TupleType (IntegerType, IntegerType), IntegerType),
    (
      IfThenElse (BNot (Cmp (First (Variable "input"), Integer 1)),
                  (IfThenElse (Cmp (Modulo (First (Variable "input"), Integer 2), Integer 0),
                               Application (Variable "collatz",
                                            Tuple (
                                              Division (First (Variable "input"), Integer 2),
                                              Plus (Integer 1, Second (Variable "input")))),
                               Application (Variable "collatz",
                                            Tuple (
                                              Plus (Integer 1, Times (Integer 3, First (Variable "input"))),
                                              Plus (Integer 1, Second (Variable "input")))))),
                 (Second (Variable "input")))
    ),
    (Function ("x",
               FunctionType (IntegerType, IntegerType),
               Application (Variable "collatz", Tuple (Variable "x", Integer 1)))
    )
  )
;;

match typecheck program with
  Ok _ -> Printf.printf "Hailstone sequence's lenght program: success\n"
| _ -> Printf.printf "Hailstone sequence's lenght program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Sum multiples of 3 and 5 program *)

let program =
  LetFun (
    "sum",
    "n",
    FunctionType (IntegerType, IntegerType),
    (IfThenElse ((BOr (Cmp (Modulo (Variable "n", Integer 3), Integer 0), Cmp (Modulo (Variable "n", Integer 5), Integer 0))),
                 Plus (Variable "n", Application (Variable "sum", Minus (Variable "n", Integer 1))),
                 (IfThenElse ((CmpLessEq (Variable "n", Integer 1)),
                              (Integer 0),
                              (Application (Variable "sum", Minus (Variable "n", Integer 1))))
                 ))
    ),
    (Variable "sum")
  )
;;

match typecheck program with
  Ok _ -> Printf.printf "Sum multiples of 3 and 5 program: success\n"
| _ -> Printf.printf "Sum multiples of 3 and 5 program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Rand program *)
let program =
  Function (
    "x",
    FunctionType (IntegerType, IntegerType),
    Rand (Variable "x")
  )

;;

match typecheck program with
  Ok _ -> Printf.printf "Rand program: success\n"
| _ -> Printf.printf "Rand program: failed\n"

(* -------------------------------------------------------------------------- *)
(* Fibonacci program *)
let program =
  LetFun (
    "fib",
    "input",
    FunctionType (TupleType (TupleType (IntegerType, IntegerType), IntegerType), IntegerType),
    (IfThenElse (Cmp (First (First (Variable "input")), Integer 0),
                 Second (First (Variable "input")),
                 Application (Variable "fib",
                              Tuple ( Tuple (
                                  Minus (First (First (Variable "input")), Integer 1),
                                  Second (Variable "input")),
                                  Plus (Second (First (Variable "input")), Second (Variable "input"))))
                )),
    Function ("x",
              FunctionType (IntegerType, IntegerType),
              (Application (Variable "fib", Tuple (Tuple (Variable "x", Integer 0), Integer 1))))
  )
;;

match typecheck program with
  Ok _ -> Printf.printf "Fibonacci program: success\n"
| _ -> Printf.printf "Fibonacci program: failed\n"