Slide: 1

Slide: 2

• langage fonctionnel,
• typé statiquement,
• polymorphe paramétrique,
• avec inférence de types,
• muni d'un mécanisme d'exceptions
• et de traits impératifs,
• possèdant un système de modules paramétrés
• (et un modèle objet),
• possiblement indépendant de l'architecture machine.

Slide: 3

• l'ancêtre : ML (meta-langage) de LCF (80)
• machine abstraite : la CAM ; Curien, Cousineau
• spécifications : Standard ML (84 - Milner)
• premières implantations
  • CAML - Suarez - Weis - Mauny (87)
  • SML/NJ - Mc Queen - Appel (ATT - 88)
• nouvelles implantations : Caml-light (90) Leroy - Doligez
• modules paramétrés : CSL (95)
• extension objet (96)

Slide: 4

$ cat p.ml
let f x = x+1
print_int (f 1999); print_newline()
$ ocamlc -i -o p.exe p.ml
val f : int -> int

$ file p.exe
p.exe: a /usr/local/bin/ocamlrun script text
$ ./p.exe
2000

Slide: 5

$ ocmalopt -o p.exe p.ml
$ file pp.exe 
p.exe: ELF 32-bit LSB executable, Intel 80386, 
version 1 (FreeBSD), dynamically linked, not stripped
$ ./p.exe
2000

Slide: 6

$ ocaml
        Objective Caml version 3.00

# let f x = x+1 ;;
val f : int -> int = <fun>
# print_int (f 1999); print_newline() ;;
2000
- : unit = ()
# #quit ;;
$

Slide: 7

1. Types et opérateurs numériques
2. Définir et utiliser des fonctions (sur les nombres)
3. Manipuler les nombres
4. Autres types de base simples
5. Types et structures de données paramétrés
6. Manipuler ces types
7. Types utilisateurs
8. Des expressions (synthèse)
9. Des programmes

Slide: 8

Slide: 9

• Entiers :
  • type int
  • valeurs [-2³⁰,2³⁰-1]
    (sur machine 32 bits)
• Flottants :
  • type float
  • valeurs mantisse 53 bits, exposant [-1022,1023]
    (norme IEEE 754)

Slide: 10

# 1 ;;
- : int = 1

• le # est l'invite ;
• 1 est l'expression ;
• le ;; provoque l'évaluation ;
• on obtient en retour le type (int) et la valeur (1)

Slide: 11

# -1 ;;
- : int = -1
# 0xffffffff ;;
- : int = -1
# 0o10 ;;
- : int = 8
# 0b10 ;;
- : int = 2

Slide: 12

# 1.0 ;;
- : float = 1.000000
# 1. ;;
- : float = 1.000000
# 0.1 ;;
- : float = 0.100000
# 1.e-1 ;;
- : float = 0.100000

Slide: 13

# 1 + 2 * 3 mod 4;;
- : int = 3

Slide: 14

Slide: 15

# let cube x = x*x*x ;;
val cube : int -> int = <fun>

# cube 3 ;;
- : int = 27

Slide: 16

# cube 3+1 ;;
- : int = 28
# cube (3+1) ;;
- : int = 64
# cube cube 3 ;;
This function is applied to too many arguments
# cube (cube 3) ;;
- : int = 19683

Slide: 17

# let fact n = if n <= 0 then 1 else n * (fact (n-1)) ;;
Unbound value fact
# let rec fact n = if n = 0 then 1 else n * (fact (n-1)) ;;
val fact : int -> int = <fun>

Slide: 18

# let rec fact n =
    if n < 0 then failwith "undefined"
    else if n = 0 then 1 
    else n * (fact (n-1)) 
;;
# fact (-1)
Uncaught exception: Failure "undefined".

Slide: 19

# let rec even n =
    if n=0 then true
    else odd (n-1)

  and odd n =
    if n=1 then true
    else even (n-1) 
;;
val even : int -> bool = <fun>
val odd : int -> bool = <fun>

Slide: 20

# let x = 3 ;;
val x : int = 3

# let puiss4 n =
    let n2 = n*n in n2*n2 ;;
val puiss4 : int -> int = <fun>
# puiss4 2 ;;
- : int = 16

Slide: 21

Slide: 22

# max_int ;;
- : int = 1073741823
# min_int ;;
- : int = -1073741824
# max_int+1;;
- : int = -1073741824

# 1 / 0 ;;
Uncaught exception: Division_by_zero.
# 1.0 /. 0.0 ;;
- : float = Inf

Slide: 23

# 1.0 / 0 ;;
This expression has type float but is here used with type int
# 1.0 /. 0 ;;
This expression has type int but is here used with type float

# float_of_int ;;
- : int -> float = <fun>
# (float_of_int 1) /. 2.0 ;;
- : float = 0.500000

Slide: 24

