fun cadd (CI(x1,y1),CI(x2,y2)) = CI((x1+x2),(y1+y2));
fun cmult (CI(x1,y1),CI(x2,y2)) = CI((x1*x2),(y1*y2));
fun seqadd ([],[]) = [] | seqadd (lst1,lst2) = (hd lst1 + hd lst2)::(seqadd((tl lst1):intseq, (tl lst2):intseq):intseq);
fun seqmult ([],[]) = [] | seqmult (lst1,lst2) = (hd lst1 * hd lst2)::(seqmult((tl lst1):intseq, (tl lst2):intseq):intseq);

(*********************************)
(* Start of answer to Question 1
Represent a complex integer as an element of the datatype
  datatype cint = CI of int * int.
(So CI(4,5) represents 4+5i.)

Implement functions cadd and cmult of type cint * cint -> representing complex integer addition and
multiplication.
(So cadd(CI(1,0),CI(0,1)) should compute CI(1,1).)
*)

(* before *)
datatype cint = CI of int * int;

(* cadd *)
fun cadd (CI(x1,y1),CI(x2,y2)) = CI((x1+x2),(y1+y2));

(* Test 1 (should return CI(1,1)) *)
cadd(CI(3,2),CI(4,7));

(* Test 2 (should return CI(7,9)) *)
cadd(CI(3,2),CI(4,7));

(* Test 3 (should return CI(6,~5)) *)
cadd(CI(5,~6),CI(1,1));

(* Test 4 (should return an error as it is using reals) *)
cadd(CI(0.3,0.2),CI(0.1,0.0));


(* cmult *)
fun cmult (CI(x1,y1),CI(x2,y2)) = CI((x1*x2),(y1*y2));

(* Test 1 (should return CI(0,0)) *)
cmult(CI(1,0),CI(0,1));

(* Test 2 (should return CI(12,14)) *)
cmult(CI(3,2),CI(4,7));

(* Test 3 (should return CI(5,~12)) *)
cmult(CI(5,~6),CI(1,2));

(* Test 4 (should return an error as it is using reals) *)
cmult(CI(0.3,0.2),CI(0.1,0.0));


( * End of answer to Question 1 * )
(*********************************)


(*********************************)
(* Start of answer to Question 2
Implement recursive functions seqadd and seqmult of type intseq * intseq -> intseq that implement
pointwise addition and multiplication of integer sequences.
(So seqadd([1,2,3],[~1,2,2]) should compute [0,4,5])
*)

(* before *)
type intseq = int list;

(* seqadd *)
fun seqadd ([],[]) = []
(* If the list is empty return an empty list *)
| seqadd (lst1,lst2) = (hd lst1 + hd lst2)::(seqadd((tl lst1):intseq, (tl lst2):intseq):intseq);

(* Test 1 (should return [10, 36, 4]: intseq) *)
seqadd([5,4,3],[5,32,1]);

(* Test 2 (should return [3, 5, ~5]: intseq) *)
seqadd([1,7,~4],[2,~2,~1]);

(* Test 3 (should return [3]: intseq) *)
seqadd([1],[2]);

(* Test 4 (should return an error as it is using a triad tuple) *)
seqadd([1,4,5],[1,7,8],[3,6,5]);


(* seqmult *)
fun seqmult ([],[]) = []
(* If the list is empty return an empty list *)
| seqmult (lst1,lst2) = (hd lst1 * hd lst2)::(seqmult((tl lst1):intseq, (tl lst2):intseq):intseq);;

(* Test 1 (should return CI(0,0)) *)
seqmult(CI(1,0),CI(0,1));

(* Test 2 (should return CI(12,14)) *)
seqmult(CI(3,2),CI(4,7));

(* Test 3 (should return CI(5,~12)) *)
seqmult(CI(5,~6),CI(1,2));

(* Test 4 (should return an error as it is using a triad tuple) *)
seqmult([1,4,5],[1,7,8],[3,6,5]);


( * End of answer to Question 2 * )
(*********************************)

