Deciding ML typability is complete for deterministic exponential time
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A simple proof of a theorem of Statman
Theoretical Computer Science
Type reconstruction in finite rank fragments of the second-order &lgr;-calculus
Information and Computation - Special issue: Selections from 1990 IEEE symposium on logic in computer science
A direct algorithm for type inference in the rank-2 fragment of the second-order &lgr;-calculus
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
Foundations of programming languages
Foundations of programming languages
Parallel beta reduction is not elementary recursive
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Principality and decidable type inference for finite-rank intersection types
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '83 Proceedings of the 10th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
An Analysis of the Core-ML Language: Expressive Power and Type Reconstruction
ICALP '94 Proceedings of the 21st International Colloquium on Automata, Languages and Programming
A Typed Intermediate Language for Flow-Directed Compilation
TAPSOFT '97 Proceedings of the 7th International Joint Conference CAAP/FASE on Theory and Practice of Software Development
Addendum to ``New Notions of Reduction and Non-Semantic Proofs of Beta Strong Normalization in Typed Lambda Calculi''''
A calculus with polymorphic and polyvariant flow types
Journal of Functional Programming
ESOP '02 Proceedings of the 11th European Symposium on Programming Languages and Systems
The Essence of Principal Typings
ICALP '02 Proceedings of the 29th International Colloquium on Automata, Languages and Programming
Types, potency, and idempotency: why nonlinearity and amnesia make a type system work
Proceedings of the ninth ACM SIGPLAN international conference on Functional programming
Weak linearization of the lambda calculus
Theoretical Computer Science - Applied semantics: Selected topics
Electronic Notes in Theoretical Computer Science (ENTCS)
FOSSACS'07 Proceedings of the 10th international conference on Foundations of software science and computational structures
On the rôle of minimal typing derivations in type-driven program transformation
Proceedings of the Tenth Workshop on Language Descriptions, Tools and Applications
Strict intersection types for the Lambda Calculus
ACM Computing Surveys (CSUR)
Linearity and iterator types for Gödel's System
Higher-Order and Symbolic Computation
Hi-index | 0.00 |
We investigate finite-rank intersection type systems, analyzing the complexity of their type inference problems and their relation to the problem of recognizing semantically equivalent terms. Intersection types allow something of type τ1 Λ τ2 to be used in some places at type τ1 and in other places at type τ2. A finite-rank intersection type system bounds how deeply the Λ can appear in type expressions. Such type systems enjoy strong normalization, subject reduction, and computable type inference, and they support a pragmatics for implementing parametric polymorphism. As a consequence, they provide a conceptually simple and tractable alternative to the impredicative polymorphism of System F and its extensions, while typing many more programs than the Hindley-Milner type system found in ML and Haskell.While type inference is computable at every rank, we show that its complexity grows exponentially as rank increases. Let K(0, n) = n and K(t + 1, n) = 2K(t,n); we prove that recognizing the pure λ-terms of size n that are typable at rank k is complete for DTIME[K(k−1, n)]. We then consider the problem of deciding whether two λ-terms typable at rank k have the same normal form, generalizing a well-known result of Statman from simple types to finite-rank intersection types. We show that the equivalence problem is DTIME[K(K(k − 1, n), 2)]-complete. This relationship between the complexity of typability and expressiveness is identical in wellknown decidable type systems such as simple types and Hindley-Milner types, but seems to fail for System F and its generalizations. The correspondence gives rise to a conjecture that if Τ is a predicative type system where typability has complexity t(n) and expressiveness has complexity e(n), then t(n) = Ω(log* e(n)).