cours-2-2
12 pages
Français

cours-2-2

-

Le téléchargement nécessite un accès à la bibliothèque YouScribe
Tout savoir sur nos offres

Description

Modules - Mutabilité 1Module : définitionModule =Mécanisme de structuration qui permet de regrouper sous une même dénomination et en un même lieu des définitions ayant une forte corrélation logique.un module permet – de rassembler des types et des fonctions associés à une fonctionnalité donnée.– de favoriser la réutilisation de types et de fonctions.– de développer de manière incrémentale une solution à un problème donné.Tous les "grands" langages de programmation ont une notion de moduleDEUG 2 2000Modules - Mutabilité 2Utilité des modulesLes modules sont une réponse à trois questions :Comment gérer la multiplication des noms ?Peut-on utiliser un même nom pour des notions différentes ?Peut-on programmer à plusieurs un logiciel ?Comment améliorer la sécurité de la programmation ?Peut-on interdire l'utilisation de fonctions "dangereuses" ?Peut-on garantir que les valeurs sont correctes vis-à-vis de la modélisation ?Peut-on étendre le système de types ?Comment diffuser des composants logiciels ?Les questions sont techniques, mais la réponse est fondamentale !DEUG 2 2000Page 1Modules - Mutabilité 3Modules : notationsyntaxe Ocaml Nom du modulemodule Triplets =struct let fst = function (x, y, z) -> x Définitions let snd = function (x, y, z) -> y OCaml let thrd = function (x, y, z) -> zend;;DEUG 2 2000Modules - Mutabilité 4La question des nomsLes modules structurent l'espace des noms selon deux modalités– la portée : le texte ...

Sujets

Informations

Publié par
Nombre de lectures 15
Langue Français

Exrait

Modules - Mutabilité Module : définition
1
Module = MÈcanisme de structuration qui permet de regrouper sous une mÍme dÈnomination et en un mÍme lieu des dÈfinitions ayant une forte corrÈlation logique.
un module permet Ð de rassembler des types et des fonctions associÈs ‡ une fonctionnalitÈ donnÈe. Ð de favoriser la rÈutilisation de types et de fonctions. Ð de dÈvelopper de maniËre incrÈmentale une solution ‡ un problËme donnÈ. Tous les "grands" langages de programmation ont une notion de module
DEUG 2
Modules - Mutabilité Utilité des modules
2000
2
Les modules sont une rÈponse ‡ trois questions : Comment gÈrer la multiplication des noms ? Peut-on utiliser un mÍme nom pour des notions diffÈrentes ? Peut-on programmer ‡ plusieurs un logiciel ?
Comment amÈliorer la sÈcuritÈ de la programmation ? Peut-on interdire l'utilisation de fonctions "dangereuses" ? Peut-on garantir que les valeurs sont correctes vis-‡-vis de la modÈlisation ? Peut-on Ètendre le systËme de types ?
Comment diffuser des composants logiciels ? Les questions sont techniques, mais la rÈponse est fondamentale ! DEUG 2 2000
Page 1
Modules - Mutabilité Modules : notation
syntaxe Ocaml
DEUG 2
module Triplets =
struct
Nom du module
 let fst = function (x, y, z) -> x  let snd = function (x, y, z) -> y  let thrd = function (x, y, z) -> z
end;;
Modules - Mutabilité La question des noms
Les modules structurent l'espace des noms selon deux modalitÈs
Ð la portÈe : le texte dans lequel un nom est dÈfini un module dÈfinit un espacelocalentre et struct end les rËgles usuelles s'appliquent (liaison avant utilisation)
Ð la visibilitÈ : le droit (ou non) d'utiliser un nom
3
DÈfinitions OCaml
2000
4
Ces deux modalitÈs sont liÈes mais trËs diffÈrentes : ª la portÈe est un mÈcanisme associÈ aux rËgles d'exÈcution ª la visibilitÈ est un outil de programmation qui permet de protÈger le programmeur
DEUG 2
Page 2
2000
Modules - Mutabilité Qu’est-ce qu’un nom ?
5
Nom complet = la composition dÕun chemin et dÕun identificateur un chemin est une suite de noms de modules <nom_module>.<nom_module>.<identificateur> List.hd, Triplets.fst, etc.
Petit nom = forme abrÈgÈe du nom complet qui consiste en un simple identificateur
Les petits noms permettent de faciliter lÕÈcriture (et la lecture) des programmes On accËde aux petits noms par open NomModule;; DEUG 2 2000
Modules - Mutabilité Interface et Implantation
6
Objet technique = un service et la faÁon d'accÈder (ou de commander) ‡ ce service Plus l'objet devient complexe, plus il est nÈcessaire de sÈparer l'implantation: la faÁon dont le service est rÈalisÈ elle n'a pas besoin d'Ítre connue, sauf des spÈcialistes ! l'interface: les liens avec l'extÈrieur
moteur de voiture distributeur de boissons implantation : mÈcanique complexe implantation : ???????? interface : accÈlÈrateur, compte-tour interface : boutons de sÈlection, monnayeur,  rÈceptacle module List implantation : ?????? interface : hd, for_all, @, etc. Cette sÈparation est un des fondements de l'ingÈnierie
DEUG 2
Page 3
2000
Modules - Mutabilité Signature : définition
7
signature = un ensemble de types et de profils formant l'interface d'un module
signature du module Triplets
sig  val fst : 'a * 'b * 'c -> 'a  val snd : 'a * 'b * 'c -> 'b  val thrd : 'a * 'b * 'c -> 'c  end
La signature d'un module est l'Èquivalent du type d'une expression OCaml calcule la signature lors d'une dÈfinition de module
DEUG 2
Modules - Mutabilité Signature : notation
2000
8
il est possible de dÈfinir une signature indÈpendemment d'un module
syntaxe OCaml
DEUG 2
module type TRIPLETS =
sig
nom de la signature
 val fst : 'a * 'b * 'c -> 'a  val snd : 'a * 'b * 'c -> 'b  val thrd : 'a * 'b * 'c -> 'c
