➪ You have completed OCaml - Lesson 3.
(* This defines a record type. *)
type coordinates =
{ long: float ;
lat: float }
(* This defines only an alias. *)
type path = coordinates list
(* Another record *)
type region =
{ region_name: string ;
borders: path ;
has_coastline: bool }
(** Functions are first-class, they can appear in records. **)
type test =
{ (* A function which should be tested. *)
fonc: (int -> int) ;
(* An argument, which will be given to the function. *)
arg: int ;
(* The expected result. *)
expect: int }
let point1 = { long = -0.3 ;
lat = 42.5 }
let point2 = { point1 with long = -1.0 }
.field, for example let get_lat c = c.lat
let get_lat { lat = some_name ; _ } = some_name
lat is a field name, some_name is a variable which takes the value of lat.{ lat ; _ } is syntactic sugar for { lat = lat ; _ }, hence you can write let get_lat { lat ; _ } = lat
let get_lat { some_name ; _ } = some_name
mean anything, given the types defined above?let get_all { long ; lat } = (long, lat)
(* Checks if a region is well defined: it must have a region name and at least one border. *)
let is_good = function
| { region_name = "" ; _ } -> false
| { borders = [] ; _ } -> false
| _ -> true
By the way, it is possible to join patterns like this:
let is_good = function
| { region_name = "" } | { borders = [] } -> false
| _ -> true
let test1 = { ... }
and test2 = { ... }
let result1 = apply test1
(* A parameterized record type. *)
type 'a test =
{ fonc: ('a -> int) ;
arg: 'a ;
expect: int }
(* Your tests, written in the previous section, now have type: int test. *)
let test1 = { ... }
and test2 = { ... }
(* Add other tests with a different type, e.g. bool test. *)
and test3 = { ... }
type ('a, 'b) test = ...
(* Previous tests : (int, int) test. *)
let test1 = { ... }
and test2 = { ... }
(* Tests added above: (bool, int) test. *)
and test3 = { ... }
(* Add other tests with type: (bool, bool) test or (bool, string) test, ... *)
and test4 = { ... }
let john = Array.make 100 true
builds an array with 100 cells containing true.john.(index)
john.(index) <- value
let foo a i = a.(i)
let bar a i v = a.(i) <- v
type player =
{ name: string ;
age: int ;
mutable points: int }
points field is mutable. Other fields (name, age) are immutable.foo.points <- 800
which has type unit. %! in Printf to flush output.;
. | show_iplayer: | iplayer → unit |
| new_iplayer: | string → int → iplayer |
| add_ipoints: | iplayer → int → iplayer |
let test () =
(* Create an iplayer and add some points. *)
let p1_a = new_iplayer ... in
let p1_b = add_ipoints p1_a 50 in
let p1_c = add_ipoints ... in
show_iplayer p1_c
type 'a ref = { mutable contents: 'a }
(do not define it, it already exists)let create x = { contents = x }
let read rf = rf.contents
let write rf v = rf.contents <- v
let test () =
...
;
. let ref x = { contents = x }
let (!) rf = rf.contents
let (:=) rf v = rf.contents <- v
!r to read the value of r, and r := 100 to set the value of r.let gen1 =
fun () -> 0
let gen2 =
fun () ->
let count = ref 0 in
count := !count + 1 ;
!count
let gen3 =
let count = ref 0 in
fun () ->
count := !count + 1 ;
!count
type color = White | Yellow | Green | Blue | Red
type role = Player | Referee
This is again a classical enumeration.type role = Player of color * int | Referee
(def)roleReferee, which has no argument. Try: Referee ;;
Player, which has two arguments. Try: Player ;;
the type checker complains.let role1 = Referee
let role2 = Player (Green, 8)
let role3 = Player (Yellow, 10)
let get_number = function
| Referee -> 0
| Player (_, nb) -> nb
type people =
{ name: string ;
role: role ;
age: int }
Exercise : Simple variantsOne of the main usage of variants is to define recursive, and usually parameterized, structures.
type 'a mylist = Empty | Cell of 'a * 'a mylist
(Note that these constructors are completely distinct from the builtin list type.)Cell( 10, Cell(20, Empty) )
failwith "empty list"
. if, only pattern-matching.failwith "foo"
? Trying failwith "foo" ;; does not give its type, but you have other ways to find it.let mylength l =
let rec loop acu l =
(* This is your tail-recursive function *)
...
in
loop 0 l
type 'a list = [] | (::) of 'a * 'a list
(Do not redefine it)::
is a prefix constructor, so you write a :: b instead of :: (a,b)let f = function
| [] -> "empty list"
| a :: _ -> "list starting with " ^ a
The following type is already defined in OCaml: type 'a option = None | Some of 'a
It can be used to return a result (Some x), or nothing (None) when nothing can be returned.
Some x if the list head is x, and returns None if the list is empty.Exercise : Ad-hoc functionsWe use the type people defined in the Variant section.
get_younger people_list 20 returns the list of people being at most 20 years old.Some x), or None if nobody has the expected color.Exercise : Generic functionsWe now write polymorphic higher-order functions on lists, and see that the previous exercise is only a particular case of them.
filter pred alist
returns the elements of alist for which the predicate pred returns true.filter (fun x -> x mod 2 = 0) [ 1 ; 2 ; 3 ; 4 ; 5 ; 6]
| [2 ; 4 ; 6] |
filter (fun x -> x < 10) [ 100 ; 5 ; 15 ; 6 ; 16 ; 7 ]
| [5 ; 6 ; 7] |
filter (fun x -> x < 0) [ 100 ; 5 ; 15 ; 6 ; 16 ; 7 ]
| [] |
find pred alist
returns the first element of the list that satisfies pred (returns Some x), or None if no element satisfies pred.Once the mission is completed, you must be able to: