Introduction à OCaml

• L'interpréteur interactif
• Les types primitifs
• Le Transtypage
• Définir une valeur
• Les Tableaux
• Les Listes
• Les Tuples
• Les Fonctions
• Condition if
• La Boucle for
• Les Boucles avec des Fonctions
• Filtrage avec match
• Iteration sur les Listes et les Tableaux
• Les Enregistrements
• Les Enregistrements : Mise à Jour Immuable
• Les Variants
• Mise en garde contre les tableaux
• Les chaînes de caractères
• Récursivité Terminale
• Script et exécutable
• Main
• Les Exceptions
• Aller plus loin
• Notice d'utilisation

Les différents modes d'exécution

• en binaire, code natif compilé
  (comme le C et avec des performances équivalentes)
• en bytecode exécuté à l'aide d'une machine virtuelle
  (comme Java et avec des performances équivalentes)
• en interprété avec l'interpréteur
  (comme Python, Perl, Ruby ou PHP et avec des performances équivalentes)
• en interactif avec une boucle d'interaction nommée "toplevel"
  (comme avec la commande 'python')

Les styles de programmation

Lancez l'interpréteur intractif

[guest@localhost ˜]$ ocaml
        OCaml version 4.11.1

#

[guest@localhost ˜]$ rlwrap ocaml
        OCaml version 4.11.1

#

Les types primitifs

# 6 ;;

- : int = 6

# 8.2 ;;
- : float = 8.2

# 12. ;;
- : float = 12.

# 12 ;;
- : int = 12

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

# 'e' ;;
- : char = 'e'

# "OCaml" ;;
- : string = "OCaml"

# "OC" ^ "aml";;
- : string = "OCaml"

# "OCaml".[2] ;;
- : char = 'a'

# "OCaml".[26] ;;
Exception: Invalid_argument "index out of bounds".

# () ;;
- : unit = ()

# print_endline "OCaml" ;;
OCaml
- : unit = ()

# print_newline () ;;

- : unit = ()

Transtypage

# float_of_int 16 ;;
- : float = 16.

# int_of_float 12.0 ;;
- : int = 12

# int_of_char 'A' ;;
- : int = 65

# char_of_int 97 ;;
- : char = 'a'

# 4 + 6 ;;
- : int = 10

# 2.4 *. 1.2 ;;
- : float = 2.88

# (float) 9 /. 1.2 ;;
- : float = 7.5

Définir une valeur

# let my_item = 128 ;;
val my_item : int = 128

# my_item ;;
- : int = 128

# let my_item = my_item * 2 ;;
val my_item : int = 256

Les Tableaux

# [| 'b'; 'E'; 't'; 'i' |] ;;
- : char array = [|'b'; 'E'; 't'; 'i'|]

# let my_array = [| 1; 5; 7; 12; 64 |] ;;
val my_array : int array = [|1; 5; 7; 12; 64|]

# my_array.(2) ;;
- : int = 7

Les Listes

# [ 1; 3; 45; 24; 17; 0; 9 ] ;;
- : int list = [1; 3; 45; 24; 17; 0; 9]

# let my_list = [ 3; 4; 5 ] ;;
val my_list : int list = [3; 4; 5]

# 8 :: my_list ;;
- : int list = [8; 3; 4; 5]

# [] ;;
- : 'a list = []

# 3 :: [] ;;
- : int list = [3]

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

Les Tuples

# (3, 'F') ;;
- : int * char = (3, 'F')

# let a = 3 ;;
val a : int = 3
# let b = 'F' ;;
val b : char = 'F'

# let (a, b) = (b, a) ;;
val a : char = 'F'
val b : int = 3

# a ;;
- : char = 'F'
# b ;;
- : int = 3

# (12.5, "www.ifrc.org", float_of_int) ;;
- : float * string * (int -> float) = (12.5, "www.ifrc.org", <fun>)

Les Fonctions

# String.length "OCaml" ;;
- : int = 5

# open String ;;
# length "OCaml" ;;
- : int = 5

# String.length ;;
- : string -> int = <fun>

[guest@localhost ˜]$ ocaml
        OCaml version 4.11.1
 
# float_of_int ;;
- : int -> float = <fun>
 
# int_of_char ;;
- : char -> int = <fun>
 
# print_string ;;
- : string -> unit = <fun>

# let step a = a + 2 ;;
val step : int -> int = <fun>

# step 6 ;;
- : int = 8

Condition if

# 2 > 3 ;;
- : bool = false

# if 2 > 3 then "first case" else "second case" ;;
- : string = "second case"

# let condition = (2 > 3) ;;
val condition : bool = false

