Struttura dei Linguaggi Funzionali

1
Struttura dei Linguaggi Funzionali

• Principii di Base
• Numerabile nel framework
• Macchina Funzionale Pura
• 0-domain dependent

2
Principi di Base

• La struttura di ogni linguaggio e formata
  dallintegrazione di due componenti
• Domain independent
• Domain dependent

3
Domain Independent Framework

• Strutture proprie del linguaggio
• (include i meccanismi di controllo)
• Comuni a tutti i linguaggi di quella classe
• imperativi
• funzionali
• logici
• object oriented

4
Domain Dependent

• Strutture proprie delle
• applicazioni
• per le quali il linguaggio e stato concepito
• (include valori operazioni associate)

5
Numerabile nel Framework

• Meccanismi per
• Dati concreti
• Dati astratti
• estendono valori in modo arbitrario
• Necessita di un numerabile (interi o sequenze di
  bits)
• Nei L.F. il numerabile e lo Spazio delle Funzioni

6
Numerabile nel Framework (2)

• I numerali di Church
• I naturali di Rosser
• I naturali di Barendregt

7
Numerali di Church

• 0 ? fun f x --gt x
• n ? fun f x --gt f(...f(x)...)
• (n
  volte fn(x) )

8
Numerali di Church unaltra notazione

• Oppure, i combinatori
• 0 ? fun f --gt ? (? e la funzione identita)
• n ? fun f --gt f ...f
• (n volte fn )

9
Numerali di Church proprieta

• possiamo dimostrare che
• 1) "n,"F, "x, (sono equivalenti)
• n F x n F x
• 2) "n, "F, (e discreta)
• n1 F F (n F)

10
I Naturali di Rosser numerali di Church
operazioni

• Equipaggiamola con le operazioni sui naturali
  ?n,m??, ?i ? i

• Succ m ? fun f --gt f (m f)
• m n ? fun f --gt (m f) (n f)
• m n ? fun f --gt n (m f)
• ? m n ? fun f --gt (n m) f

11
I Naturali di Rosser Possiamo dimostrare che

• "n, n Succn (0)
• dim. Per induzione sui naturali
• Ovvio per n0
• n1 Succn1 (0)
• Succ(Succn (0)) definition
• Succ(n) induction
• fun f --gt f (n f) unfolding
• fun f --gt f (f n) definition
• fun f --gt f n1 definition
• "n,m m n mn
• "n,m m n mn
• "n,m ?m n mn

12
I Naturali di Rosser Possiamo calcolare 32

• 3 2
• usiamo riduzione

(fun m n --gt (fun f --gt (mf) (n f))) 3 2 fun f
--gt ( 3 f) (2 f) fun f --gt ((fun f --gt f f
f) f) ((fun f --gt f f) f) fun f --gt (f
f f) (f f) fun f --gt f f f f f
13
I Naturali di Rosser Possiamo calcolare 32

• 3 2
• usiamo (sempre) riduzione

(fun m n --gt (fun f --gt n (m f))) 3 2 fun f --gt
2 (3 f) fun f --gt ((fun f --gt ff) ((fun f --gt
fff) f)) parallelo fun f --gt
((fun f --gt ff) fff) fun f --gt ffffff
14
I Naturali di Rosser Possiamo calcolare 32

• ? 3 2
• usiamo (sempre) riduzione

(fun m n --gt (fun f --gt (n m) f)) 3 2 fun f --gt
(2 3) f) fun f --gt ((fun f --gt f f) 3) f)
fun f --gt (3 3) f) fun f --gt 3((fun f
--gt f f f) f) fun f --gt (fun f --gt f f
f) f f f) fun f --gt f f f f f f
f f f
15
I Naturali di Barendregt

• Difficile definire il predecessore e completare
  operazioni con divisione
• I numerali di Barendregt
• H.P. Barendregt (1990) Functional Programming and
  Lambda Calculus, Handbook of T.C.S, pp 322-364
• Introduciamo funzioni per booleani e sequenze

16
Introduciamo funzioni per booleani

• true ? fun p --gt fun q --gt p Curryzzazione
• false ? fun p q --gt q prodotto
• Allora (B f g) si comporta come un condizionale
• allorche B?true,false

17
Introduciamo funzioni per sequenze

• ltf1,f2gt ? fun B --gt B f1 f2 valore
• ltf1,f2gt?1 ? ltf1,f2gt true op. selezione
  primo
• (fun B--gtB f1 f2) true
• ltf1,f2gt?2 ? ltf1,f2gt false op. sel.
  secondo
• (fun B--gtB f1 f2) false

18
Introduciamo funzioni per sequenzefunzioni
n-arita

• F ? fun x y --gt e
• Puo (ordine superiore) essere zucchero
  sintattico per
• G ? fun z --gt ez?1/x, z?2/y

F e1 e2 corrisponde a F lte1 e2gt
19
Sottrazione e divisione funzioni base

• id ? ?
• Zero? ? fun n --gt n (true false) true

Possiamo provare Zero? 0 true Zero? n1
false
20
Sottrazione e divisionefunzioni base

• drop ?
• fun B --gt B?1 lttrue, fun f--gt(f B?2(f))gt
• lttrue, fun f--gt ?gt

Possiamo provare drop ltfalse,xgt lttrue, 0
gt drop lttrue, n gt lttrue, n1 gt
Quindi drop n1 ltfalse , _gt lttrue, n gt
21
Sottrazione e divisione

