Results 11  20
of
55
Raising ML to the Power of System F
 In ICFP ’03: Proceedings of the eighth ACM SIGPLAN international conference on Functional programming
, 2003
"... We propose a type system MLF that generalizes ML with firstclass polymorphism as in System F. We perform partial type reconstruction. As in ML and in opposition to System F, each typable expression admits a principal type, which can be inferred. Furthermore, all expressions of ML are welltyped, wi ..."
Abstract

Cited by 10 (0 self)
 Add to MetaCart
We propose a type system MLF that generalizes ML with firstclass polymorphism as in System F. We perform partial type reconstruction. As in ML and in opposition to System F, each typable expression admits a principal type, which can be inferred. Furthermore, all expressions of ML are welltyped, with a possibly more general type than in ML, without any need for type annotation. Only arguments of functions that are used polymorphically must be annotated, which allows to type all expressions of System F as well.
Types, potency, and idempotency: why nonlinearity and amnesia make a type system work
 In ICFP ’04: Proceedings of the ninth ACM SIGPLAN international conference on Functional programming, 138–149, ACM
, 2004
"... Useful type inference must be faster than normalization. Otherwise, you could check safety conditions by running the program. We analyze the relationship between bounds on normalization and type inference. We show how the success of type inference is fundamentally related to the amnesia of the type ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
(Show Context)
Useful type inference must be faster than normalization. Otherwise, you could check safety conditions by running the program. We analyze the relationship between bounds on normalization and type inference. We show how the success of type inference is fundamentally related to the amnesia of the type system: the nonlinearity by which all instances of a variable are constrained to have the same type. Recent work on intersection types has advocated their usefulness for static analysis and modular compilation. We analyze SystemI (and some instances of its descendant, System E), an intersection type system with a type inference algorithm. Because SystemI lacks idempotency, each occurrence of a variable requires a distinct type. Consequently, type inference is equivalent to normalization in every single case, and time bounds on type inference and normalization are identical. Similar relationships hold for other intersection type systems without idempotency. The analysis is founded on an investigation of the relationship between linear logic and intersection types. We show a lockstep correspondence between normalization and type inference. The latter shows the promise of intersection types to facilitate static analyses of varied granularity, but also belies an immense challenge: to add amnesia to such analysis without losing all of its benefits.
Program Representation Size in an Intermediate Language with Intersection and Union Types
 In Proceedings of the Third Workshop on Types in Compilation (TIC 2000
, 2000
"... The CIL compiler for core Standard ML compiles whole programs using a novel typed intermediate language (TIL) with intersection and union types and ow labels on both terms and types. The CIL term representation duplicates portions of the program where intersection types are introduced and union ..."
Abstract

Cited by 9 (7 self)
 Add to MetaCart
(Show Context)
The CIL compiler for core Standard ML compiles whole programs using a novel typed intermediate language (TIL) with intersection and union types and ow labels on both terms and types. The CIL term representation duplicates portions of the program where intersection types are introduced and union types are eliminated. This duplication makes it easier to represent type information and to introduce customized data representations. However, duplication incurs compiletime space costs that are potentially much greater than are incurred in TILs employing typelevel abstraction or quanti cation. In this paper, we present empirical data on the compiletime space costs of using CIL as an intermediate language. The data shows that these costs can be made tractable by using suciently negrained ow analyses together with standard hashconsing techniques. The data also suggests that nonduplicating formulations of intersection (and union) types would not achieve signi cantly better space complexity.
Implementing Compositional Analysis Using Intersection Types with Expansion Variables
, 2002
"... A program analysis is compositional when the analysis result for a particular program fragment is obtained solely from the results for its immediate subfragments via some composition operator. This means the subfragments can be analyzed independently in any order. Many commonly used program analysis ..."
Abstract

Cited by 9 (5 self)
 Add to MetaCart
A program analysis is compositional when the analysis result for a particular program fragment is obtained solely from the results for its immediate subfragments via some composition operator. This means the subfragments can be analyzed independently in any order. Many commonly used program analysis techniques (in particular, most abstract interpretations and most uses of the Hindley/Milner type system) are not compositional and require the entire text of a program for sound and complete analysis.
Strict Intersection Types for the Lambda Calculus
, 2010
"... This paper will show the usefulness and elegance of strict intersection types for the Lambda Calculus; these are strict in the sense that they are the representatives of equivalence classes of types in the BCDsystem [15]. We will focus on the essential intersection type assignment; this system is a ..."
Abstract

Cited by 7 (5 self)
 Add to MetaCart
(Show Context)
This paper will show the usefulness and elegance of strict intersection types for the Lambda Calculus; these are strict in the sense that they are the representatives of equivalence classes of types in the BCDsystem [15]. We will focus on the essential intersection type assignment; this system is almost syntax directed, and we will show that all major properties hold that are known to hold for other intersection systems, like the approximation theorem, the characterisation of (head/strong) normalisation, completeness of type assignment using filter semantics, strong normalisation for cutelimination and the principal pair property. In part, the proofs for these properties are new; we will briefly compare the essential system with other existing systems.
Complexity of strongly normalising λterms via nonidempotent intersection types
"... We present a typing system for the λcalculus, with nonidempotent intersection types. As it is the case in (some) systems with idempotent intersections, a λterm is typable if and only if it is strongly normalising. Nonidempotency brings some further information into typing trees, such as a bound o ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
We present a typing system for the λcalculus, with nonidempotent intersection types. As it is the case in (some) systems with idempotent intersections, a λterm is typable if and only if it is strongly normalising. Nonidempotency brings some further information into typing trees, such as a bound on the longest βreduction sequence reducing a term to its normal form. We actually present these results in Klop’s extension of λcalculus, where the bound that is read in the typing tree of a term is refined into an exact measure of the longest reduction sequence. This complexity result is, for longest reduction sequences, the counterpart of de Carvalho’s result for linear headreduction sequences.
Making Implicit Parameters Explicit
, 2005
"... In almost all languages all arguments to functions are to be given explicitly. The Haskell class system however is an exception: functions can have class predicates as part of their type signature, and dictionaries are implicitly constructed and implicitly passed for such predicates, thus relieving ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
In almost all languages all arguments to functions are to be given explicitly. The Haskell class system however is an exception: functions can have class predicates as part of their type signature, and dictionaries are implicitly constructed and implicitly passed for such predicates, thus relieving the programmer from a lot of clerical work and removing clutter from the program text. Unfortunately Haskell maintains a very strict boundary between the implicit and the explicit world; if the implicit mechanisms fail to construct the hidden dictionaries there is no way the programmer can provide help, nor is he able to override the choices made by the implicit mechanisms. In this paper we describe, in the context of Haskell, a mechanism that allows the programmer to explicitly construct implicit arguments. This extension blends well with existing resolution mechanisms, since it only overrides the default behavior. We include a description of the use of partial type signatures, which liberates the programmer from having to choose between specifying a complete type signature or no type signature at all. Finally we show how the system can easily be extended to deal with higherorder predicates, thus enabling the elegant formulation of some forms of generic programming.
Polymorphic Intersection Type Assignment for Rewite Systems with Intersection and betarule (Extended Abstract)
 IN TYPES’99. LNCS
, 2000
"... We define two type assignment systems for firstorder rewriting extended with application,abstraction, andreduction (TRS). The types used in these systems are a combination of (free) intersection and polymorphic types. The first system is the general one, for which we prove a subject reduction t ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
We define two type assignment systems for firstorder rewriting extended with application,abstraction, andreduction (TRS). The types used in these systems are a combination of (free) intersection and polymorphic types. The first system is the general one, for which we prove a subject reduction theorem and show that all typeable terms are strongly normalisable. The second is a decidable subsystem of the first, by restricting types to Rank 2. For this system we define, using an extended notion of unification, a notion of principal type, and show that type assignment is decidable.
Inferring intersection typings that are equivalent to callbyname and callbyvalue evaluations
, 2005
"... Abstract. We present a procedure to infer a typing for an arbitrary λterm M in an intersectiontype system that translates into exactly the callbyname (resp., callbyvalue) evaluation of M. Our framework is the recently developed System E which augments intersection types with expansion variable ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
Abstract. We present a procedure to infer a typing for an arbitrary λterm M in an intersectiontype system that translates into exactly the callbyname (resp., callbyvalue) evaluation of M. Our framework is the recently developed System E which augments intersection types with expansion variables. The inferred typing for M is obtained by setting up a unification problem involving both type variables and expansion variables, which we solve with a confluent rewrite system. The inference procedure is compositional in the sense that typings for different program components can be inferred in any order, and without knowledge of the definition of other program components. 3 Using expansion variables lets us achieve a compositional inference procedure easily. Termination of the procedure is generally undecidable. The procedure terminates and returns a typing iff the input M is normalizing according to callbyname (resp., callbyvalue). The inferred typing is exact in the sense that the exact callbyname (resp., callbyvalue) behaviour of M can be obtained by a (polynomial) transformation of the typing. The inferred typing is also principal in the sense that any other typing that translates the callbyname (resp., callbyvalue) evaluation of M can be obtained from the inferred typing for M using a substitutionbased transformation.