ML è un linguaggio interattivo La modalità interattiva di OCaml Ciclo: LETTURA, VALUTAZIONE, STAMPA. Objective Caml version 3.06

Transcript

1 1 ML è un linguaggio interattivo La modalità interattiva di OCaml Ciclo: LETTURA, VALUTAZIONE, STAMPA # Objective Caml version 3.06 Il cancelletto è il prompt di Caml. # 3*8;; - : int = 24 LETTURA: viene letta un espressione (3*8), terminata da ;; e dalla pressione del tasto di ritorno carrello (ENTER) VALUTAZIONE: viene calcolato il valore dell espressione STAMPA: viene stampato il valore dell espressione, specificando di che tipo è: - : int il valore è di tipo int (intero) = 24 il valore è 24 # <ESPRESSIONE> ;; - : <TIPO> = <VALORE>

2 2 Il calcolo procede valutando espressioni. OGNI ESPRESSIONE DEL LINGUAGGIO HA UN VALORE E UN TIPO Quando si immette un espressione al prompt di OCaml (seguita da ;; e <ENTER>), OCaml ne calcola e stampa il valore e il tipo. # (5/2, 5 mod 2);; - : int * int = (2, 1) # if not(3>0) then "pippo" else "pluto";; - : string = "pluto" /, mod, not sono FUNZIONI PRIMITIVE del linguaggio int * int è il tipo delle coppie di interi if...then...else... è un espressione condizionale; if, then, else sono PAROLE CHIAVE "pippo", "pluto" sono stringhe

3 3 L ambiente di valutazione La valutazione di un espressione avviene in un AMBIENTE che contiene il significato (VALORE) di un insieme di parole (VARIABILI). Quando si avvia l interprete OCaml, le espressioni vengono valutate nell ambiente predefinito, che contiene il significato delle operazioni primitive del linguaggio. # succ;; - : int -> int = <fun> # succ 4;; - : int = 5 # abs;; - : int -> int = <fun> # abs (-3);; - : int = 3 # fst;; - : a * b -> a = <fun> # fst (3,"pippo");; - : int = 3

4 4 Un programma è una collezione di dichiarazioni (di variabili, funzioni, tipi,...) L ambiente può essere esteso mediante # let three = 3;; val three : int = 3 # three * 8;; - : int = 24 DICHIARAZIONI Una dichiarazione dà un nome a un valore I nomi dei valori si chiamano VARIABILI # let base = 3;; val base : int = 3 # let altezza = 4;; val altezza : int = 4 # let area = base * altezza;; val area : int = 12 let <VARIABILE> = <ESPRESSIONE>;;

5 5 DICHIARAZIONI # let pi = ;; val pi : float = float: tipo dei numeri reali (IR) # let r = 2.0;; val r : float = 2. NELLE ESPRESSIONI: # let area = pi *. r *. r;; val area : float = *. moltiplicazione sui reali Il tipo degli operandi deve essere consistente con quello richiesto dagli operatori, senza eccezioni. Caml distingue le operazioni sugli interi * + / - dalle corrispondenti operazioni sui reali (float) *. +. /. -. # let area = pi * r * r;; Characters 11-13: let area = pi * r * r;; ^^ This expression has type float but is here used with type int

6 DICHIARAZIONE DI FUNZIONI let <NOME-FUNZIONE> = function <PARAMETRO-FORMALE> -> <ESPRESSIONE>;; # let area_quadrato = function n -> n * n;; val area_quadrato : int -> int = <fun> area_quadrato è una funzione da interi a interi. Applicata a un intero n, riporta l area del quadrato con lato di lunghezza n ATTENZIONE: il valore di una funzione non è stampabile. OCaml informa soltanto che si tratta di una funzione (<fun>) ML ha un meccanismo di inferenza di tipi che gli consente di dedurre qual è il tipo di un espressione senza bisogno di dichiarazioni esplicite # let area_quadrato = function n -> n * n;; val area_quadrato : int -> int = <fun> ML ha dedotto il tipo della funzione: Se n viene moltiplicato per sé stesso mediante la moltiplicazione tra interi (*), deve essere n: int. Quindi il dominio di area_quadrato è int. Il valore della funzione, n*n, è di tipo int. Quindi il codominio di area_quadrato è int. 6

