108 lines
2.9 KiB
OCaml
108 lines
2.9 KiB
OCaml
(* Some, None - Are called data/value constructors *)
|
|
Some 1;; (* - : int option = Some 1 *)
|
|
|
|
None;; (* - : 'a option = None *)
|
|
|
|
(* OPTIONS are called type constructors, it takes a type *)
|
|
(* 'a is a type variable, where 'a is some type such as int *)
|
|
|
|
type 'a option = None | Some of 'a;;
|
|
|
|
(*
|
|
You can define any type you want, this type constructor starts
|
|
with a lower case letter "direction" and the value constructor starts
|
|
with uppercase "North", "East", ...
|
|
|
|
type constructors are not functions
|
|
*)
|
|
type direction = North | East | South | West;;
|
|
|
|
(* There are RESULT types *)
|
|
Ok 1;;
|
|
Error "hell";; (* albert's example is hell not my example *)
|
|
|
|
(*
|
|
A result is a two type variable, this is the syntax for
|
|
something that takes to type variables
|
|
*)
|
|
type ('a, 'b) result = Ok of 'a | Error of 'b;;
|
|
|
|
(1, 2);; (* type is - : int * int = (1, 2) *)
|
|
(* (int, int) : (type * type) *)
|
|
|
|
(* we define an expresion that has a type of Int, and can be of type Add, Sub or Mul *)
|
|
type expr =
|
|
Int of int
|
|
| Add of expr * expr
|
|
| Sub of expr * expr
|
|
| Mul of expr * expr;;
|
|
|
|
(* We then define an eval function, that takes in an eval,
|
|
and recursively evaluates e1, e2 till they are just of
|
|
type Int to then evaluate the addition, subtraction, etc. *)
|
|
let rec eval = function
|
|
| Int n -> n
|
|
| Add (e1, e2) -> eval e1 + eval e2
|
|
| Sub (e1, e2) -> eval e1 - eval e2
|
|
| Mul (e1, e2) -> eval e1 * eval e2;;
|
|
|
|
let e = Mul(Add (Int 1, Int 2), Int 7);;
|
|
eval e;;
|
|
|
|
(* lets apply the type variables and constructors to create a card type *)
|
|
type suit = Club | Diamond | Heart | Spade;;
|
|
type rank = Num of int | Jack | Queen | King | Ace;;
|
|
type card = rank * suit;;
|
|
|
|
let compare_rank r1 r2 =
|
|
match r1, r2 with
|
|
| Num x, Num y -> Int.compare x y
|
|
| Num _, _ -> -1
|
|
| _, Num _ -> 1
|
|
| _, _ -> Stdlib.compare r1 r2;;
|
|
|
|
let compare_suit s1 s2 = Stdlib.compare s1 s2;;
|
|
|
|
let compare_card (r1, s1) (r2, s2) =
|
|
let c = compare_rank r1 r2 in
|
|
if c = 0 then compare_suit s1 s2
|
|
else c;;
|
|
|
|
let string_of_suit = function
|
|
| Club -> "clubs"
|
|
| Diamond -> "diamonds"
|
|
| Heart -> "hearts"
|
|
| Spade -> "spades";;
|
|
|
|
let string_of_rank = function
|
|
| Num n -> string_of_int n
|
|
| Jack -> "Jack"
|
|
| Queen -> "Queen"
|
|
| King -> "King"
|
|
| Ace -> "Ace"
|
|
|
|
let string_of_card (r, s) =
|
|
string_of_rank r ^ " of " ^ string_of_suit s;;
|
|
|
|
compare_card (King, Diamond) (Queen, Heart);;
|
|
string_of_card (Queen, Heart);;
|
|
|
|
let all_suits = [Club; Diamond; Heart; Spade];;
|
|
let all_ranks =
|
|
(List.init 9 (fun x -> x + 2) |> List.map (fun x -> Num x)) @
|
|
[Jack; Queen; King; Ace];;
|
|
|
|
let all_cards =
|
|
List.fold_right (fun rank acc -> (
|
|
List.fold_right (fun suit acc -> (rank, suit) :: acc) all_suits []
|
|
) @ acc) all_ranks [];;
|
|
|
|
type 'a linked_list = Nil | Cons of 'a * 'a linked_list;;
|
|
|
|
let rec map_linked f = function
|
|
| Nil -> Nil
|
|
| Cons (x, l) -> Cons (f x, map_linked f l);;
|
|
|
|
Cons (1, Cons (2, Cons (3, Nil))) |> map_linked (fun x -> x * x);;
|
|
|