Implementazione di algoritmi per l inferenza di tipi ricorsivi Implementation of algorithms for the inference of recursive types

Transcript

1 Implementazione di algoritmi per l inferenza di tipi ricorsivi Implementation of algorithms for the inference of recursive types Andrea Crotti Contents 1 Italiano Introduzione Inferenza dei tipi Inferenza di tipi ricorsivi Struttura degli algoritmi Appiattimento Equivalenza di tipi Haskell Classi Monadi English Introduction Type Inference Recursive type inference Algorithms structure Flattening Type equivalence Haskell Classes Monads Italiano 1.1 Introduzione In questo lavoro faremo alcune considerazione riguardo all inferenza di tipi ricorsivi per un generico linguaggio funzionale. Inoltre mostreremo l implementazione di un semplice algoritmo essenziale a questo scopo, scritto in haskell, e daremo una breve introduzione a questo linguaggio. 1.2 Inferenza dei tipi Ogni linguaggio di programmazione adotta una specifica strategia per la gestione dei tipi, ci sono numerose soluzioni possibili, ma possono essere divise in due grandi categorie: 1

2 Typing statico (come ad esempio haskell) In un sistema di typing statico il compilatore esamina il codice sorgente e assegna delle etichette a pezzi di codice, poi le utilizza per inferire qualcosa sul comportamento del programma. Typing dinamico (come ad esempio scheme o python) In un sistema di typing dinamico il compilatore genera codice per tenere traccia della categoria dei dati (che incidentalmente è sempre chiamato tipo) usati dal programma. La prima soluzione può sembrare più restrittiva ma con il typing polimorfico e l inferenza dei tipi può risultare molto vantaggiosa. Per i nostri esempi useremo haskell come meta linguaggio, ha un motore di inferenza di tipi basato sull algoritmo di Hindley-Milner e è il linguaggio utilizzato anche nel resto del lavoro. Ogni espressione in haskell deve avere un tipo, può essere esplicitamente scritto (cosa utile anche ai fini della documentazione) oppure può essere implicito. In quel caso il compilatore haskell cerca di inferire il tipo più generico possibile che sia al contempo compatibile con il contesto. Se non è in grado di trovare nessuno tipo compatibile ritornerà errore e il programma non sarà compilato. Ad esempio questo: id : : a > a è il tipo della funzione id (identità), prende qualcosa di tipo a and ritorna qualcosa (incidentalmente uguale) dello stesso tipo. Un esempio più interessante potrebbe essere il tipo della funzione f, definita come: f = \x > x 5 Qual è il tipo di f? f è una lambda astrazione, e prende come input una funzione che lavora su Ints e la applica al numero 5. Quindi il tipo di f è: f : : ( Integer > t ) > t Dove il tipo t potrebbe essere qualsiasi cosa, ma naturalmente lo stesso nelle sue due occorrenze. 1.3 Inferenza di tipi ricorsivi Un tipo è ricorsivo quando è definito in funzione di se stesso. Un esempio di tipi ricorsivo potrebbe essere il tipo della funzione f = λx x x Questo non può essere tipato con un algoritmo standard Hindley-Milner, il type checker di haskell ritorna infatti questo errore: Main> : t (\ x > x x ) <i n t e r a c t i v e > : 1 : 7 : Occurs check : cannot c o n s t r u c t the i n f i n i t e type : t = t > t1 Probable cause : x i s a p p l i e d to too many arguments In the e x p r e s s i o n : x x 2

3 L errore viene generato dal type checker, che non permette la costruzione di tipi ricorsivi. L algoritmo implementato in potrebbe essere parte di un estensione che permetta l inferenza dei tipi ricorsivi. 1.4 Struttura degli algoritmi I due algoritmi principali usati in questo lavoro sono l algoritmo di appiattimento e l algoritmo che verifica se due tipi ricorsivi (presentati da ricorsioni simultanee, cioè sistemi finiti di equazioni tra tipi) sono uguali in senso forte, cioè hanno lo stesso sviluppo infinito Appiattimento Definition (Sistema piatto) Un sistema S è piatto quando il lato destro di ogni equazione consiste di una costante oppure di un costruttore di tipi applicato a variabili. La funzione flatten prende come input un sistema S (in forma di sostituzione) e ritorna un sistema equivalente che è piatto, introducendo nuove variabili. La parte principale del processo di appiattimento è la funzione typeflat, che prende una espressione di tipo, rinomina tutte le variabili e poi costruisce un sistema equivalente e piatto. Prima analizza l intera struttura ricorsivamente dividendola in due parti, e poi le combina in una nuova espressione con questa linea di codice: newexpr = makesubst ( getexp t1 ass1 : > getexp t2 ass1 ) ( Tvar ( Id n1 ) ) Il caso base della ricorrenza è una variabile singola, la funzione non fa nulla se la variabile è già stata trovata, la aggiunge e incrementa il contatore altrimenti. Per esempio applicando la funzione typeflat al tipo: ( ( var0 > var1 ) > ( var2 > var3 ) ) Restituisce come output var4 = var3 var3 = var2 var1 = var1 var0 = var0 var2 = ( var0 > var1 ) var5 = ( var3 > var4 ) var6 = ( var2 > var5 ) Equivalenza di tipi Dato un sistema di equazioni vogliamo verificare se ci sono tipi ricorsivi fortemente equivalenti tra loro. L algoritmo implementato è preso da [1], e verifica se due tipi sono uguali cercando una bisimulazione tra di essi. Il sistema dato in input deve essere piatto, altrimenti l algoritmo non è in grado di funzionare. Per esempio se abbiamo un sistema di questo tipo: 3

