Semaine 1 — Premiers pas en Caml

photo en CC-By-Nc-Sa par Samira Mink

, par Pierre

Premières prise de contact avec le langage et le REPL. Typage. Types de base, listes, tuples, fonctions, correspondance de motifs (pattern-matching). Pour que les fonctions soient des objets de première classe il faut associer à chaque fonction non seulement son code mais aussi son contexte (sa clôture). Illustration de cette nécessité des clôtures par ce dont son absence nous prive, avec un exemple en langage C.

  1. (* Premier cours de caml *)
  2. (* ocaml + emacs + tuareg mode *)
  3.  
  4. (* operations sur les entiers *)
  5. 1 + 2;; (* taper ctrl-c ctrl-e pour evaluer dans le repl *)
  6. 1 - 2;;
  7. 1 / 2;;
  8. 1 * 2;;
  9.  
  10. (* sur les float *)
  11. 1. +. 2.;;
  12. 1. -. 2.;;
  13. 1. /. 2.;;
  14. 2. *. 3.;;
  15.  
  16. (* les noms *)
  17. let toto = 2 * 3;;
  18. let x = 5;;
  19. let y = x + 3;;
  20. let x = 4;;
  21. (* portee limitee des noms *)
  22. let x = 0 in x + 1;;
  23. x + 1;;
  24.  
  25. (* les fonctions *)
  26. let triple = function x -> 3 * x;;
  27. triple 2;;
  28. let quadruple x = 4 * x;;
  29. quadruple 1;;
  30. let addition x y = x + y;;
  31. let addition2 = function x -> function y -> x + y;;
  32. let addition3 = fun x y -> x + y;;
  33. let increment = function x -> x + 1;;
  34.  
  35. (* fonction qui retourne une fonction *)
  36. let increment2 = addition 1;;
  37. increment2 4;;
  38. (addition 3) 4;;
  39.  
  40. (* fonction qui prend en argument une fonction *)
  41. let appliquera2 = function f -> f 2;;
  42. let triple = function x -> 3 * x;;
  43. appliquera2 triple;;
  44. (* expression a valeur de fonction *)
  45. appliquera2 (function x -> x + 1);;
  46. (function x -> x + 1) 3;;
  47.  
  48. (* les listes et les tuples *)
  49. [3; 4];; (* liste de deux elements 3 et 4 *)
  50. [];; (* liste vide *)
  51. [1, 2];; (* erreur courante *)
  52. ("salut", 2, 1.1);; (* un tuple *)
  53. (* ["salut"; 2; 1.1];; (* une erreur *) *)
  54. 3::(4::(5::[]));; (* meme chose que [3; 4; 5] *)
  55.  
  56.  
  57. (* exercices : reimplementer la bibliotheque des listes *)
  58. let estVide = function [] -> true
  59. | _ -> false;;
  60.  
  61. estVide [];;
  62. estVide ["salut"];;
  63. exception ListeVide;;
  64. let tete = function [] -> raise ListeVide
  65. | x::xs -> x;;
  66. tete [];;
  67. tete ["salut"; "koly"];;
  68. let rec taille = function [] -> 0
  69. | x::xs -> 1 + taille(xs);;
  70. taille [];;
  71. taille [3; 2];;
  72. let queue = function [] -> raise ListeVide
  73. | x::xs -> xs;;
  74. queue [];;
  75. queue [1;2;3];;
  76.  
  77. let rec nieme = function
  78. (1, x::xs) -> x
  79. | (n, l) -> nieme (n-1, queue l);;
  80. nieme(2, [8; 800; 10; 80]);;
  81. nieme(0, [8; 800; 10; 80]);;
  82. nieme(10, [8; 800; 08; 80]);;
  83. nieme(10, []);;
  84.  
  85. let rec dernier = function
  86. [] -> raise ListeVide
  87. | x::[] -> x
  88. | x::xs -> dernier xs;;
  89. dernier ["salut"; "c'est toi"; "le"; "chat"];;
  90.  
  91. let rec renverser = function
  92. [] -> []
  93. | x::xs -> (renverser xs)@[x];;
  94.  
  95. (* @ effectue la concatenation on peut aussi definir la concatenation *)
  96. renverser ["bien"; "trop"; "c'est"];;
  97.  
  98. let rec concatener = function
  99. ([], l) -> l
  100. | (x::xs, l) -> x::concatener(xs, l) ;;
  101.  
  102. #trace concatener;;
  103. concatener ([1; 2], [3]);;
  104. concatener ([], []);;
  105.  
  106. (*
  107. definir la fonction map.
  108. Exemple map f [a; b; c; d] = [f a; f b; f c; f d]
  109. *)
  110. let rec map = function (f, []) -> []
  111. | (f, x::xs) -> f x :: map(f, xs);;
  112.  
  113. let successeur = function x -> x + 1;;
  114. map (successeur, [1; 3; 5]);; (* [2; 4; 6] *)
  115. map (successeur, []);; (* [] *)
  116. map (estVide, [[]; [3; 4]]);; (* [true; false] *)

Télécharger

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3.  
  4.  
  5. /* type des fonction N -> N */
  6. typedef int (*nat2nat) (int);
  7.  
  8. /* quelques fonctions N -> N */
  9. int triple(int x) {
  10. return 3*x;
  11. }
  12. int successeur(int x) {
  13. return x + 1;
  14. }
  15.  
  16. /* fonction passee en parametre OK */
  17. int appliquera2(nat2nat f) {
  18. return f(2);
  19. }
  20.  
  21. /* fonction comme valeur de retour: FAIL */
  22. nat2nat ajouteur(int n) {
  23. /* s'il y avait des clotures n serait alloue sur le tas et non
  24.   (seulement) sur la pile pour survivre a l'invalidation du cadre
  25.   courant */
  26. int f(int x) {
  27. return x + n;
  28. }
  29. return f;
  30. }
  31.  
  32. void garbage() {
  33. int t[1024];
  34. int i;
  35. for (i = 0; i < 1024; i += 1) {
  36. t[i] = 0;
  37. }
  38. }
  39.  
  40. int main() {
  41. nat2nat f;
  42.  
  43. f = ajouteur(100);
  44. garbage(); /* ecrase les anciens cadres sur la pile */
  45. printf("%d\n", f(2));
  46.  
  47. return EXIT_SUCCESS;
  48. }

Télécharger

Revenu et logement, Je livre ici quelques éléments de comparaison concernant mon niveau de vie, pour couper court à quelques idées reçues, et un condensé de nombreuses (...)
Revenu et travail d’un enseignant-chercheur, Cet article complète l'article Revenu et logement, en détaillant un peu le budget de mon ménage, mon parcours d'enseignant-chercheur en terme de (...)
Cybersyn (el systemo synco), Au café, mardi 5 avril 2011, j'ai bien vu que, mis à part Antoine Allombert, personne ne connaissait l'histoire de l'extraordinaire projet chilien (...) [jpg, jpg, png]