(*********************************)
(* Start of answer to Question 3
Represent integer matrices as the datatype intmatrix = IM of intseq list.
Write functions
- ismatrix : intmatrix -> bool
- matrixshape : intmatrix -> (int * int)
- matrixadd : intmatrix * intmatrix -> intmatrix
- matrixmult : intmatrix * intmatrix -> intmatrix

(* before *)
type intseq = int list;
datatype intmatrix = IM of intseq list;
fun seqadd ([],[]) = []
| seqadd (lst1,lst2) = (hd lst1 + hd lst2)::(seqadd((tl lst1):intseq, (tl lst2):intseq):intseq);
(* Need to define seqadd as it is used in my implementation of matrixadd*)

(* ismatrix *)
fun ismatrix (IM([x])) = true |
(* if the list contains only one element return true *)
ismatrix (IM(m)) = (length(hd m) = length(hd(tl m)) andalso ismatrix(IM(tl m)));
(* recursivley compares the of a row with the row below it and then performs a boolean operation to check that all previous comparisons have come back true *)

(* Test 1 (should return true) *)
ismatrix(IM([[3,4,5],[1,2,6],[3,4,5]]));

(* Test 2 (should return false) *)
ismatrix(IM([[3,4,5],[1,6],[3]]));

(* Test 3 (should return true) *)
ismatrix(IM([[3,4,5]]));

(* Test 4 (should return false as it is of the type int list list not intmatrix) *)
ismatrix([[3,4,5],[1,2,6],[3,4,5]]);

(* matrixshape *)
fun matrixshape (IM(m)) = ((length (hd m)),(length (m)));
(* returns the length of the first row and therefore the overall width of the matrix along with
the depth of the matrix *)

(* Test 1 (should return 3,3) *)
matrixshape(IM([[3,4,5],[1,2,6],[3,4,5]]));

(* Test 2 (should return an exception as there is no matrix) *)
matrixshape(IM([]));

(* Test 3 (should return 3,1) *)
matrixshape(IM([[3,4,5]]));

(* matrixadd *)
fun matrixadd ([],[]) = []
(* returns an empty list if either list is empty *)
| matrixadd (m1,m2) = seqadd((hd m1), (hd m2))::(matrixadd((tl m1), (tl m2)));
(* recursively adds each row by using the seqadd function from the previous question and then appends the result to the new list *)

(* Test 1 (should return [[4, 7, 10], [3, 4, 7], [7, 6, 6]]) *)
matrixadd(([[3,4,5],[1,2,6],[3,4,5]]),([[1,3,5],[2,2,1],[4,2,1]]));

(* Test 2 (should return [[4, 7, 10]]) *)
matrixadd(([[3,4,5]]),([[1,3,5]]));

(* Test 3 (should return 3,1) *)
matrixshape(IM([[3,4,5]]))

( * End of answer to Question 3 * )
(*********************************)

(*********************************)
(* Start of answer to Question 4
ML Type System Essay
Convince the marker you understand:
- Ad-hoc and parametric polymorphism.
- Function types.
- Pair types.
- Equality types.
- Type aliases and datatype declarations (and their differences)
*)


The ML Type system is a particularly strong static type system. Where it differs from many languages is the lack of subtypes. This essay aims to explain certain features of this rather unique type system. The first of which being Ad-hoc and parametric polymorphism. This feature allows the writing of more generic functions in that the functions can be applied to arguments of a different type. Ad hoc polymorphism is also known as overloading and allows for the use of the same operators on different types by using different implementations of the functions. Parametric Polymorphism in ML is achieved through the use of type variables to express unknown types which are represented using the Greek alphabet. Another interesting feature is the function types. Functions in ML map from what is known as the domain type to the range type in the following format, fn : domain type -> range type. The domain type being the parameters of the function and the range type being the result. Pairs in ML can come in variety of forms. Pairs allow you to combine types for instance the tuple (3, 7) would be of type (int * int). However they are not limited only to two expressions you could also have (3, 7, 5) which is known as a triple. It is also possible to mix types with (27, true, “spaghetti”) being of type (int * bool * string). The last thing that should be noted about pairs is the possibility of a zero tuple, () which is of type unit. Equality types using the ML system is defined as any type which allows equality testing. Real, streams and functions are the only types that are not Equality types. When comparing Equality types in ML we use = to check if the values either side are equal and use <> to check if the values are not equal. ‘’a is used to range over all equality types. Type aliases allow you to assign a type a synonym which can make types more meaningful. For example if you were writing a program to be used by a library in which each book had an id, you could use type book_id = int; this would allow you to set book_id as the explicit type in the program. The keyword datatype can be used to declare new data types, this differs from type in that it will create an entirely new data type rather than just providing a synonym for a pre-existing one. An example of a datatype declaration could be datatype flower = healthy | dead | wilting. A datatype declaration will introduce both new type constructors and also new value constructors for each of the type constructors. Perhaps the most interesting feature of defining datatypes is that they can be recursive. In conclusion the ML type system is a diverse and unique system that gives you a great deal of control over the types you are using while still remaining strong and statically typed.

( * End of answer to Question 4 * )
(*********************************)

(*********************************)
(* Start of answer to Question 5
Write a pair of function types
(('a * 'b) -> 'c) -> ('a -> ('b -> 'c))
and
('a -> 'b -> 'c) -> (('a * 'b) -> 'c)
*)

fun myfunc1 f x y = f (x,y)

(* Allows you to input arguments serpratley into a function that originally would have taken a tuple of values as an argument *)

fun myfunc2 f (x,y) = f x y

(* Performs the inverse of the previous function *)

( * End of answer to Question 5 * )
(*********************************)