1 / 14

Haskell: Tipi algebrici

Haskell: Tipi algebrici. Tipi algebrici: proprietà, sintassi, semantica Tipi algebrici: esempi e applicazioni Esempi: Tipi algebrici polimorfi Equivalenza strutturale e refenziale: vantaggi Morfismi tra tipi: Deriving e esplicito Tipi ricorsivi e mutuamente ricorsivi

almira
Download Presentation

Haskell: Tipi algebrici

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Haskell: Tipi algebrici • Tipi algebrici: proprietà, sintassi, semantica • Tipi algebrici: esempi e applicazioni • Esempi: Tipi algebrici polimorfi • Equivalenza strutturale e refenziale: vantaggi • Morfismi tra tipi: Deriving e esplicito • Tipi ricorsivi e mutuamente ricorsivi • Tipo unione (disgiunta): Either e Maybe • Induzione strutturale • Esercizi

  2. T1,1 x … x Cn1,1 + Tn1,1 N + Cnk,k Tnk,1 x … x Tnk,k Proprietà: sintassi e semantica • Due forme per introdurre tipi espliciti: • Sinonimi • type People = (Name, Age) type Name = String type Age = Int • Algebrici • data People = Person Name Age data Name = LastFisrt String data Age = Year Int • Struttura Sintattica • data Name = Constrn1,1 eT1,1 … eTn1,1 | … | Constrnk,k eTk,1 … eTnk,k • Significato • data N = Cn1,1 eT1,1…eTn1,1 | … | Cnk,k eTk,1…eTnk,k • definisce iniezioni da domini somme di prodotto

  3. Struttura: Esempi e applicazioni • Tipi enumerati • data Tepore = Caldo | Freddo • data Stagioni = Autunno | Inverno | Primavera | Estate • unione di tipi il cui dominio di valori contiene un solo valore • ogni valore è un costruttore • Tipi prodotto • data Persona = Person PNome PEta • data PNome = Coppia Cognome Nome • data PEta = Anni Int • prodotto di tipi • ogni valore è una iniezione di un prodotto di valori • Tipi unione • data IntErr = Val Int | Err String

  4. Esempi: Tipi algebrici polimorfi Lisp: S-espessioni data SExpr = A Atom | Cons SExpr SExpr deriving(Show, Eq) data Atom = LAMBDA | VAL Int | VAR String deriving(Show, Eq) fun = Cons (A LAMBDA) (Cons (Cons (A(VAR "X")) (A(VAR "y"))) (A(VAR "y"))) Alberi polimorfi data Tree a = Nil | Node a (Tree a) (Tree a) deriving(Show,Eq,Ord) t1 = Node “uno” (Node “due” (Node “tre” Nil Nil) Nil) Nil t2 = Node “uno” Nil (Node “due” (Node “tre” Nil Nil) Nil) t1 > t2

  5. Equivalenza strutturale e nominale • Due forme per introdurre tipi espliciti: • Sinonimi • type People = (Name, Age) type Name = String type Age = Int • Algebrici • data People = Person Name Age data Age = Year Int • Due forme di equivalenza di tipo • Sinonimo: equivalenza strutturale • x:: People; y:: (String,Int) --- x e y hanno stesso tipo • Algebrico:equivalenza nominale (referenziale) • Ogni tipo algebrico è unico • Vantaggi: Sinonimi • Defnizione compatta: dovuta all’uso di strutture built-in quali le tuple • Riusabilità: dovuta alla equivalenza strutturale Algebrici: • Morfismi: possibilità di morfismi tra tipi (deriving istanze di classe) • Tipi ricorsivi: sono ilmeccanismo per introdurre tipi ricorsivi • Uso di nomi: (significativi) per i selettori dei componenti -- esempio: CognomeNome String String • Riduzione di errori: dovuta all’equivalenza nominale che previene l’uso improprio di tipi diversi • Documentazione: dovuta ad un buon uso di nomi -- esempio: Year Int

  6. Morfismi tra tipi: deriving • Morfismi tra tipi basati sui costruttori op: A --> B data TA = CA A data TB = CB B (A-->B)->(Ta-->Tb)(op u) = op (CA v) = CB(op v) Quando op preserva i morfismi -- class AB a where op:: A-->B • In Haskell: il costrutto deriving (solo per built-in) • data Stagioni = Autunno | Inverno | Primavera | Estate Deriving (Eq, Ord, Enum, Show) Equivale a: instance Eq Stagioni where Autunno == Autunno = True …; instance Ord Stagioni where Autunno > Inverno = True … ; instance …

  7. Morfismi tra tipi: esplicito • Scenario iniziale: due classi e due tipi class Movable a where reflectX:: a -> a --- ed altre operazioni che omettiamo data AName = Pair A String • Come esprimere un morfismo Movable A --> Movable Pair A String • passo1: lifting di funzioni A->A su (AName)->(AName) mapName f (Pair a s) = Pair (f a) s esempio: reflectX:: a --> a mapAName reflectX:: AName --> AName • passo2(ultimo): AName è un movable quando A è movable instance Movable A => Movable AName where reflectX = mapAName reflectX esempio: instance Movable A where reflectX u = …. ora possiamo esprimere e calcolare: reflectX (P v s) con v espressione di tipo A ed s espressione di tipo String

  8. Morfismi tra tipi polimorfi: esplicito • Scenario iniziale: due classi e due tipi class Movable a where reflectX:: a -> a --- ed altre operazioni che omettiamo data Name a = Pair a String • Come esprimere un morfismo Movable a --> Movable Pair a String • passo1: lifting di funzioni a->a su (Name a)->(Name a) mapName f (Pair a s) = Pair (f a) s esempio: reflectX:: a --> a mapName reflectX:: (Name a) --> (Name a) • passo2(ultimo): Name a è un movable quando a è movable instance Movable a => Movable (Name a) where reflectX = mapName reflectX esempio: instance Movable A where reflectX u = …. ora possiamo esprimere e calcolare: reflectX (P v s) con v espressione di tipo A ed s espressione di tipo String

  9. Esempi: Tipi algebrici polimorfi Lisp: S-espessioni data SExpr = A Atom | Cons SExpr SExpr deriving(Show, Eq) data Atom = LAMBDA | VAL Int | VAR String deriving(Show, Eq) fun = Cons (A LAMBDA) (Cons (Cons (A(VAR "X")) (A(VAR "y"))) (A(VAR "y"))) Alberi polimorfi data Tree a = Nil | Node a (Tree a) (Tree a) deriving(Show,Eq,Ord) t1 = Node “uno” (Node “due” (Node “tre” Nil Nil) Nil) Nil t2 = Node “uno” Nil (Node “due” (Node “tre” Nil Nil) Nil) t1 > t2

  10. Tipi ricorsivi e mutuamente ricorsivi • data IntList = Val Int | Cons Int IntList • data Expr = Lit Int | Expr :+: Expr | Expr :-: Expr • data SForest = P TLabel [Stree] data STree = Leaf NLabel | Root Sforest data TLabel = T String data NLabel = N Label Anche polimorfe: RISCRIVIAMOLE

  11. Tipo unione: Either e Maybe Either data Either a b = Left a | Right b deriving(Show, Ord, Eq) compareMese::Either Int String -> Either Int String -> Boolean Maybe data Maybe a = Nothing | Just a deriving(Show,Eq,Ord) factorial n |(n < 0) = Nothing |(n==0) = Just 1 |otherwise= let Just m = factorial (n-1) in Just (n* m)

  12. (1) (2) Induzione strutturale Un tipo algebrico (polimorfo su a) data TyName a = C1 a | … | Ck a esempio: data Tree a = Nil | Node a (Tree a) (Tree a) Una proprietà su TyName v::TyName, P(v) esempio: A| v::Tree a, C(v) dove, A: flipT Nil = Nil flipT(Node u t1 t2) = Node u (flipT t2) (flipT t1) C(v): flipT(flipT v) = v Dimostrazione: Induzione sulla struttura Base: Nil --- (componenti non ricorsivi) v=Nil => flipT(flipT Nil) = flipT Nil = Nil Generale: vero per t1,t2, --- (termini dei componenti ricorsivi) i.e. A|flipT(flipT t1))=t1 & flipT(flipT t2))=t2 --- (ind. Hyp.) v = Node u t1 t2 => flipT(flipT(Node u t1 t2)) = flipT(Node u (flipT t2) (flipT t1)) --- (by 2) = Node u (flipT(flipT t1)) (flipT(flipT t2)) --- (by 2) = Node u t1 t2 --- (by ind. Hyp.)

  13. Esercizi: • Polimorfi: Si ridefinisca il tipo Expr in un polimorfo che generalizzi Int. Si ridefisnisca il tipo Sforest (ed tipi correlati) in un polimorfo che astragga rispetto ad una variabile a per il tipo delle etichette dei nodi interni e una b per i nodi foglia. Si definisca, quindi una funzione sizeIn che calcoli il numero di nodi interni di una SForest • Show: Per il polimorfo Sforest precedente si provveda a definire l’operazione show, ricorrendo: • 1) ora al morfismo implicito, • 2) ora a quello esplicito. In quest’ultimo caso, la stringa di presentazione deve essere una sequenza racchiusa tra parentesi tonde e contenente le presentazione degli alberi, a loro volte sequenze, senza separatori. • Tipi: Si definisca un tipo di dato per memorie rappresentate come funzioni da Location -> Val, dove Val sia un tipo adatto per esprimere 3 possibili differenti tipi di valore e Location sia un tipo per locazioni raprresenta- bili con arbitari interi. Si definisca l’operazione alloc che data una Location e un tipo dei tre possibili allochi in memoria tale locazioni con valore il valore di default previsto per tale tipo. • Tipi: Si definisca un tipo di dato per insiemi polimorfi e lo si equipaggi con le operazioni di unione, appartenenza, e confronto, > e ==. • Tipi: Si definisca un tipo di dato per relazioni binarie polimorfe rispetto ad un tipo a di classe Ord. Si fornisca la definizione di un predicato transitive che calcola true se e solo se la relazione è transitiva, e la definizione della funzione min che, data una relazione e un valore u, calcola il minimo valore che è in relazione con u.

  14. Briciole:Tipi ricorsivi e domini riflessivi data Rec a = R ((Rec a) -> (Rec a)) unfoldRec (R f) = f foldRec (R f) x = f x -- typing \x -> (x x) funXX:: Rec a -> Rec a funXX = \x -> foldRec x x -- typing Y=\f -> (\x -> f x x) (\x -> f x x), s.t. Y F = f(Y F)

More Related