Cours 2 : Symboles, valeurs et fonctions

Symboles et valeurs

# 2;;
- : int = 2
# 2+3;;
- : int = 5
# "toto";;
- : string = "toto"
# "toto"^"titi";;
- : string = "tototiti"

A ne pas confondre...

2;;
2.0;;
'2';;
"2";;

... attention aux lettres et aux mots !

'a';;
"a";;
a;;
let a = "b";;
a;;
gentil;;
let gentil = "mechant";;
gentil;;
let gentil = "pas " ^ gentil;;
gentil;;
let pi = 3.141592645;;

Définitions temporaires :

let pi2 = pi *. pi
in
  (pi2 +. 1.0) /. (pi2 -. 1.0);;
pi2;;

Une bizarrerie qui nous sera utile :

# ();;
- : unit = ()

Le produit cartésien, c'est comme en math.

# (2,3);;
- : int * int = (2, 3)
# ("toto",3.0);;
- : string * float = ("toto", 3.)
# ((),'a',"toto",7.89);;
- : unit * char * string * float = ((), 'a', "toto", 7.89)
# ((2,3),("titi",4));;
- : (int * int) * (string * int) = ((2, 3), ("titi", 4))

Fonctions

Les fonctions sont des valeurs

Certaines fonctions sont déjà définies.

# string_of_int;;
- : int -> string = <fun>
# string_of_int 1432;;
- : string = "1432"

Mais l'idée bien sûr est d'en faire soi-même.

# function x -> x + 1;;
- : int -> int = <fun>
# (function x -> x + 1) 38;;
- : int = 39
# let f = function x -> x + 1;;
val f : int -> int = <fun>
# f 38;;
- : int = 39
# f 45;;
- : int = 46

Fermeture lexicale

let f = function x -> x + y;;
let y = 5;;
let f = function x -> x + y;;
f 3;;
let y = 10;;
f 3;;

Fonctions à plusieurs arguments

Ca n'existe pas en caml, ni en math. Mais...

let f = function x -> (function y -> x + y);;
f 3;;
(f 3) 5;;
f 3 5;;
let increment = f 1;;
increment 28;;
let plus =
  function x ->
  function y ->
    x + y;;

Notez que le type de la fonction est automatiquement inféré par caml.

Fonctions de fonctions

Les fonctions sont des valeurs comme les autres... on peut les passer en argument de fonctions.

let paire_successifs =
  function f ->
  function x ->
    ( (f x) + 1, f (x + 1) );;
paire_successifs (function x -> 3*x) 10;;

Mais l'inférence de type est bien plus puissante que l'on peut le penser.

let triplet_compose =
  function f ->
  function g ->
  function x ->
    (x, f x, g (f x));;

.. ou, pour éviter de calculer deux fois f x

let triplet_compose =
  function f ->
  function g ->
  function x ->
    let f_de_x = f x
    in
      (x, f_de_x, g f_de_x);;
triplet_compose string_of_int (function x -> "J'ai "^x^" ans.") 25;;