• pred ?
• fun n --gt (n drop) ltfalse undefgt false
• - ? fun m n --gt (n pred) m
• div ?
• fun n --gt (Zero? m) 0 ((div(-m n) n)1)

22
Possiamo calcolare pred 0

• pred 0
• usiamo (sempre) riduzione

(fun n --gt (n Drop) ltfalse undefgt false) 0 (0
Drop) ltfalse undefgt false ((fun f --gtId) Drop)
ltfalse undefgt false Id ltfalse undefgt false
ltfalse undefgt false (fun B. B false undef)
false undef
23
Possiamo calcolare pred 2

• pred 2
• usiamo (sempre) riduzione

(fun n --gt (n Drop) ltfalse undefgt false) 2 (2
Drop) ltfalse undefgt false ((fun f --gt f f )
Drop) ltfalse undefgt false Drop Drop ltfalse
undefgt false Drop(fun B --gt B?1 lttrue,fun f--gtf
(B?2 f)gt lttrue,fun f--gtidgt ltfalse undefgt)
false Drop (false lttrue,fun f--gtf (undef f)gt
lttrue,fun f--gtidgt) false
24
Pred 2 (continua)

• Ed ancora

Drop lttrue,fun f--gtidgt false (fun B --gt B?1
lttrue,fun f--gtf (B?2 f)gt lttrue,fun
f--gtidgt lttrue,fun f--gtidgt) false (true lttrue,
fun f--gtf ((fun f--gtid) f)gt lttrue,fun
f--gtidgt) false lttrue, fun f--gtf ((fun f--gtid)
f)gt false (fun B --gtB true fun f--gtf ((fun
f--gtid) f)) false fun f--gtf ((fun f--gtid) f)
fun f--gtf id fun f--gtf
25
Possiamo calcolare - 4 2

• - 4 2
• usiamo (sempre) riduzione

(fun m n --gt (n pred) m) 4 2 (2 pred) 4)
((fun f --gt f f) pred) 4) pred pred 4

26
Possiamo calcolare div 4 2

• div 4 2
• usiamo (sempre) riduzione

(fun m n --gt (zero? m) 0 ( (div (- m n) n) 1)) 4
2 (zero? 4) 0 ( (div (- 4 2) 2) 1) ((fun f
--gt f f f f) (true false) true) 0 ( (div
(- 4 2) 2) 1) ((true false)((true false)((true
false)((true false)true))))) 0 ( (div (- 4 2)
2) 1) ((true false)((true false)((true false)
false)))) 0 ( (div (- 4 2) 2) 1) ((true
false)((true false) false))) 0 ( (div (- 4 2) 2)
1) false 0 ( (div (- 4 2) 2) 1) ( (div (- 4
2) 2) 1) ... (div (0 2) 1)) 1 0 1
27
Macchina Funzionale 0-data domain

• programmi

Valori funzionali n,true,false, lt_gt,
Fix Succ,,-,,div
28
Macchina Imperativa

• Programmi

Transizione di stato Sequenze di bits Registri
e Parole di memoria Sequenza Ri lt- 0 Ri lt-
Rj1 Golabel N Ri lt- Rj-1 or-golabel N Stop
29
Macchina Imperativa programmazione

• Esprimiamo la somma

(0) Rmlt--Rm-1 or-golabel 3 (1) Rnlt--Rn1 (2) golab
el 0 (3) stop
Cosa calcola? la transizione di stato Rm,Rn
--gt Rm0, RnRmRn
30
Macchina Imperativa programmazione con lo stato

• Esprimiamo la transizione
• Rm,Rn --gt RmRm, RnRn, R0RmRn
• Occorre esprimere copie
• Rn,R0,R1 --gt RnRn, R0Rn, R10

(0) r0lt--0 (1) r1lt--0 (2) rnlt--rn-1 or-golabel
6 (3) r0lt--r01 (4) r1lt--r11 (5) golabel
2 (6) r1lt--r1-1 or-golabel 9 (7) rnlt--rn1 (8) gol
abel 6
ora possiamo aggiungere il resto
31
Conclusioni

• Strutture domain independent e dependent
• Lo spazio delle funzioni fornisce gia un
  numerabile
• Lo spazio delle funzioni fornisce gia strutture
  per
• Naturali
• Booleani
• Tuple e sequenze
• Struttura ed espressivita di
• Una macchina funzionale 0-domain
• Una macchina imperativa a registri di bit

32
Osservazioni ?-tipato ? ?cDimostriamo che non
esiste totale calcolabile F? che assegna tipi a
tutti i termini chiusi di ?

• Premesse
• ?c il nostro calcolo
• F? calcolabile, quindi esprimibile in ?c (i.e.
  F? ? ?c )
• F? non banale, quindi ? t0, t1 ? ?c
• F? (t0)0 ? 1F? (t1) (i.e. 0 /gt? 1, and 1
  /gt? 0)
• Definiamo
• I I(x) t0 se F? (x) 0 , I(x) t1 altrimenti
• Not Not(x) t1 se F? (x) 0 , Not(x) t0
  altrimenti
• I, Not sono calcolabili, quindi I, Not ? ?c
• R \x.Not(xx)
• R é chiuso e Not è calcolabile, quindi R ? ?c
• Esprimiamo
• F? (RR) gt? F? (Not(RR))
• Concludiamo
• F? è banale oppure non è calcolabile.