Results 11  20
of
21
On functors expressible in the polymorphic typed lambda calculus
 Logical Foundations of Functional Programming
, 1990
"... This is a preprint of a paper that has been submitted to Information and Computation. ..."
Abstract

Cited by 16 (1 self)
 Add to MetaCart
This is a preprint of a paper that has been submitted to Information and Computation.
Static Dependent Types for First Class Modules
"... Static dependent types are the basis of a new type system that permits types and values to be packaged together into rst class modules. Unlike other approaches to modules, static dependent types permit unrestricted access to the types and values in first class modules without sacrificing static type ..."
Abstract

Cited by 16 (0 self)
 Add to MetaCart
Static dependent types are the basis of a new type system that permits types and values to be packaged together into rst class modules. Unlike other approaches to modules, static dependent types permit unrestricted access to the types and values in first class modules without sacrificing static type checking or data abstraction. Static dependent types are type safe in the presence of side e ects because they rely on an effect system that can make deductions conventional type systems cannot. Experience with an implementation, built as an extension to the FX87 programming language, shows that static dependent types can be used for building large systems.
Formalizing and verifying semantic type soundness for a simple compiler
, 2007
"... We describe a semantic type soundness result, formalized in the Coq proof assistant, for a compiler from a simple imperative language with heapallocated data into an idealized assembly language. Types in the highlevel language are interpreted as binary relations, built using both secondorder quan ..."
Abstract

Cited by 12 (4 self)
 Add to MetaCart
We describe a semantic type soundness result, formalized in the Coq proof assistant, for a compiler from a simple imperative language with heapallocated data into an idealized assembly language. Types in the highlevel language are interpreted as binary relations, built using both secondorder quantification and a form of separation structure, over stores and code pointers in the lowlevel machine.
Type Reconstruction with FirstClass Polymorphic Values
, 1989
"... We present the first type reconstruction system which combines the implicit typing of ML with the full power of the explicitly typed secondorder polymorphic lambda calculus. The system will accept MLstyle programs, explicitly typed programs, and programs that use explicit types for all firstclass ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
We present the first type reconstruction system which combines the implicit typing of ML with the full power of the explicitly typed secondorder polymorphic lambda calculus. The system will accept MLstyle programs, explicitly typed programs, and programs that use explicit types for all firstclass polymorphic values. We accomplish this flexibility by providing both generic and explicitlyquantified polymorphic types, as well as operators which convert between these two forms of polymorphism. This type reconstruction system is an integral part of the FX89 programming language. We present a type reconstruction algorithm for the system. The type reconstruction algorithm is proven sound and complete with respect to the formal typing rules.
Structural Polymorphism
 Informal Proceedings Workshop on Generic Programming, WGP'98, Marstrand
, 1998
"... This paper describes structural polymorphism, a new form of type polymorphism appropriate to functional languages featuring userdefined algebraic data types (e.g., Standard ML, Haskell and Miranda 1 ). The approach extends the familiar notion of parametric polymorphism by allowing the definition of ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
This paper describes structural polymorphism, a new form of type polymorphism appropriate to functional languages featuring userdefined algebraic data types (e.g., Standard ML, Haskell and Miranda 1 ). The approach extends the familiar notion of parametric polymorphism by allowing the definition of functions which are generic with respect to data structures as well as to individual types. For example, structural polymorphism accommodates generalizations of the usual length and map functions which may be applied not only to lists, but also to trees, binary trees or similar algebraic structures. Under traditional polymorphic type systems, these functions may be defined for arbitrary component types, but must be (laboriously) redefined for every distinct data structure. In this sense, our approach also extends the spirit of parametric polymorphism, in that it provides the programmer relief from the burden of unnecessary repetitive effort. The mechanism we will use to realize this form of polymorphism is inspired by a feature familiar to functional programmers, namely the pattern abstraction. Pattern abstractions generalize the usual lambda abstraction (x.e) in that they are comprised of multiple pattern/expression clauses, rather than just a single boundvariable/expression pair. By analogy with pattern abstractions, we generalize polymorphic type abstractions (Òå.e) to typepattern abstractions, which are comprised of multiple typepattern/expression pairs. The types given to typepattern abstractions are universally quantified, just as for traditional type abstractions, but the universal quantifiers are now justified by a recursive analysis of the forms of all possible type instantiations, rather than by parametric independence with respect to a type variable. (x:+.e) ...
An Introduction to Polymorphic Lambda Calculus
 Logical Foundations of Functional Programming