# if condition
  then "la condition est vraie"
  else "la condition est fausse"
  ;;
- : string = "la condition est fausse"

# let lang = "OCaml" ;;
val lang : string = "OCaml"

# let my_item =
    if lang.[0] = 'O'
    then "Objective"
    else "Unknown"
  ;;
val my_item : string = "Objective"

# let comp a =
    if a = 4
    then "equal"
    else if a > 4
      then "sup"
      else "inf"
  ;;
val comp : int -> string = <fun>

# comp 6 ;;
- : string = "sup"

# let is_equal_to_5 this =
    if this = 5
    then print_endline "this is equal to 5"
  ;;
val is_equal_to_5 : int -> unit = <fun>

# is_equal_to_5  3 ;;
- : unit = ()

# is_equal_to_5  5 ;;
this is equal to 5
- : unit = ()

Les Boucles

Boucle for

# for var = 2 to 6 do
    print_endline ("var value is " ^ (string_of_int var))
  done
  ;;
var value is 2
var value is 3
var value is 4
var value is 5
var value is 6
- : unit = ()

# for var = 2 to 6 do
    print_string "var value is " ;
    print_int var ;
    print_newline ()
  done
  ;;
var value is 2
var value is 3
var value is 4
var value is 5
var value is 6
- : unit = ()

Les Boucles avec des Fonctions

# let rec loop a =
    print_int a;
    print_newline ();
    if a > 0 then
      loop (a - 1)
  ;;
val loop : int -> unit = <fun>

# loop 5 ;;
5
4
3
2
1
0
- : unit = ()

match

# let v = 2 ;;
val v : int = 2

# match v with
  | 1 -> "un"
  | 2 -> "deux"
  | 3 -> "trois"
  | _ -> "je ne sais pas compter au delà de trois"
  ;;
- : string = "deux"

# let li = [ 2; 8; 5; 11; 32 ] ;;
val li : int list = [2; 8; 5; 11; 32]

# match li with
  | head :: tail -> tail
  | [] -> []
  ;;
- : int list = [8; 5; 11; 32]
(* Dans le jargon, on désigne le premier élément d'une liste comme
   sa tête (head en anglais), et le reste comme sa suite (tail).
   Ici l'expression renvoie la suite de la liste nommée « li ». *)

# match li with
  | head :: tail ->
      print_string "the head is ";
      print_int head;
      print_newline ();
  | [] ->
      print_endline "the list is empty";
  ;;
the head is 2
- : unit = ()

# let li = [2; 3; 5; 7] in
  let rec loop li =
    match li with
    | head :: tail ->
        print_int head;
        print_newline ();
        loop tail;
    | [] ->
        print_endline "End Of List";
  in
  loop li
  ;;
2
3
5
7
End Of List
- : unit = ()

"Foreach"

(Iteration sur les listes et les tableaux)

# let for_each item = item * 2 ;;
val for_each : int -> int = <fun>

# let my_list = [ 5; 1; 22; 3; 16 ] ;;
val my_list : int list = [5; 1; 22; 3; 16]

# List.map  for_each  my_list ;;
- : int list = [10; 2; 44; 6; 32]

# let each item =
    item + 4
  in
  List.map each [10; 50; 30; 80; 20]
  ;;
- : int list = [14; 54; 34; 84; 24]

# each ;;
Unbound value each

# List.iter
    (fun i -> print_int i ; print_newline ())
    [ 8; 64; 2; 16 ]
  ;;
8
64
2
16
- : unit = ()

# let high_level_languages = [
    "Lisp";
    "Perl";
    "Python";
    "PHP";
    "Ruby";
    "OCaml"
  ] in
  List.iter (fun lang -> print_endline lang) high_level_languages
  ;;
Lisp
Perl
Python
PHP
Ruby
OCaml
- : unit = ()

Les Enregistrements

# type personne = { nom: string; telephone: string; } ;;
type personne = { nom : string; telephone : string; }

# let doe = {
    nom = "Doe";
    telephone = "02.30.54.29";
} ;;
val doe : personne = {nom = "Doe"; telephone = "02.30.54.29"; }

# doe.telephone ;;
- : string = "02.30.54.29"

Les Enregistrements : Mise à Jour Immuable

# let doe = { doe with telephone = "02.74.16.48" } ;;
val doe : personne = {nom = "Doe"; telephone = "02.74.16.48"}

Les structures mutables

# type personne = { nom : string; mutable age : int } ;;
type personne = { nom : string; mutable age : int; }
(* permettra de modifier le champ age, mais pas le champ nom. *)

# let p = { nom = "Paul"; age = 23 } ;;
val p : personne = {nom = "Paul"; age = 23}

