cours-2-2

Jean-Pierre Jacquot

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

Informations

• Publié par: Essa
• Nombre de lectures: 15
• Langue: Français

Extrait

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 ..." />

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 sig est 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.rationnel int*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: [| v 1 ; v 2 ; ...; v n |] crÈation : Array.make n v => [|v; v; ...; v|] accÈs ‡ un ÈlÈment : o˘ 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é