, 1994
"... Introduction to the Polymorphic Lambda Calculus John C. Reynolds Carnegie Mellon University December 23, 1994 The polymorphic (or secondorder) typed lambda calculus was invented by JeanYves Girard in 1971 [11, 10], and independently reinvented by myself in 1974 [24]. It is extraordinary that ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Introduction to the Polymorphic Lambda Calculus John C. Reynolds Carnegie Mellon University December 23, 1994 The polymorphic (or secondorder) typed lambda calculus was invented by JeanYves Girard in 1971 [11, 10], and independently reinvented by myself in 1974 [24]. It is extraordinary that essentially the same programming language was formulated independently by the two of us, especially since we were led to the language by entirely different motivations. In my own case, I was seeking to extend conventional typed programming languages to permit the definition of "polymorphic" procedures that could accept arguments of a variety of types. I started with the ordinary typed lambda calculus and added the ability to pass types as parameters (an idea that was "in the air" at the time, e.g. [4]). For example, as in the ordinary typed lambda calculus one can write f int!int : x int : f(f (x)) to denote the "doubling" function for the type int, which accepts a function from integers
Generic Operations on Nested Datatypes
, 2001
"... Nested datatypes are a generalisation of the class of regular datatypes, which includes familiar datatypes like trees and lists. They typically represent constraints on the values of regular datatypes and are therefore used to minimise the scope for programmer error. ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Nested datatypes are a generalisation of the class of regular datatypes, which includes familiar datatypes like trees and lists. They typically represent constraints on the values of regular datatypes and are therefore used to minimise the scope for programmer error.
ClassisType is Inadequate for Object Reuse
 ACM SIGPLAN Notices
, 2001
"... The concepts of the basic entities, i.e., objects, object classes, object types, etc., in the type hierarchy of objectoriented languages are revisited. The notion of object reuse is defined and elaborated. We show that while object classes are useful in object description and creation, the class ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
The concepts of the basic entities, i.e., objects, object classes, object types, etc., in the type hierarchy of objectoriented languages are revisited. The notion of object reuse is defined and elaborated. We show that while object classes are useful in object description and creation, the classistype principle which is used in many objectoriented languages is inadequate for object reuse. We also show that parameterized types and generic functions are better served by using kindbounded qualification than universal qualification and other mechanisms. Keywords: Object reuse, software integration, objects, classes, types, kinds, classistype principle, parameterized types, generic functions, kindbounded polymorphism 1
Building continuous webbed models for System F
, 2000
"... We present here a large family of concrete models for Girard and Reynolds polymorphism (System F ), in a non categorical setting. The family generalizes the construction of the model of Barbanera and Berardi [2], hence it contains complete models for F [5] and we conjecture that it contains models w ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We present here a large family of concrete models for Girard and Reynolds polymorphism (System F ), in a non categorical setting. The family generalizes the construction of the model of Barbanera and Berardi [2], hence it contains complete models for F [5] and we conjecture that it contains models which are complete for F . It also contains simpler models, the simplest of them, E 2 ; being a second order variant of the EngelerPlotkin model E . All the models here belong to the continuous semantics and have underlying prime algebraic domains, all have the maximum number of polymorphic maps. The class contains models which can be viewed as two intertwined compatible webbed models of untyped calculus (in the sense of [8]), but it is much larger than this. Finally many of its models might be read as two intertwined strict intersection type systems. Contents 1
Analyse Statique Comportementale des Langages de Programmation.
"... ogy (MIT), le Professeur David K. Gifford, mon colocataire de bureau transatlantique Mark A. Sheldon, Jim O'Toole, Franklyn Turbak, Michael "Ziggy" Blair, John Lucassen et Brian Reistad. ffl Au Laboratoire de Recherche en Informatique (LRI) de Paris XI, les Professeurs JeanPierre Jouannaud qui m' ..."
Abstract
 Add to MetaCart
ogy (MIT), le Professeur David K. Gifford, mon colocataire de bureau transatlantique Mark A. Sheldon, Jim O'Toole, Franklyn Turbak, Michael "Ziggy" Blair, John Lucassen et Brian Reistad. ffl Au Laboratoire de Recherche en Informatique (LRI) de Paris XI, les Professeurs JeanPierre Jouannaud qui m'a invit'e `a pr'esenter ma th`ese d'habilitation `a Paris XI et JeanPierre Sansonnet. ffl Au Centre de Recherche Bull, mon coauteur "industriel" Babak Dehbonei, G'erard Memmi et Nadia Tawbi. ffl A l'Etablissement Technique Central de l'Armement (ETCA), Serge Petiton et Philippe Clermont, maintenant `a HyParTech. ffl Au Programme de Recherches Coordonn'ees C3, Patrice Quinton, pour son financement. ffl A la Direction Recherche Et Technique (DRET), Philippe Sarrazin. De plus, Fran¸cois Irigoin, Corinne Ancourt, Philippe Bazet, Fran¸cois Masdupuy, et Babak Dehbonei ont particip'e `a la relecture de ce manuscr