end ;;
Noter le val !
Page 4
2000
Modules - Mutabilité
Signature : usage
9
Les signatures permettent de contrÙler l'interface des modules ª masquage des types ª masquage des noms
Principe : ce qui n'est pas inclus dans l'interface n'est pas visible de l'extÈrieur ! module B = (A:S)
module A
struct type t1 = .... let f = function ... let g = function ..
end
DEUG 2
module type S
sig type t1 val f: t1 -> t2 end
t1 visible, mais sans savoir  ce qu'il est !
Modules - Mutabilité A quoi ça sert ?
exemple des nombres rationnels
f visible
2000
10
module Rationnels = struct  type rationnel = int*int  let rec pgcd = ... (* calcul du pgcd *)  let normalise =... (* calcule la fraction rÈduite *)  let ((+): rationnel -> rationnel -> rationnel) =  function (p1, q1) -> function (p2, q2) -> normalise ((p1*q2+p2*q1), (q1*q2))
 and (( *): rationnel -> rationnel -> rationnel) =  function (p1, q1) -> function (p2, q2) -> normalise ((p1*q2+p2*q1), (q1*q2))
and ((<): rationnel -> rationnel -> bool) =  function (p1, q1) -> function (p2, q2) -> (p1*q2) < (p2*q1) end;; DEUG 2
Page 5
2000
Modules - Mutabilité
Exemple
open Rationnels;; # (1, 2) + (1, 4);; - : Rationnels.rationnel = 3, 4 # (1,2) < (1,3);; - : bool = false
# (1,-2) < (1,3);; - : bool = false
DEUG 2
Que se passe-t-il ?
AIE !!!
Tout va bien
Modules - Mutabilité Invariant de représentation
11
2000
12
est une modÈlisation imparfaite des rationnels int*int il faut uninvariant de reprÈsentation: des conventions qui ª donnent la reprÈsentation canonique des valeurs modÈlisÈes ª garantissent que les fonctions calculent un rÈsultat correctssil'invariant est respectÈ invariant de Rationnel : (p, q) modÈlise un rationnel si et seulement si ª p/q est une fraction rÈduite ª q est strictement positif (1, -2) n'est donc pas un modËle pour -1/2, il ne devrait donc pas Ítre utilisÈ comme argument de (<) !
DEUG 2
Comment garantir le respect de l'invariant ?
Page 6
2000
Modules - Mutabilité 13 Module = implantation + interface module RatImplantation = struct  type rationnel = int*int  let rec pgcd = ... (* calcul du pgcd *)  let normalise =... (* calcule la fraction rÈduite *)  let ((+): rationnel -> rationnel -> rationnel) = ... fonctions de conversion  and (( *): rationnel -> rationnel -> rationnel) = ... int*int en rationnel  and ((<): rationnel -> rationnel -> bool) = ... let (de_couple: int*int -> rationnel) = function c -> normalise c let (vers_couple: rationnel -> int*int) = function c -> c end;; module type RatInterface =la reprÈsentation sigest cachÈe  type rationnel val (+): rationnel -> rationnel -> rationnel  val ( *): rationnel -> rationnel -> rationnel) val (<): rationnel -> rationnel -> bool val de_couple: int*int -> rationnel val vers_couple: rationnel -> int*int end;; DEUG 2 2000
Modules - Mutabilité Ça marche !
14
# module Rationnels = (RatImplantation:RatInterface);;
# open Rationnels;; # (1,2) < (1,3);; This expression has type int * int but is here used with type  Rationnels.rationnelint*int n'est pas un rationnel !
# de_couple (1, -2);; - : Rationnels.rationnel = <abstr>
# vers_couple (de_couple (1, -2));; - : int * int = -1, 2
la reprÈsentation des rationnels est cachÈe
# (de_couple (1, -2)) < (de_couple (1,3));; - : bool = true DEUG 2
Page 7
rÈsultat correct
2000
Modules - Mutabilité Mutabilité : définition
15
¥ Objet mutable = Liaison (nom, valeur) dont la partie valeur peut varier au cours du calcul ¥ Exemple : Ð lÕ‚ge dÕune personne Ð lÕheure affichÈe sur une montre digitale
¥ ModËle simple id val Ð liaison simple : (nom, valeur) nom est Èquivalent ‡ la valeur id val Ð objet mutable : (nom, boÓte) nom est Èquivalent aucontenu de la boÓte ˆ cet instant
DEUG 2
Modules - Mutabilité Notations Caml
2000
16
Trois grandes catÈgories dÕobjets mutables les produits cartÈsiens ‡ champs nommÈs (enregistrements) t t crÈation : type MutE =1 ( {fixe: ; mutable mut: } type personne = {nom: string; mutable age: int} modification : <-let anniversaire = function pers ->  pers.age <- (pers.age + 1);;
DEUG 2
let moi = {nom=ÒJPJÓ; age = 1};; anniversaire moi;; moi;; anniversaire moi;; moi;;
Page 8
2000
Modules - Mutabilité Notations Caml
17
Les vecteurs (nommÈsArrayen OCaml) crÈation : syntaxe spÈciale: [| v1; v2; ...; vn|] crÈation : Array.make n v => [|v; v; ...; v|] accÈs ‡ un ÈlÈment : t.(n) £ £ 0 n (Array.length t) -1 modification : t.(n) <- nouveau_v
Les rÈfÈrences crÈation : let nom = ref v;; accËs : !nom modification : nom := nouveau_v
DEUG 2
Modules - Mutabilité Qu’apporte la mutabilité ?
2000
18
des ennuis ! Les programmes ne sont plusrÈfÈrentiellement transparents,cÕest-‡-dire quÕil nÕest plus possible de dire quelle est la valeur associÈe ‡ un nomlors de la lecturedu programme. LÕinconvÈnient majeur est quÕil devient plus difficile de prouver les programmes et, souvent, de les mettre au point quelques avantages tout de mÍme CÕest un modËle naturel pour certains objets : une personne possËde des caractËres fixes (nom, Numero INSEE, etc.) et des caractËres variables (‚ge, taille, poids, adresse, etc.) Les calculspeuventÍtre plus efficaces, en particulier lorsque le problËme ‡ traiter se modÈlise avec des Ètats et des opÈrations qui font changer dÕÈtat.
DEUG 2
Page 9
2000
Modules - Mutabilité Classes de langages
langage fonctionnel == langage dans lequel la mutabilitÈ est annexe tranparence rÈfÈrentielle meilleures propriÈtÈs mathÈmatiques => Ècriture des algorithmes plus simple
19
langage impÈratif == langage dont le modËle de calcul repose sur la mutabilitÈ pas de transparence rÈfÈrentielle => le temps joue un rÙle pour comprendre un calcul propriÈtÈs mathÈmatiques plus difficiles ‡ Ètablir meilleure efficacitÈ du calcul au prix dÕune bien plus grande complexitÈ de programmation
DEUG 2
Modules - Mutabilité Mutabilité et typage
2000
20
RËgle Caml : toute expression dÈfinit un calcul, qui produit une valeur, qui doit Ítre dÕun certain type id := !id + 1;; Calment.Age <- 120;; print_string ÒbonjourÓ;;
problËme : quel est le type dÕun calcul quimodifie?un Ètat RÈponse Caml : le type unit une seule valeur, notÈe () utilisable comme tous les autres types trËs utile pour les fonctions constantes ou celles qui lisent des pÈriphÈriques RËgle :toute expression qui modifie un Ètat retourne la valeur () de type unit
DEUG 2
Page 10
2000
Page 11
2000
DEUG 2
Modules - Mutabilité Exemple d’utilisation
Pile
pop
push
2000
DEUG 2
22
21
endroit sur lequel on pose et retire des objets (assiettes par exemple) la gestion des objets obÈit ‡ une politique prÈcise on pose au dessus on retire uniquement lÕobjet du dessus ou Dernier arrivÈ, premier servi (LIFO)
Soit ‡ dÈfinir une fonction ÒcalculatriceÓ qui calcule une expression donnÈe sous forme postfixÈe (‡ la HP) EntrÈe = [Ò12Ó; Ò132Ó; Ò+Ó; Ó1Ó; Ò2Ó; Ò+Ó; Ò/Ó] (exemple) Sortie = 48 IdÈe dÕalgorithme un nombre = argument dÕun futur opÈrateur => le stocker un opÈrateur = rÈcupÈrer les deux derniers arguments, faire lÕopÈration et stocker le rÈsultat (futur argument) a la fin, le dernier nombre stockÈ est le rÈsultat Il faut une structure pour stocker : une pile
Modules - Mutabilité