4 var0 = var0 var2 var1 = var1 var3 var2 = Char var3 = Char Vediamo che var0 e var1 sono uguali, ma sono entrambi tipi ricorsivi. Quindi valutiamo la funzione che verifica l equivalenza fra tipi su tutto il sistema, e otteniamo il sistema stesso con aggiunti (in coda) tutte le possibili equivalenze tra tipi ricorsivi. L output della funzione è: var1 = ( var3 > var1 ) var0 = ( var3 > var0 ) var3 = Char var0 = var1 L algoritmo tiene traccia delle variabili analizzate utilizzando due contenitori, O e C. Ad ogni passo aggiorna O e C fino a che O non diventa, oppure fino a che non troviamo due variabili che siano evidentemente differenti. 1.5 Haskell Il linguaggio scelto per questo stage è haskell 1, un linguaggio di programmazione funzionale puro e lazy. Puro: viene definito puro perché non ci sono effetti collaterali. Le computazioni che hanno bisogno di effetti collaterali sono incapsulate in strutture speciali chiamate Monadi. Lazy: è pure perché haskell calcola solamente il minimo necessario per ottenere un valore. Questa semplice istruzione: Prelude> take 10 [ 1.. ] [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 1 0 ] prende il primi 10 elementi dalla lista infinita [1..] terminando normalmente. In un linguaggio strict questo non può essere fatto altrettanto agevolemente Classi Un altro importante concetto di haskell è il concetto di classe. Una classe in haskell è una collezione di tipi che supporta certe operazioni chiamate metodi. Qualsiasi tipi t instanza della classe C deve implementare questi metodi, rispettando le stesse signature dei tipi. Per esempio potremo creare un nuovo tipo MyType con tre costruttori unari: data MyType = One Two Three instance Show MyType where show One = uno show Two = due show Three = t r e 1 4

5 E istanziare la classe Show, che permette di dare la rappresentazione di MyType come stringa Monadi Le monadi sono il sistema utilizzato da haskell per gestire gli effetti collaterali (per esempio operazioni di IO). La classe Monad è definita nel prelude di haskell ( 2 ) come: class Monad m where (>>=) : : m a > ( a > m b ) > m b return : : a > m a Per fare in modo che il nostro tipo di dati diventi una monade dobbiamo istanziare la classe Monad e implementare i due operatori >>= e return. Dato che il concetto di monade viene da una branca della teoria delle categorie, per creare una monade non è sufficiente semplicemente dichiararla come istanza della classe monade. Per essere corretta, le funzioni return e >>= devono obbedire alle tre leggi delle monadi: 1. Identità sinistra del return rispetto a >>=: ( return x ) >>= f == f x 2. Identità destra di return rispetto a >>=: m >>= return == m 3. Associatività di >>=: (m >>= f ) >>= g == m >>= (\ x > f x >>= g ) 2 English 2.1 Introduction In this work we make some considerations about type inference with recursive types for a functional programming language. Then we show the implementation of a small algorithm, essential for this purpose, written in haskell and we give a brief introduction to this language. 2.2 Type Inference Every programming language has to choose a strategy for typing, there are several different solutions adopted, but they can be divided in two main families: static typing (for example haskell) A static type system is a mechanism by which a compiler examines source code and assigns labels to pieces of the syntax, and then uses them to infer something about the program s behavior. 2 modulo che viene automaticamente caricato 5