7 7 Dichiarazione di funzioni: sintassi alternativa La funzione area_quadrato si può definire anche così: # let area_quadrato n = n * n;; val area_quadrato : int -> int = <fun> let <NOME-FUNZIONE> <PARAMETRO-FORMALE> = <ESPRESSIONE> Definizione di una funzione che calcola il doppio di un intero: # let double x = 2 * x;; val double : int -> int = <fun> ML ha dedotto il tipo della funzione: Se x viene moltiplicato per 2 (con la moltiplicazione tra interi), deve essere x: int. Quindi il dominio di double è int. Il valore della funzione, x*2, è di tipo int. Quindi il codominio di double è int.

8 8 La principale modalità di calcolo è l applicazione di funzioni Applicazione di funzioni Quando una funzione è stata dichiarata, si può utilizzare il suo nome nelle espressioni, in particolare per applicarle a un argomento: # area_quadrato 5;; - : int = 25 # double 3;; - : int = 6 Esempio # let area r = pi *. r *. r;; val area : float -> float = <fun> # area 3.0;; - : float = # let square r = r *. r;; val square : float -> float = <fun> # area (square 3.0);; - : float = L espressione area (square 3.0) è corretta: square: float -> float square 3.0: float area: float -> float, quindi area si può applicare a square 3.0

9 ATTENZIONE: l applicazione di funzioni è associativa a sinistra In mancanza di parentesi area square 3.0 viene interpretato come (area square) 3.0, che non è un espressione corretta: square: area: float -> float float -> float, quindi area non si può applicare a square se anche area square fosse corretto, il suo tipo sarebbe float, che non è il tipo di una funzione, quindi non si può applicare a 3.0 # area square 3.0;; Characters 0-4: area square 3.0;; ^^^^ This function is applied to too many arguments 9

10 10 ML ha un meccanismo di inferenza di tipi che gli consente di dedurre qual è il tipo di un espressione senza bisogno di dichiarazioni esplicite Inferenza dei tipi Quando si immette un espressione o una dichiarazione: OCaml ne controlla la correttezza: un espressione è corretta se è possibile determinarne il tipo. Ne determina il tipo, mediante un processo di inferenza dei tipi. Se si tratta di un espressione, ne calcola il valore e lo stampa. Il valore viene calcolato nell ambiente di valutazione attuale. Se si tratta di una dichiarazione, estende l ambiente di valutazione creando un nuovo legame per la variabile dichiarata.

11 11 Il calcolo procede valutando espressioni. Non ci sono effetti collaterali AMBIENTE DI VALUTAZIONE Un ambiente è una collezione di legami variabile-valore: var n val n Ambiente di top level (iniziale): var n 1 val n var 1 val not function x mod function x function y Ambiente del modulo Pervasives

12 12 Estensione dell ambiente mediante dichiarazioni La valutazione di una dichiarazione aggiunge un nuovo legame all ambiente: # let two = 2;; val two : int = 2 # let three = two + 1;; val three : int = 3 two 2 ambiente del modulo P ervasives - Viene valutata l espressione two + 1 nell ambiente esistente, dove il valore di two è 2; - Viene creato un nuovo legame, di three con il valore di two + 1 three 3 two 2 ambiente del modulo P ervasives

13 L ambiente viene gestito come un PILA: i nuovi legami vengono aggiunti in alto e si cerca il valore delle variabili a partire dall alto. # let two = "due";; val two : string = "due" two "due" three 3 two 2 ambiente del modulo P ervasives In questo ambiente, il valore di two è "due": il nuovo legame nasconde il vecchio. 13