# (float_of_int max_int) ** 2. ;;
- : float = 1152921502459363328.000000
# int_of_float ;;
- : float -> int = <fun>
# int_of_float ((float_of_int max_int) ** 2.) ;;
- : int = 0

Slide: 25

# print_int ;;
- : int -> unit = <fun>
# print_float ;;
- : float -> unit = <fun>
# print_newline ;; 
- : unit -> unit = <fun>
# print_int 1; print_newline();
  print_float 1.0; print_newline() ;;
1
1
- : unit = ()

Slide: 26

# () ;;
- : unit = ()

# print_int (2+3); 2+3 ;;
5- : int = 5

Slide: 27

Slide: 28

# 'A' ;;
- : char = 'A'
# '\n' ;;
- : char = '\n'
# '\010' ;;
- : char = '\n'

Slide: 29

# int_of_char 'A' ;;
- : int = 10
# char_of_int 65 ;;
- : char = 'A'
# char_of_int 0 ;;
- : char = '\000'
# char_of_int (-1) ;;
Uncaught exception: Invalid_argument "char_of_int".
# char_of_int 256 ;;
Uncaught exception: Invalid_argument "char_of_int".

Slide: 30

# "Hello" ;;
- : string = "Hello"
# "" ;;
- : string = ""

# "Hello" ^ " (O'Caml) " ^ "world\n" ;;
- : string = "Hello (O'Caml) world\n"

Slide: 31

# 'H' ^ "ello" ;;
This expression has type char but is here used with type string
# "2000" + 1 ;;
This expression has type string but is here used with type int
# int_of_string ;;
- : string -> int = <fun>
# (int_of_string "2000") + 1 ;;
- : int = 2001
# int_of_string "2 000" ;;
Uncaught exception: Failure "int_of_string".
# string_of_char ;;
Unbound value string_of_char

Slide: 32

# String.make 12 '.' ;;
- : string = "............"
# String.create 12 ;;
- : string = "\216\141\013\008H\253\t\008\008Z\006\008"

# Sys.max_string_length ;;
- : int = 16777211
# String.create (Sys.max_string_length + 1) ;;
Uncaught exception: Invalid_argument "String.create".

Slide: 33

# print_char ;;
- : char -> unit = <fun>
# print_string ;;
- : string -> unit = <fun>

# Printf.printf "%d %f %c %s \n" 1 1. '1' "1" ;;
1 1.000000 1 1 
- : unit = ()

Slide: 34

# true ;;
- : bool = true
# false ;;
- : bool = false

Slide: 35

# lnot false ;;
This expression has type bool but is here used with type int
# lnot 0 ;;
- : int = -1
# lnot 0xffffffff;;
- : int = 0

Slide: 36

# 0 < 1 ;;
- : bool = true
# false < true ;;
- : bool = true
# 0 < true ;;
This expression has type int but is here used with type bool

Slide: 37

Slide: 38

# 1, "mai" ;;        
- : int * string
# "may", 1 ;;
- : string * int = "may", 1

Slide: 39

# fst ;;
- : 'a * 'b -> 'a = <fun>
# snd ;;
- : 'a * 'b -> 'b = <fun>

Slide: 40

# fst (1,"mai") ;;
- : int = 1
# fst 1, "mai" ;;
This expression has type int but is here used with type 'a * 'b

# int_of_char, char_of_int ;;
- : (char -> int) * (int -> char) = <fun>, <fun>
# (fst (int_of_char, char_of_int)) 'A' ;;
- : int = 65

Slide: 41

# let pol1 (n, m) = 3*n*n + 2*m + 1 ;;
val pol1 : int * int -> int = <fun>
# pol1 (1, 2) ;;
- : int = 8
# pol1 1 2 ;;
This function is applied to too many arguments

# let pol1' c = 3*(fst c)*(fst c) + 2*(snd c) + 1 ;;
val pol1' : int * int -> int = <fun>

Slide: 42

# let pol2 n m = 3*n*n + 2*m + 1 ;;
val pol2 : int -> int -> int = <fun>
# pol2 1 ;;
- : int -> int = <fun>
# pol2 1 2 ;;
- : int = 8

1. int -> int -> int º int -> (int -> int)
2. pol2 1 2 º ((pol2 1) 2)

Slide: 43

# 1, "mai", 2001 ;;
- : int * string * int = 1, "mai", 2001
# (1, "mai"), 2001 ;;
- : (int * string) * int = (1, "mai"), 2001
# (1, "mai", 2001) = ((1, "mai"), 2001)  ;;
This expression has type int * string * int but is here used 
with type (int * string) * int
# (1, "mai", 2001) = (1, ("mai", 2001)) ;;
This expression has type int * string * int but is here used 
with type int * (string * int)

Slide: 44

• constructeurs
  • liste vide, notée []
  • ajout d'un élément en tête, noté :: (infixe)