6 dynamic typing (for example scheme or python) A dynamic type system is a mechanism by which a compiler generates code to keep track of the sort of data (incidentally still called type ) used by the program. The first solution may look excessively constrained but with polymorphic typing and type inference can be very advantageous. For our example we will use haskell as a meta language, it has a Hindley-Milner type inference engine and it s the language used for this work. Every expression in haskell must have a type, it can be explicitly written (also useful for documentation) or implicit. In that case the haskell compiler tries to infer the most possible general type which is compatible with the context. If it s unable to find any compatible type then it will return error and the program won t compile at all. For example this: id : : a > a is the type of the function id (identity), takes something of type a and returns something else (incidentally the same thing) of type a. A more interesting type could be the type of the function f, where f is: f = \x > x 5 What s the type of f? f is bound to a lambda abstraction, and takes as input a function that works on Ints and applies it to the number 5. Then the type of f is: f : : ( Integer > t ) > t where the type t could be anything, but of course has to be the same in both occurrences. 2.3 Recursive type inference A type is recursive whenever is defined in term of itself. An example of recursive type could be the type of the function f = λx x x This can t be typed with a standard Hindley-Milner algorithm, the haskell type checker returns this error: Main> : t (\ x > x x ) <i n t e r a c t i v e > : 1 : 7 : Occurs check : cannot c o n s t r u c t the i n f i n i t e type : t = t > t1 Probable cause : x i s a p p l i e d to too many arguments In the e x p r e s s i o n : x x The error is raised from the type checker, that doesn t allow construction of recursive types. The algorithm implemented in could be a part of an extension that allows type inference for recursive types. 6

7 2.4 Algorithms structure The two main algorithms used in this work are the flattening algorithm and the algorithm that checks if two recursive types (presented by simultaneous recursions, i.e. finite systems of type equations) are equal Flattening Definition (Flat system) A system S is flat when the right hand side of each equation consists either of a constant or of a type constructor applied to type variables. The function flatten takes as input a system S (in form of substitution) and returns an equivalent system which is also flat, introducing new variables. The core of the flattening process is the function typeflat, which takes a type expression, relabels every variable and then builds an equivalent equation system. We first analyze the whole structure recursively dividing it in two parts, then merge them together in a composed expression with this line. newexpr = makesubst ( getexp t1 ass1 : > getexp t2 ass1 ) ( Tvar ( Id n1 ) ) The base case of the recurrence is a singleton variable, I do nothing if the variable has been found, otherwise I add to the binding and increment the counter. For example applying the function typeflat on the type: ( ( var0 > var1 ) > ( var2 > var3 ) ) Gives as output: var4 = var3 var3 = var2 var1 = var1 var0 = var0 var2 = ( var0 > var1 ) var5 = ( var3 > var4 ) var6 = ( var2 > var5 ) Type equivalence Given a system of equations we want to check if there are recursive types which are strongly equivalent modulo this system. The implemented algorithm is taken from [1], and checks if two types are equal looking for a bisimulation between them. The system given in input must be already flat, otherwise this algorithm won t work. For example we have a system like this: var0 = var0 var2 var1 = var1 var3 var2 = Char 7

8 var3 = Char We see that var0 and var1 are equal, but they are both recursive types. Then we evaluate the function that checks the equivalence of variables on the whole system, and get the same system plus (at the end) bindings between recursive types. The output of the function is: var1 = ( var3 > var1 ) var0 = ( var3 > var0 ) var3 = Char var0 = var1 The algorithm keeps track of analyzed variables using two containers O and C. It updates them every step until O becomes or we find two variables that can be easily checked for equality. If O becomes then we will have in C(n) the bisimulations between strongly equal variables. 2.5 Haskell The language chosen for this stage is haskell 3, a pure and lazy functional programming language. Pure: it s pure because it doesn t have side effects. Computations that do need side effects are encapsulated in special structures called Monads. Lazy: it s lazy because Haskell only computes what it needs to compute in order to get a value. This very simple computation: Prelude> take 10 [ 1.. ] [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 1 0 ] takes the first 10 elements from the infinite list [1..] without any problem. In strict languages this can t be done so simply Classes Another important concept in haskell is the concept of class. A class in haskell is a collection of types that supports certain overloaded operations called methods. Any type t instance of the class C must implement those methods, respecting their type signatures. For example we could create a new data type MyType with three unary constructors: data MyType = One Two Three instance Show MyType where show One = uno show Two = due show Three = t r e And instantiate the class Show, which gives the representation of MyType as a string

9 2.5.2 Monads Monads are the way that haskell uses to handle with side effects (needed for example for IO computations). The monad class is defined in the haskell prelude ( 4 ) as: class Monad m where (>>=) : : m a > ( a > m b ) > m b return : : a > m a To make our data type a Monad we need to make it instance of the Monad class, and implement the two operators >>= and return. As long as the concept of monad comes from a branch of category theory, to create a monad is not just enough to declare a monad instance with the correct type signatures. To be a proper monad, the return and >>= functions must obey to the three laws of monads: 1. Left identity of return with respect to >>=: ( return x ) >>= f == f x 2. Right identity of return with respect to >>=: m >>= return == m 3. Associativity of >>=: (m >>= f ) >>= g == m >>= (\ x > f x >>= g ) References [1] F. Cardone and M. Coppo. Decidability properties of recursive types. In C. Blundo and C. Laneve, editors, Theoretical Computer Science, Proceedings of the 8th Italian Conference, volume 2841 of Lecture Notes in Computer Science, pages Springer-Verlag, the module automatically loaded 9