# let anniversaire x = x.age <- x.age + 1 ;;
val anniversaire : personne -> unit = <fun>

# anniversaire p ;;
- : unit = ()

# p ;;
- : personne = {nom = "Paul"; age = 24}

# p.nom <- "Maximilien";;
Error: The record field nom is not mutable

Les Variants

# type shape = Square | Circle | Triangle ;;
type shape = Square | Circle | Triangle

# let string_of_shape sh =
    match sh with
    | Square   -> "square"
    | Triangle -> "triangle"
    | Circle   -> "circle"
  ;;
val string_of_shape : shape -> string = <fun>

# string_of_shape Square ;;
- : string = "square"

Les Variants avec arguments

(* Définition du type shape avec un variant pour représenter différentes formes géométriques *)
type shape =
  | Square of float            (* carré avec un côté *)
  | Triangle of float * float  (* triangle avec une largeur et une hauteur *)
  | Circle of float            (* cercle avec un rayon *)

(* Exemples de formes géométriques *)
let square = Square 5.0
let triangle = Triangle (4.0, 6.0)
let circle = Circle 3.0

Mise en garde contre les tableaux

# let arr = [| 1; 2; 3; 4; 5 |] ;;
val arr : int array = [|1; 2; 3; 4; 5|]

# let modif i v =
    arr.(i) <- v;
  ;;
val modif : int -> int -> unit = <fun>

# modif 2 1024 ;;
- : unit = ()

# arr ;;
- : int array = [|1; 2; 1024; 4; 5|]

Les chaînes de caractères

# let str = "OCaml" ;;
val str : string = "OCaml"

# let modif str i c =
    str.[i] <- c;
  ;;
val modif : string -> int -> char -> unit = <fun>

# modif str 1 'k' ;;
- : unit = ()

# str ;;
- : string = "Okaml"

# let s = Bytes.of_string "Hello" ;;
val s : bytes = Bytes.of_string "Hello"

# Bytes.set s 4 'a' ;;
- : unit = ()

# s ;;
- : bytes = Bytes.of_string "Hella"

Récursivité Terminale

# let rec add x =
    if x <= 0
    then 0
    else x + add (x - 1)
  ;;
val add : int -> int = <fun>

#  add 10 ;;
- : int = 55

# add 100 ;;
- : int = 5050

# add 10_000 ;;
- : int = 50005000

# add 100_000 ;;
Stack overflow during evaluation (looping recursion?).

# let addt x =
    let rec aux x acc =
      if x <= 0
      then acc
      else aux (x - 1) (x + acc)
    in
    aux x 0
  ;;
val addt : int -> int = <fun>

# addt 100_000 ;;
- : int = 5000050000

# let rec up_to m n =
    if m > n
      then up_to n m
      else if m = n
        then [m]
        else m :: up_to (m+1) n
    ;;
val up_to : int -> int -> int list = <fun>

# up_to 4 12;;
- : int list = [4; 5; 6; 7; 8; 9; 10; 11; 12]

# let up_to m n =
  let rec aux m n acc =
    if m > n
    then acc
    else aux m (n-1) (n::acc)
  in
  if m > n
  then aux n m []
  else aux m n []
  ;;
val up_to : int -> int -> int list = <fun>

# up_to 4 12 ;;
- : int list = [4; 5; 6; 7; 8; 9; 10; 11; 12]

Script et exécutables

print_endline "Hello World!" ;;

ocaml hello.ml

#!/usr/bin/env ocaml

chmod a+x hello.ml

./hello.ml

ocamlc  hello.ml  -o hello.byte
./hello.byte

ocamlopt  hello.ml  -o hello
./hello

ocamlopt  hello.ml  -o hello.exe
./hello.exe

Main

Point d'entrée du programme

let fib n =
  let rec aux a b acc =
    if a > n then (List.rev acc)
    else aux b (a+b) (a::acc)
  in
  aux 0 1 []

let () =
  let n = int_of_string Sys.argv.(1) in
  let li = fib n in
  let s = String.concat " " (List.map string_of_int li) in
  print_endline s;
;;

$ ocaml fib.ml 1000
 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

Les Exceptions

let () =
  let n =
    try int_of_string Sys.argv.(1)
    with _ -> 100
  in
  let li = fib n in
  let s = String.concat " " (List.map string_of_int li) in
  print_endline s;
;;

let () =
  let n =
    try int_of_string Sys.argv.(1)
    with
    | Invalid_argument _ -> 100    (* default value *)
    | Failure _ ->    (* exit with an error message *)
        prerr_endline "please provide an integer";
        exit 1
  in

Aller plus loin

Notice d'utilisation