((* CS:3820, Fall 2016 *)
(* Cesare Tinelli *)
(* The University of Iowa *)
(* F# examples seen in class *)
type ilist = E | L of int * ilist
let l = L(1, L(2, L(3, E)))
let head l =
match l with
| E -> failwith "list is empty!"
| L(h, _) -> h
let tail l =
match l with
| E -> failwith "list is empty!"
| L(_, t) -> t
let rec last l =
match l with
| E -> failwith "list is empty!"
| L(h, E) -> h
| L(h, t) -> last t
type 'a list = E | L of 'a * 'a list
let l1 = L(1, L(2, E))
let l2 = L("a", L("b", E))
let id x = x
id 5
id 3.3
let toTriple x y z = (x, y, z)
// forces first two parameters to be of the same type
let toTriple (x:'a) (y:'a) (z:'b) = (x, y, z)
let equal x y = (x = y)
let distinct x y = not (x = y)
(* Lists *)
[]
[3;5;6;3]
["dd"; "sdf"]
[(1,2); (1,4)]
[[3;1]; []; [4;5;6]]
(*
[3; "sdf"]
*)
[6]
6::[]
6 :: []
5::(6::[])
5::6::[]
(*
5::6
*)
List.head [1;2;3]
List.tail [1;2;3]
let (h :: t) = [1;2;3]
let (h :: t) = (1 :: (2 :: (3 :: [])))
let rec len l =
match l with
[] -> 0
| _ :: t -> 1 + (len t)
len [2;5;1]
len ["a";"b"]
let rec len l =
match l with
[] -> 0
| _ :: t -> 1 + (len t)
(*
len (1 :: 2 :: 3 :: [])
--> 1 + len (2 :: 3 :: [])
--> 1 + 1 + len (3 :: [])
--> 1 + 1 + 1 + len []
--> 1 + 1 + 1 + 0
--> 3
*)
let rec min l =
match l with
[] -> failwith "Empty list!"
| n :: [] -> n
| n1 :: n2 :: t when n1 < n2 -> min (n1 :: t)
| n1 :: n2 :: t -> min (n2 :: t)
min [1;4;0;9;3]
(*
min (1 :: 4 :: 0 :: 9 :: 3 :: [])
--> min (1 :: 0 :: 9 :: 3 :: [])
--> min (0 :: 9 :: 3 :: [])
--> min (0 :: 3 :: [])
--> min (0 :: [])
--> 0
*)
let rec append l m =
match l with
[] -> m
| h :: t -> h :: (append t m)
append [1;2] [2;3;4]
// append is actually predefined and has infix syntax
[1;2] @ [2;3;4]
let rec reverse = function
[] -> []
| h :: t -> append (reverse t) [h]
reverse [1;2;3]
// association lista are lists of type ('a * 'b) list
let al = [("a", 3); ("c", 78); ("baf", 666); ("b", 111)]
let rec lookup al x =
match al with
| [] -> failwith "key not found"
| (k,v) :: t -> if x = k then v else lookup t x