• accesseurs (module List)
  • élément en tête, List.hd : 'a list -> 'a
    List.hd (x::xs) º x
  • suite de la liste, List.tl : 'a list -> 'a list
    List.tl (x::xs) º xs

Slide: 45

# [];;                       
- : 'a list = []
# [1; 2; 3] ;;
- : int list = [1; 2; 3]
# 0::[1; 2; 3] ;;
- : int list = [0; 1; 2; 3]
# 0::1::2::3::[] = [0; 1; 2; 3] ;;              
- : int list = [1; 2; 3]

# [0; 1] @ [2; 3] ;;
- : int list = [0; 1; 2; 3]

Slide: 46

# [1; "mai"] ;;
This expression has type string but is here used with type int

# [String.uppercase; String.lowercase] ;;
- : (string -> string) list = [<fun>; <fun>]
# (List.hd [String.uppercase; String.lowercase]) "hello" ;;
- : string = "HELLO"

Slide: 47

Slide: 48

# let rec sum ns =
    match ns with
      [] -> 0
    | n::ns' -> n + (sum ns') ;;
val sum : int list -> int = <fun>
# sum [6; 60; 600] ;;
- : int = 666

Slide: 49

# let head_and_tail xs =
    match xs with
      [] -> failwith "empty"
    | x::xs' -> x, xs' ;;
val head_and_tail : 'a list -> 'a * 'a list = <fun>
# head_and_tail [0; 1; 2] ;;
- : int * int list = 0, [1; 2]

Slide: 50

# let head_only xs =
    match xs with
      [] -> failwith "empty"
    | x::_ -> x ;;
# head_only [0; 1; 2] ;;
- : int = 0

Slide: 51

# let bad_head_only xs =
    match xs with
      _ -> failwith "first pattern"
    | x::_ -> x ;;
Warning: this match case is unused.
# bad_head_only [0; 1; 2] ;;
Uncaught exception: Failure "first pattern".

Slide: 52

# let rec pairing xs =
    match xs with
      [] -> []
    | [x] -> failwith "should be of even length"
    | x1::x2::xs' -> (x1,x2)::(pairing xs') ;;

# let rec pairing xs =
    match xs with
      [] -> []
    | x1::x2::xs' -> (x1,x2)::(pairing xs') 
    | _ -> failwith "should have even elements" ;;

Slide: 53

# let rec rem_zero nss =
    match ns with
      [] -> []
    | 0::ns' -> rem_zero ns'
    | n::ns' -> n::(rem_zero ns') ;;
val rem_zero : int list -> int list = <fun>
# rem_zero [1; 0; 2; 0; 0; 3] ;;
- : int list = [1; 2; 3]

Slide: 54

# let rec rem_dup xs =
    match xs with
      x::x::xs' -> rem_dup (x::xs')
    | x::xs' -> x::(rem_dup xs')
    | _ -> xs ;;
This variable is bound several times in this matching

Slide: 55

# let print_int_list = 
    let print_fun n = Printf.printf"(%d)" n in
      List.iter print_fun
;;
val print_int_list : int list -> unit = <fun>
# print_int_list [0; 1; 2; 3] ;;
(0)(1)(2)(3)- : unit = ()

Slide: 56

# let rev_pairs xys =
    let f (x,y) = (y,x) in
      List.map f xys
;;
val rev_pairs : ('a * 'b) list -> ('b * 'a) list = <fun>
# rev_pairs [1,true; 2,false; 3,true; 4,false] ;;
- : (bool * int) list = [true, 1; false, 2; true, 3; false, 4]

Slide: 57

# let sum ns = List.fold_right (+) ns 0 ;;
val sum : int list -> int = <fun>
# sum [1; 2; 3; 4] ;;
- : int = 10

Slide: 58

Slide: 59

# type int_or_float =
    Int_value of int
  | Float_value of float ;;

# Int_value 1 ;;
- : int_or_float = Int_value 1
# Float_value 1.5 ;;
- : int_or_float = Float_value 1.500000

Slide: 60

# let add x y =
    match x, y with
      Int_value n1, Int_value n2 -> Int_value (n1 + n2)
    | Float_value x1, Float_value x2 -> Float_value (x1 +. x2)
    | _ -> failwith "type error" ;;

Slide: 61

# type fun_and_arg = 
    Arg  of int 
  | Fun of (int -> int) ;;
[...]
# let apply t =
    match t with 
      Fun f, Arg x -> f x
    | _ -> failwith"some this wrong"
;;
val apply : fun_and_arg * fun_and_arg -> int = <fun>
# apply (Fun succ, Arg 1) ;;
- : int = 2

Slide: 62

# type int_btree =
    Empty
  | Node of int_btree * int * int_btree ;;

# type 'a btree =
    Empty
  | Node of 'a btree * 'a * 'a btree ;;