14 ML è un linguaggio a scopo statico: determina a tempo di compilazione il valore delle variabili in una dichiarazione. 14 # let six=6;; DICHIARAZIONE DI FUNZIONI six # let sixtimes n=six*n;; # let six=50;; # six;; - : int = 50 # sixtimes 3;; - : int = 18 sixtimes function n -> six * n six six 50 sixtimes function n -> six * n six Il valore di six nel corpo di sixtimes viene cercato NELL AMBIENTE DI DICHIARAZIONE di six, cioè nell ambiente in cui six è stata definita.

15 15 # let six="six";; # sixtimes 3;; - : int = 18 six "six" six 50 sixtimes function n -> six * n six OCaml è un LINGUAGGIO A SCOPO STATICO

16 16 CHIAMATA DI FUNZIONI # let six=6;; # let sixtimes = six * n;; # sixtimes (2+1);; sixtimes function n -> six * n six Quando viene chiamata la funzione sixtimes: - il suo argomento viene valutato nell ambiente; - viene creato un nuovo legame PROVVISORIO del parametro formale n con il valore dell argomento; - in questo nuovo ambiente viene valutato il corpo della funzione, six * n; - il legame provvisorio viene cancellato. sixtimes n n 3 sixtimes function n -> six * n six : int = 18 sixtimes function n -> six * n six

17 ML è un linguaggio fortemente tipato: ogni espressione in ML ha un tipo che può essere determinato a tempo di compilazione Espressioni e tipi semplici Un tipo è un insieme di valori Espressioni di tipo t: il cui valore è di tipo t int 0, - 23, 14,... Operazioni: +, -, *, /, mod, succ, pred float 0.01, 3.0, -4.0, 7E-5,... Operazioni: +., -., *., /., **, sqrt, sin,... bool true, false Operazioni booleane: not, &&, or # (true && not false) or false;; - : bool = true E è valutato solo se E && E E ha valore true E or E E ha valore false 17

18 18 string "pippo", "pluto", "12Ev",... Operazioni: (concatenazione) # "programmazione " ^ "funzionale";; - : string = "programmazione funzionale" # "ABCDEFG".[2];; - : char = C # string_of_int 45;; - : string = "45" char 'a', '9', ' ',... # Char.code A ;; - : int = 65 # Char.chr 65;; - : char = A unit ()

19 19 # 3*8 = 24;; - : bool = true # "pippo" = "pi" ^ "ppo";; - : bool = true # true = not true;; - : bool = false # true <> false;; - : bool = true Uguaglianza e disuguaglianza L uguaglianza non è definita sulle funzioni: # let double x = x*2;; val double : int -> int = <fun> # let treble x = x*3;; val treble : int -> int = <fun> # double = treble;; Exception: Invalid_argument "equal: functional value"

20 20 Operatori di confronto # 3*8 <= 30;; - : bool = true # 6.0 < 5.9;; - : bool = false # A >= B ;; - : bool = false # "abc" > "ABC";; - : bool = true # false < true;; - : bool = true

21 21 I tipi con uguaglianza L uguaglianza e gli operatori di confronto sono definiti su tutti i tipi di dati, tranne che sulle funzioni. # true <> false;; - : bool = true # 3*8 <= 30;; - : bool = true # false < true;; - : bool = true # "abc" > "ABC";; - : bool = true # let double x = x*2;; val double : int -> int = <fun> # let treble x = x*3;; val treble : int -> int = <fun> # double = treble;; Exception: Invalid_argument "equal: functional value"

