Notice d'utilisation

Introduction about OCaml

• The interactive loop
• Basic Types
• Transtyping
• Arrays
• Lists
• Tuples
• Functions
• Conditions with "if"
• The for loop
• Making loops with functions
• Filtering with the match construct
• Iterating Lists and Arrays
• Using Records
• Imutable updates for Records
• Variants
• Warning about arrays
• Terminal recursion
• Scripts and binaries
• Going further

Different Execution modes

• Binaries, compiled to natif code
  (similar than with the C programing language and with similar performences)
• With Bytecodes that you run with a virtual machine
  (like Java and with equivalent performences)
• As a script
  (like Python, Perl, Ruby or PHP, you will have similar fun)
• With the Interactive loop, for real-time interaction with the user, also called the "toplevel"
  (similar than the 'python3' command)

Different Programming Styles

The interactive loop

[guest@localhost ˜]$ ocaml
        OCaml version 4.12.2

#

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

#

Basic Types

# 4 ;;

- : int = 4

# 8.6 ;;
- : float = 8.6

# 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 = ()

Transtyping

# 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_of_int 9) /. 1.2 ;;
- : float = 7.5

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

# my_item ;;
- : int = 128

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

Arrays

# [| '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

Lists

# [ 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 = []

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>)

Functions

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

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

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

# 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 = ()

Loops

For loops

# 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 = ()

Loops with functions

# 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 var = 2 ;;
val var : int = 2

# match var 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";
    "Nim"
  ] in
  List.iter (fun lang -> print_endline lang) high_level_languages
  ;;
LISP
Perl
Python
PHP
Ruby
OCaml
Nim
- : unit = ()

Using Records

# type person = { name: string; telephone: string; } ;;
type person = { name : string; telephone : string; }

# let doe = {
    name = "Doe";
    telephone = "FD.CE.AF";
} ;;
val doe : person = {name = "Doe"; telephone = "FD.CE.AF"; }

# doe.telephone ;;
- : string = "FD.CE.AF"

Les Enregistrements : Mise à Jour Immuable

# let doe = { doe with telephone = "C85.5C8" } ;;
val doe : person = {nom = "Doe"; telephone = "C85.5C8"}

Les Variants

# type chocolat = Chocolat_noir | Chocolat_blanc | Chocolat_au_lait ;;
type chocolat = Chocolat_noir | Chocolat_blanc | Chocolat_au_lait

# let quoi_en_faire tablette =
    match tablette with
    | Chocolat_noir    -> "Je le mange goulûment !"
    | Chocolat_au_lait -> "Je le refile à ma petite soeur."
    | Chocolat_blanc   -> "Je le refile à mon voisin..."
  ;;
val quoi_en_faire : chocolat -> string = <fun>

# quoi_en_faire Chocolat_noir ;;
- : string = "Je le mange goulûment !"

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|]

# 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"

Terminal Recursion

# 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 = 705082704

# 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.bin
./hello.bin

ocamlopt  hello.ml  -o hello
./hello

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

Aller plus loin