Slide: 63

let rec btree_fold f a t =
  match t with
    Empty -> a
  | Node(t1, x, t2) 
    -> f x (btree_fold f a t1) (btree_fold f a t1)
;;
val btree_fold : 
  ('a -> 'b -> 'b -> 'b) -> 'b -> 'a btree -> 'b = <fun>

Slide: 64

# type 'a tree =
    Leaf
  | Branch of 'a * 'a forest

  and 'a forest =
    Empty
  | Cons of 'a tree * 'a forest
;;

Slide: 65

# let rec tree_fold f a g b t =
    match t with
      Leaf -> a
    | Branch (x, ts) -> f x (forest_fold f a g b ts)
  and forest_fold f a g b ts =
    match ts with
      Empty -> b
    | Cons (t, ts') 
      ->  g (tree_fold f a g b t) (forest_fold f a g b ts')
;;

Slide: 66

val tree_fold :
  ('a -> 'b -> 'c) -> 'c -> ('c -> 'b -> 'b) -> 'b 
   -> 'a tree -> 'c = <fun>
val forest_fold :
  ('a -> 'b -> 'c) -> 'c -> ('c -> 'b -> 'b) -> 'b 
   -> 'a forest -> 'b = <fun>

Slide: 67

# type fiche = 
   { nom: string;
     prenom: string;
     naissance: int*int*int } ;;

# let f1 = { prenom = "Gilberte";
             naissance = 01,01,01;
             nom = "Albertine" } ;;
val f1 : fiche = 
  {nom="Albertine"; prenom="Gilberte"; naissance=1, 1, 1}

Slide: 68

# f1.nom ;;
- : string = "Albertine"

# let get_nom f =
    match f with
      {nom=x} -> x
;;
val get_nom : fiche -> string = <fun>
# get_nom f1 ;;
- : string = "Albertine"

Slide: 69

# type t = { value: int; next: int -> int } ;;
[...]
# let e0 = { value = 0; next = succ } ;;
val e0 : t = {value=0; next=<fun>}

# let e1 = { e0 with value = e0.next e0.value } ;;
val e1 : t = {value=1; next=<fun>}

Slide: 70

type t = { value: int; next: t -> t } ;;
[...]
# let e1 =
    let succ_t e = { e with value = succ e.value } in
      { value = 2; next = succ_t } ;;
val e1 : t = {value=2; next=<fun>}
# let e2 = 
    let square_t e = { e with value =  e.value * e.value } in
      { value = 2; next = square_t } ;;
val e2 : t = {value=2; next=<fun>}

Slide: 71

# let next_t e = e.next e ;;
val next_t : t -> t = <fun>
# let e1' = next_t e1 ;;
val e1' : t = {value=3; next=<fun>}
# let e1'' = next_t e1' ;;
val e1' : t = {value=4; next=<fun>}
# let e2' = next_t e2 ;;
val e2' : t = {value=4; next=<fun>}
# let e2'' = next_t e2' ;;
val e2'' : t = {value=16; next=<fun>}

Slide: 72

Slide: 73

# let f x = print_string" puis j'oublie mon argument\n" ;;
val f : 'a -> unit = <fun>
# f (print_string"je suis l'argument") ;;
je suis l'argument puis j'oublie mon argument
- : unit = ()

Slide: 74

# fun x -> failwith"j'ai oublie mon argument" ;;
- : 'a -> 'b = <fun>
# (fun x -> failwith"j'ai oublie mon argument") "Go" ;;
Uncaught exception: Failure "j'ai oublie mon argument".

Slide: 75

# print_string"je vaux "; 2001 ;;
je vaux - : int = 2001
# failwith"je m'arrete la"; 2001 ;;
Uncaught exception: Failure "je m'arrete la".

Slide: 76

# if true then 20/20 else 0/0 ;;
- : int = 1
# (if true then 20/20 else 0/0) + 10 ;;
- : int = 11

Slide: 77

# match failwith"je ne ressemble a rien" with _ -> 0/0 ;;
Uncaught exception: Failure "je ne ressemble a rien".
# (match true with false -> 0/0 | true -> 20/20) + 10 ;;
- : int = 11

Slide: 78

# let x = print_string"je vaux " in 1 ;;
je vaux - : int = 1
# let x = failwith"je ne vaux rien" in 1 ;;
Uncaught exception: Failure "je ne vaux rien".

Slide: 79

Slide: 80

# let a = 3 and b = 5 and c = 7 ;;
[...]
# let fun_poly = fun x -> fun y -> a*x*x + b*y + c ;;
val fun_poly : int -> int -> int = <fun>
# fun_poly 1 2 ;;
- : int = 20

Slide: 81

1. Les déclarations créent l'environnement d'évaluation
2. L'expression principale déclanche l'évaluation

This document was translated from L^AT_EX by H^EV^EA.