22 22 Espressioni condizionali è un espressione condizionale se: E è di tipo bool F e G hanno lo stesso tipo if E then F else G ML è un linguaggio fortemente tipato: ogni espressione in ML ha un tipo che può essere determinato a tempo di compilazione Le espressioni hanno sempre un tipo e un valore: Il tipo di if E then F else G è il tipo di F e G Il suo valore è: il valore di F se E ha valore true il valore di G se E ha valore false È un espressione, non un costrutto di controllo La parte else non può mancare Nel valutare un espressione if E then F else G: se E è true, G non viene valutata se E è false, F non viene valutata

23 23 Operatori booleani e espressioni condizionali Un espressione della forma E && F E or F equivale a if E then F else false if E then true else F Come nella valutazione delle espressioni booleane, la valutazione delle espressioni condizionali è pigra : quando si valuta if E then F else G: viene valutata E; se il valore di E è true, allora viene valutata F e G non viene valutata; se il valore di E è false, allora viene valutata G e F non viene valutata.

24 24 Esempio: valutazione di un espressione condizionale # 4 + (if 1 < 0 then 3 * 8 else 5 / 2);; - : int = (if 1 < 0 then 3 * 8 else 5 / 2) ===> 4 + (if false then 3 * 8 else 5 / 2) ===> 4 + (5 / 2) ===> ===> 6 # let sign n = if n > 0 then 1 else if n = 0 then 0 else -1;; val sign : int -> int = <fun> # let sort (x,y) = if x<y then (x,y) else (y,x);; val sort : a * a -> a * a = <fun> # sort (5,2);; - : int * int = (2,5)

25 25 Coppie Coppie ordinate: (E,F) # (5,8);; - : int * int = (5, 8) # ("pippo",7);; - : string * int = ("pippo", 7) # (true,80);; - : bool * int = (true, 80) t 1 t 2 è il tipo delle coppie ordinate il cui primo elemento è di tipo t 1 ed il secondo di tipo t 2. t 1 t 2 è il prodotto cartesiano di t 1 e t 2 Attenzione: è un costruttore di tipo (un operazione su tipi): applicato a due tipi t 1 e t 2 costruisce il tipo delle coppie il cui primo elemento è di tipo t 1 ed il secondo di tipo t 2

26 26 Tuple Triple, quadruple o tuple di dimensione qualsiasi: # (true,5*4,"venti");; - : bool * int * string = (true, 20, "venti") # ((if 3<5 then "true" else "false"), 10.3, K, int_of_string "50");; - : string * float * char * int = ("true", 10.3, K, 50) Una tupla può essere elemento di una tupla: # (true,("pippo",98),4.0);; - : bool * (string * int) * float = (true, ("pippo", 98), 4) Attenzione: * non è associativo: ad esempio il tipo bool * (int * string) è diverso dal tipo (bool * int) * string Le funzioni sono oggetti di prima classe: possono essere componenti di una struttura dati, o costituire l argomento o il valore di altre funzioni. Una funzione può essere un elemento di una tupla: # (double,(true && not false, 6*5));; - : (int -> int) * (bool * int) = (<fun>, (true, 30))

27 27 Costruttori e Selettori di un tipo di dati Ogni tipo di dati è caratterizzato da un insieme di e un insieme di COSTRUTTORI (costanti + operazioni che costruiscono valori di quel tipo) SELETTORI (operazioni che selezionano componenti da un valore del tipo) Nel caso di tipi semplici (int, float, bool, string, char, unit), abbiamo soltanto costruttori: i costruttori di un tipo di dati semplici sono tutti i valori del tipo

28 28 Costruttori e Selettori del tipo coppia L insieme di parentesi e virgola (, ) è il costruttore per il tipo delle coppie Per selezionare i componenti: fst, snd (first, second) # let t = (true,("pippo",98));; val t : bool * (string * int) = true, ("pippo", 98) # fst t;; - : bool = true # snd t;; - : string * int = "pippo", 98 # snd (snd t);; - : int = 98 fst, snd sono funzioni polimorfe: # fst;; - : a * b -> a = <fun> # snd;; - : a * b -> b = <fun> OCaml utilizza espressioni della forma a, b, c per le variabili di tipo (α, β, γ).

