➪ You have completed OCaml - Lesson 2.
switch:let f x =
match x with
| 0 -> "zero"
| 1 -> "one"
| 2 -> "two"
| _ -> "another number"
or, equivalently, let f = function
| 0 -> "zero"
| 1 -> "one"
| 2 -> "two"
| _ -> "another number"
_
not in the last position.let f tup =
match tup with
| (0, true) -> 1
| (0, false) -> -1
| (_, false) -> 2
| (_, true) -> 3
| (1, false) -> 2
and guess what the compiler says.let f (a,b) =
match (a,b) with
| (0, true) -> 1
| (0, false) -> -1
| (_, false) -> 2
| (_, true) -> 3
let confused2 (a,b) = function
| (0, true) -> 1
| (n ,_) -> 10
let foo x y = match (x,y) with
| (0,0) -> x
| _ -> y
let bar x y = function
| (0,0) -> x
| _ -> y
match and function. let calc = function
| (x, y, "add") -> x + y
| (x, y, "sub") -> x - y
| (x, y, "mul") -> x * y
| (x, 0, "div") -> failwith "Division by zero."
| (x, y, "div") -> x / y
| _ -> failwith "Unknown operator."
failwith
raises an exception.0 in one pattern?calc (110, 220, "add")
and try other triples too.x + y
. x + y
is equal to the integer found in the first position of the triple, e.g. 110.match but you no longer need function. type operation = Add | Sub | Mul | Div
(Yes, the names must start with a capital.)calc 4 5 Mul
must return 20.let equal a b =
match b with
| a -> true
| _ -> false
equal 0 0
equal 0 1
let equal a b =
match b with
| z -> true
| _ -> false
let equal a b =
match b with
| _ -> true
| _ -> false
let equal a b =
match b with
| x when x = a -> true
| _ -> false
;
a ; b
or a ;
b
has the same type than ba
is expected to have type unit.let f x =
Printf.printf "Calling f with value x = %d\n %!" x ;
x * x + 2
Printf line has type unit.x * x + 2, that is int, hence f has type int → int. let f x =
Printf.printf "Calling f with value x = %d\n %!" x ;
x + 1 ;
x * x + 2
x + 1
is ignored. The compiler emits a warning.
Exercise : Sequenceshow f v
prints a message Function called with value (here the value of v) then returns the same result as f v
. let double x = x * 2 ;;
show double 100
pshow cv f v
is exactly like show f v
, except that we use the function cv to convert the argument v to type string. The function cv has type (α → string). (Do not try to use show, which is less generic).(* A function taking an int. *)
let double x = x * 2
let show_double = pshow string_of_int double ;;
let a = show_double 0 ;;
let b = show_double 40 ;;
(* A function taking a pair of ints. *)
let sumsquare (x,y) = x * x + y * y
(* sprintf returns a string, instead of printing it. *)
let string_of_pair (x,y) = Printf.sprintf "(%d, %d)" x y
let show_sumsquare = pshow string_of_pair sumsquare ;;
let a = show_sumsquare (1, 2) ;;
let b = show_sumsquare (10, 5) ;;
Notice that show_double has the same type than double, and show_sumsquare has the same type than sumsquare.
Besides, both are closures.
You already know the top-level let.
In this chapter, we introduce another construct: let ... in ...
which is an expression and thus, it can be used inside other expressions.
let variable = expression in expression'let x = expr1 in expr2
is expr1 ⇝ vv that is, return expr2[x := v] (you recognize a substitution)var x = expr1 ;
expr2
let x = expr1 in
expr2
let is_leap_year n =
(* Test if n is a multiple of x. *)
let multiple_of x = n mod x = 0 in
let is_mul4 = multiple_of 4 in
let is_mul100 = multiple_of 100 in
let is_mul400 = multiple_of 400 in
is_mul400 || (is_mul4 && not is_mul100)
let ... and ...
. See the difference between:(* A top-level let to write our program. *)
let res1 =
(* A first inner let. *)
let a = 10 in
(* A second inner let, binding two variables at once. *)
let a = 20
and b = a in
(* The final result *)
(a, b)
and (* A top-level let to write our program. *)
let res2 =
(* A first inner let. *)
let a = 10 in
(* Two inner let (instead of one). *)
let a = 20 in
let b = a in
(* The final result *)
(a, b)
The results are different.
(* This one is a top-level let. *)
let result1 =
(* These are inner let. *)
let a = 10
and b = 20
and c = true
in
let a = c
and b = a
and c = b
in
(a,b,c)
let result2 =
10 +
let x = 5 + 5 in
let y = x * x in
2 * y
let result3 =
"Foo is " ^
let x = string_of_int (5*5) in
x ^ " I say."
let is actually a bit more general. It can bind a single, exhaustive pattern. Here are some examples: let x = expression
(nothing new)let (a, b, c) = (10, 20, 30)
let (a, b) = (b, a)
let () = print_endline "Hello."
let () =
print_endline "You get" ;
print_endline "a shiver" ;
print_endline "in the dark" ;
()
{ int x ;
{ x += 7 ;
x = x << 8 ; }
x -= 256 ;
}
let f a (b,c) = a+b+c
let f a p =
match p with
| (b,c) -> a+b+c
let f a p =
let (b,c) = p in
a+b+c
let f a = function
| (b,c) -> a+b+c
let f a = fun (b,c) -> a+b+c
let get_triple arg =
match arg with
| (a, p) ->
begin match p with
| (b,c) -> [ a ; b ; c ]
end
An OCaml program (a module) consists of definitions and expressions.
let, type definitions, module definitions, and a few other things.let x = expressionif, while, for
(do not even think about using while, which is evil imperative-style)let x = expression in expressionfun, function, match
begin expression end(expression)fun and function have very different specifications.Exercise : Expressionslet fancy1 x =
begin
if ... then
(fun a b -> ... )
else
...
end
(x-1) (x+1)
let fancy2 a b c =
(* Remember concatenation? *)
"Hello " ^
let f =
if ... then
match ... with
| ... -> (fun x -> ... )
| ... -> (function 4 -> ...
| _ -> ... )
else
...
in
(* Use f here *)
(fun) inside a match inside a if inside a let inside a top-level let. Once the mission is completed, you must be able to: