Compiler-directed type reconstruction for polymorphic languages
FPCA '93 Proceedings of the conference on Functional programming languages and computer architecture
Garbage collection for strongly-typed languages using run-time type reconstruction
LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
What are principal typings and what are they good for?
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Hi-index | 0.00 |
Modern computing environments strive to be robust and reliable, and at the same time, aim at providing enough flexibility to an interactive user to edit, debug, and test programs easily and efficiently. Strongly typed languages satisfactorily meet the former goal by guaranteeing that "type-consistent" programs will not incur run-time type-errors. But most programming environments for such languages have to sacrifice the flexibility of interactive and incremental program development in order to achieve this consistency over the whole program. The problem is further complicated by the presence of polymorphism in many of these languages, where the definition of "type-consistency" is one of inclusion, rather than equality. In this thesis, we address the latter goal of providing an interactive and incremental program development environment in context of Id, which is a polymorphic, strongly typed, incrementally compiled, parallel programming language, developed at the Laboratory for Computer Science, MIT. Id''s typing mechanism is based on the Hindley/Milner type inference system. We describe modifications and extensions to its inference algorithm to allow the building and testing of programs in an incremental, definition by definition basis, and in arbitrary order. We also prove the correctness (soundness and completeness) of our incremental typing scheme with respect to the original type system. We also examine the problem of systematically identifying overloaded identifiers in a program using type information, and translating them into efficient actual code. Finally, we describe the problems encountered while typing non-functional, polymorphic objects in our type system and discuss some possible solutions.