29 29 Funzioni a più argomenti # let area_triangolo (base,altezza) = (base * altezza)/2;; val area_triangolo : int * int -> int = <fun> Qual è il tipo di area_triangolo? Per OCaml le funzioni hanno sempre un unico argomento; eventualmente una coppia o una tupla. let quorem (n,m) = (n/m, n mod m);; quorem : int * int -> int * int # quorem (17,5);; - : int * int = (3, 2)

30 30 ML ha un sistema di tipi polimorfo: una funzione può accettare argomenti di vari tipi. # let first (x,y) = x;; val first : a * b -> a = <fun> # let zero x = 0;; val zero : a -> int = <fun> POLIMORFISMO # let sort (x,y) = if x<y then (x,y) else (y,x);; val sort : a * a -> a * a = <fun> fst, zero, sort sono funzioni polimorfe: hanno più tipi.

31 Il processo di INFERENZA DEI TIPI ha lasciato alcuni tipi completamente non ristretti: a e b possono essere qualsiasi: let first (x,y) = x first(x,y) se x: α e y: β, dominio di first: α β = x codominio di first: α let sort (x,y) = if x<y then (x,y) else (y,x) sort(x,y) se x: α e y: β, dominio di sort: α β = if x < y... α = β (x,y): α α (y,x): α α... then (x,y)... codominio di sort: α α else (y,x) OK: il valore della funzione nel caso then e nel caso else è lo stesso 31

32 32 Schemi di tipo e istanze a * b -> a è uno schema di tipo: indica un insieme infinito di tipi, tutti quelli della forma T1 * T2 -> T1 Ogni tipo che si ottiene sostituendo a con un tipo e b con un tipo è un istanza di a * b -> a int * bool -> int int * int -> int (int * bool) * (int -> bool) -> (int * bool) ( a * b) * c -> ( a * b) a -> int è uno schema di tipo: indica un insieme infinito di tipi, tutti quelli della forma T -> int Istanze di a -> int: int * bool -> int a * b -> int ( a -> b) -> int

33 33 a * a -> a * a è uno schema di tipo: indica un insieme infinito di tipi, tutti quelli della forma T * T -> T * T Istanze di a * a -> a * a int * int -> int * int bool * bool -> bool * bool All interno di un espressione, il tipo di un oggetto polimorfo viene istanziato: Il tipo dell occorrenza di first nell espressione first (8,true) è int * bool -> int Il tipo dell occorrenza di first nell espressione first (double, pippo ) è (int -> int) * string -> (int -> int)

34 34 Occorrenze multiple di un oggetto polimorfo Un oggetto polimorfo può avere occorrenze con tipi diversi nella stessa espressione: (first (first,8)) (true,10) Notiamo che il valore di (first (first,8)) è (la seconda occorrenza di) first Questo valore viene applicato a (true,10): bool * int Quindi il tipo della seconda occorrenza di first è bool * int -> bool La prima occorrenza di first si applica a (first,8), che è dunque di tipo (bool * int -> bool) * int Quindi il tipo della prima occorrenza di first è (bool * int -> bool) * int -> (bool * int -> bool)

35 Le funzioni sono oggetti di prima classe: possono essere componenti di una struttura dati, o costituire l argomento o il valore di altre funzioni. I linguaggi funzionali consentono l uso di funzioni di ordine superiore, cioè funzioni che prendono funzioni come argomento o riportano funzioni come valore, in modo assolutamente generale. Funzioni di ordine superiore # let comp (f,g) = function x -> f(g x);; val comp : ( a -> b) * ( c -> a) -> c -> b = <fun> # let double n = n*2;; val double : int -> int = <fun> # let treble n = n*3;; val treble : int -> int = <fun> # let sixtimes = comp(double,treble);; val sixtimes : int -> int = <fun> # sixtimes 8;; - : int = 48 35