When we make our programs more and more complex, we need more complex data types as well. We have only used OCaml's built-in data types, how can we construct our own data types?
\ntypeThe type keyword is similar to the typedef keyword in C, except more limited in scope. A type can only be multiple variants of arbitrary values.
(* coin is enum with variants Heads and Tails*)\ntype coin = Heads | Tails\nEach variant can also contain data of other data types.
\ntype shape =\n | Rect of float * float\n | Circle of float\nlet r = Rect (3.0, 4.0) (* r has type shape *)\nshape here has two variants. It can either be a tuple of two floats when it is a Rect, or it can be a single float when it is a Circle.
These data types are also known as algebraic data types or tagged unions.
\nADTs can be useful when we want to ensure the complete handling of all cases. For example, if an object is nullable, it is useful to make sure that we must handle the null case instead of passing that off to the developer who might carelessly not handle it. This is where the option type comes from.
\ntype 'a option =\n | Some of 'a\n | None\nThe 'a keyword means that that the type option is polymorphic, and the variant Some will contain whatever type that option is defined for. When handling an option, you must destructure it into its Some and None variants and handle both cases, otherwise OCaml will warn you for a non-exhaustive pattern match.
We can actually define our own list data type as a recursive data type, which is a data type which contains itself.
\ntype 'a list =\n | Nil\n | Cons of 'a * 'a list\nHere, list has two variants, Nil and a Cons tuple of an element and a list. If we think of the traditional list data type, this is actually just a more verbose version. [] is sugar for Nil and :: is sugar for Cons tuple.
let rec len l =\n match l with\n | Nil -> 0\n | Cons (_, t) -> 1 + (len t)\n(* same as *)\nlet rec len l =\n match l with\n | [] -> 0\n | _ :: t -> 1 + (len t)\nExceptions are a special data type used for errors in OCaml. Exceptions are similar to type constructors in that they can take arguments or have none.
\nexception Sign of int\nlet f n =\n if n > 0 then\n raise (Sign n)\n else\n raise (Failure \"foo\")\nWe can raise an exception with arguments whenever we want, which will exit the function with the exception name and its arguments. Failure is a generic exception type that is used with strings.
There is also special try syntax used to catch exceptions.
let g n =\n try\n f n\n with Sign n ->\n Printf.printf \"Caught %d\\n\" n\n | Failure s ->\n Printf.printf \"Caught %s\\n\" s\nThe function g will try running f n, but if that raises an exception, it will be caught in with. It can be pattern matched for different exception types.