Scarica Programmazione funzionale e più Dispense in PDF di Tecniche E Linguaggi Di Programmazione solo su Docsity!
Programmazione Funzionale
LP imperativi: apparenza simile modello di progettazione = macchina fisica
Famiglia dei LP imperativi = progressivo “miglioramento” del FORTRAN
Obiezione: pesante aderenza dei LP alla macchina fisica =
restrizione non necessaria al processo di sviluppo del software
Possibilità di modelli alternativi di progettazione dei LP
Paradigma funzionale : basato sulle funzioni matematiche LP funzionali
Funzioni Matematiche
Funzione matematica = mapping: dominio codominio : specificato da
Funzione applicabile ad un elemento del dominio
Valutazione della espressione di mapping: controllata da
Funzione matematica: definisce un valore (non una sequenza di operazioni su variabili in
memoria per produrre un valore)
valore della funzione dipende solo dai suoi argomenti
tabella
espressione
expr condizionali
ricorsione
variabili
effetti collaterali
1 se n = 0 fact( n ) = n fact( n -1) se n > 0
f
Forme Funzionali
Funzione di ordine superiore
Esempi:
1. Composizione di funzioni : 2. Costruzione : 3. Applicazione universale :
risultato è una funzione
parametri sono funzioni
f(x) x+ g(x) 3x h(x)^ ^ f^ °^ g^ ^ f(g(x))^ =^ (3x)+
f(x) xx g(x) 2x h(x) x/
f, g, h (16, 8, 2)
f(x) x*x map(f,(2,3,4)) (4,9,16)
Fondamenti dei LP Funzionali
Obiettivo: massimizzazione delle similarità con funzioni matematiche
Approccio al problem-solving: molto diverso da quello dei LP imperativi
Programma = { def di funzioni } + { applicazioni di funzioni }
Esecuzione = valutazione delle applicazioni delle funzioni
Poichè var assegnabili
FPL fornisce
Pb delle funzioni nei LP imperativi
stato del programma risultato dipende solo dagli argomenti
impossibile controllare cicli (conteggio, condizionali) ricorsione
trasparenza referenziale { funzioni primitive } { forme funzionali } costruzione di funzioni complesse partendo da primitive operazione di applicazione delle funzioni strutture dati
effetti collaterali
restrizione sui tipi di valori restituiti forme funzionali ridotte
Espressioni
Notazione prefissa con parentesi possibilità di numero variabile di argomenti
Liste per rappresentare
Espressioni complesse mediante liste innestate
Valori globali
(+) ; valutata 0 (+ 5) ; valutata 5 (+ 5 4 3 2 1) ; valutata 15 () ; valutata 1 ( 5) ; valutata 5 (* 1 2 3 4 5) ; valutata 120
dati
funzioni primo elemento della lista nome funzioneoperatore
(define d 120) cambia l’ambiente (unica nel nostro subset)
Valutazione delle Espressioni
Governate da 3 regole:
- Nomi sostituiti dai loro binding correnti
- Liste valutate come chiamate di funzioni scritte in forma prefissa
- Costanti sono valutate come se stesse
Inibizione della valutazione di un nome
( define d 120) ... d ; 120 (+ d 5) ; 125
(+) ; invoca + senza argomenti (+ 5) ; invoca + con un argomento (+ 5 4 3 2 1) ; invoca + con cinque argomenti (+ (5 4 3 2 1)) ; errore: cerca di valutare 5 come una funzione (d) ; errore: d non è una funzione
5 ; valutato 5 #t ; valutato true (predefinito) #f ; valutato false (predefinito)
( define colori ( quote (rosso giallo verde))) ( define colori '(rosso giallo verde)) ( define x d) ; definisce x col valore di d (120) ( define x 'f) ; definisce x come simbolo f ( define uncolore 'rosso) ; definisce uncolore come rosso ( define uncolore rosso) ; errore: rosso non definito
Liste (ii)
Lista = testa + coda
Costruzione di liste
(car pari) ; 0 (cdr pari) ; (2 4 6 8) (car (cdr pari)) ; 2 (cadr pari) ; 2 (cdr (cdr pari)) ; (4 6 8) (cddr pari) ; (4 6 8) (car '(6 8)) ; 6 (cdr '(6 8)) ; (8) (car '(8)) ; 8 (cdr '(8)) ; () list crea la lista dei suoi argomenti append concatenazione dei due argomenti lista (list 1 2 3 4) ; (1 2 3 4) (list '(1 2) '(3 4) 5) ; ((1 2) (3 4) 5) (list pari dispari) ; ((0 2 4 6 8) (1 3 5 7 9)) (list 'pari 'dispari) ; (pari dispari) (append '(1 2) '(3 4)) ; (1 2 3 4) (append pari dispari) ; (0 2 4 6 8 1 3 5 7 9) (append '(1 2) ()) ; (1 2) (append '(1 2) (list 3)) ; (1 2 3)
Liste (iii)
Test di emptyness: null?
Test di uguaglianza: equal?
Test di tipo:
(null? '()) ; #t (null? pari) ; #f (null? '(1 2 3)) ; #f (null? 5) ; #f
(equal? 5 5) ; #t (equal? 5 1) ; #f (equal? '(1 2) '(1 2)) ; #t (equal? 5 '(5)) ; #f (equal? '(1 2 3) '(1 (2 3))) ; #f (equal? '(1 2) '(2 1)) ; #f (equal? () ()) ; #t
(list? pari) ; #t (symbol? 'pari) ; #t (number? 3) ; #t (atom? pari) ; #f
tipo
atomo lista
simbolo numero
Definizione di Funzioni
( define nome ( lambda ( argomenti ) corpo )) binding( nome , - astrazione )
( define min ( lambda (x y)( if (< x y) x y)))
( define (min x y)( if (< x y) x y))
( define (abs x)( if (< x 0) ( 0 x) x))
( define (fattoriale n) ( if (< n 1) 1 (* n (fattoriale ( n 1)))) )
Definizione di Funzioni (ii)
Computazione iterativa ricorsione
Lunghezza di una lista
( define (sommatoria numeri) ( if (null? numeri) 0 (+ (car numeri) (sommatoria (cdr numeri))) ) )
passo ricorsivo
(length '(1 2 3 4)) ; 4 (length '((1 2) 3 (4 5))) ; 3 (length ()) ; 0 (length 5) ; errore
( define (length lista) ( if (null? lista) 0 (+ 1 (length (cdr lista))) ) )
piede della ricorsione
Definizione di Funzioni (iv)
Sostituzione: (subst elem1 elem2 lista )
(subst 'x 2 '(1 2 3 2 1)) ; (1 x 3 x 1) (subst 'x 2 '(1 (2 3) 2 1)) ; (1 (2 3) x 1) (subst 'x 2 '(1 (2 3) (2))) ; (1 (2 3) (2)) (subst 'x '(2 3) '(1 (2 3) 2 3)) ; (1 x 2 3) (subst '(2 3) 'x '(x y x y)) ; ((2 3) y (2 3) y)
( define (subst x y lista) ( if (null? lista) () ( if (equal? y (car lista)) (cons x (subst x y (cdr lista))) (cons (car lista) (subst x y (cdr lista))) ) ) )
Fattorizzazione di Sottoespressioni
Identificazione di sottoexpr: ( let (( id 1 expr 1 )( id 2 expr 2 ) ... ( idn exprn )) corpo )
valutazione della espressione una sola volta
let* binding ( idi , expri ) realizzato prima della valutazione di expri+ 1
( let ((x 2)(y 3))(+ x y)) ; valutata 5
( define (subst x y lista) ( if (null? lista) () ( let ((testa (car lista))(coda (cdr lista))) ( if (equal? y testa) (cons x (subst x y coda)) (cons testa (subst x y coda)) ) ) ) )
espressioni valutate tutte prima dei binding
( define x 0) ( let ((x 2) (y x)) y) ; 0 ( let* ((x 2) (y x)) y) ; 2
Regole di scope gerarchiche
Costruzione di Codice
Uniformità strutturale di sfruttata per costruire programmi dinamicamente
eval valuta il suo argomento
dati
codice
( define (sommatoria numeri) ( if (null? numeri) 0 (+ (car numeri) (sommatoria (cdr numeri))) ) )
( define (sommatoria numeri) (eval (cons '+ numeri)) )
( define lista '(3 4 5)) (sommatoria lista)
(eval '(+ 3 4 5))
Costruzione di Codice (ii)
(eval 6) ; 6 (eval (+ 1 2 3)) ; 6 (eval '(+ 1 2 3)) ; 6 (eval ''(+ 1 2 3)) ; (+ 1 2 3) (eval '''(+ 1 2 3)) ; (quote(+ 1 2 3)) (eval (eval '''(+ 1 2 3))) ; (+ 1 2 3) (eval (eval (eval '''(+ 1 2 3)))) ; 6 (eval (eval ''(+ 1 2 3))) ; 6 (eval (eval (eval ''(+ 1 2 3)))) ; 6
(eval (length '(1 2 3))) ; 3 (eval '(length (1 2 3))) ; errore (eval '(length '(1 2 3))) ; 3 (eval ''(length (1 2 3))) ; (length (1 2 3)) (eval '''(length (1 2 3))) ; (quote (length (1 2 3))) (eval ''(length '(1 2 3))) ; (length (quote (1 2 3))) (eval (eval ''(length (1 2 3)))) ; errore (eval (eval ''(length '(1 2 3)))) ; 3
