Results 1  10
of
17
Type Theories and ObjectOriented Programming
 ACM Computing Surveys
, 1988
"... Objectoriented programming is becoming a popular approach to the construction of complex software systems. Benefits of object orientation include support for modular design, code sharing, and extensibility. In order to make the most of these advantages, a type theory for objects and their interacti ..."
Abstract

Cited by 54 (0 self)
 Add to MetaCart
Objectoriented programming is becoming a popular approach to the construction of complex software systems. Benefits of object orientation include support for modular design, code sharing, and extensibility. In order to make the most of these advantages, a type theory for objects and their interactions should be developed to aid checking and
Sage: Hybrid checking for flexible specifications
 In Scheme and Functional Programming Workshop
, 2006
"... ..."
(Show Context)
Programming Metalogics with a Fixpoint Type
, 1992
"... A programming metalogic is a formal system into which programming languages can be translated and given meaning. The translation should both reflect the structure of the language and make it easy to prove properties of programs. This thesis develops certain metalogics using techniques of category th ..."
Abstract

Cited by 12 (6 self)
 Add to MetaCart
A programming metalogic is a formal system into which programming languages can be translated and given meaning. The translation should both reflect the structure of the language and make it easy to prove properties of programs. This thesis develops certain metalogics using techniques of category theory and treats recursion in a new way. The notion of a category with fixpoint object is defined. Corresponding to this categorical structure there are type theoretic equational rules which will be present in all of the metalogics considered. These rules define the fixpoint type which will allow the interpretation of recursive declarations. With these core notions FIX categories are defined. These are the categorical equivalent of an equational logic which can be viewed as a very basic programming metalogic. Recursion is treated both syntactically and categorically. The expressive power of the equational logic is increased by embedding it in an intuitionistic predicate calculus, giving rise to the FIX logic. This contains propositions about the evaluation of computations to values and an induction principle which is derived from the definition of a fixpoint object as an initial algebra. The categorical structure which accompanies the FIX logic is defined, called a FIX hyperdoctrine, and certain existence and disjunction properties of FIX are stated. A particular FIX hyperdoctrine is constructed and used in the proof of the same properties. PCFstyle languages are translated into the FIX logic and computational adequacy reaulta are proved. Two languages are studied: Both are similar to PCF except one has call by value recursive function declararations and the other higher order conditionals. ...
Dependent types and program equivalence
 In Proceedings of the 37th ACM SIGACTSIGPLAN Symposium on Principles of Programming Languages (POPL). ACM
, 2009
"... The definition of type equivalence is one of the most important design issues for any typed language. In dependentlytyped languages, because terms appear in types, this definition must rely on a definition of term equivalence. In that case, decidability of type checking requires decidability for the ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
(Show Context)
The definition of type equivalence is one of the most important design issues for any typed language. In dependentlytyped languages, because terms appear in types, this definition must rely on a definition of term equivalence. In that case, decidability of type checking requires decidability for the term equivalence relation. Almost all dependentlytyped languages require this relation to be decidable. Some, such as Coq, Epigram or Agda, do so by employing analyses to force all programs to terminate. Conversely, others, such as DML, ATS, Ωmega, or Haskell, allow nonterminating computation, but do not allow those terms to appear in types. Instead, they identify a terminating index language and use singleton types to connect indices to computation. In both cases, decidable type checking comes at a cost, in terms of complexity and expressiveness. Conversely, the benefits to be gained by decidable type checking are modest. Termination analyses allow dependently typed programs to verify total correctness properties. However, decidable type checking is not a prerequisite for type safety. Furthermore, decidability does not imply tractability. A decidable approximation of program equivalence may not be useful in practice. Therefore, we take a different approach: instead of a fixed notion for term equivalence, we parameterize our type system with an abstract relation that is not necessarily decidable. We then design a novel set of typing rules that require only weak properties of this abstract relation in the proof of the preservation and progress lemmas. This design provides flexibility: we compare valid instantiations of term equivalence which range from betaequivalence, to contextual equivalence, to some exotic equivalences.
The Open Calculus of Constructions: An Equational Type Theory with Dependent Types for Programming, Specification, and Interactive Theorem Proving
"... The open calculus of constructions integrates key features of MartinLöf's type theory, the calculus of constructions, Membership Equational Logic, and Rewriting Logic into a single uniform language. The two key ingredients are dependent function types and conditional rewriting modulo equatio ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
The open calculus of constructions integrates key features of MartinLöf's type theory, the calculus of constructions, Membership Equational Logic, and Rewriting Logic into a single uniform language. The two key ingredients are dependent function types and conditional rewriting modulo equational theories. We explore the open calculus of constructions as a uniform framework for programming, specification and interactive verification in an equational higherorder style. By having equational logic and rewriting logic as executable sublogics we preserve the advantages of a firstorder semantic and logical framework and especially target applications involving symbolic computation and symbolic execution of nondeterministic and concurrent systems.
System FC with Explicit Kind Equality
"... System FC, the core language of the Glasgow Haskell Compiler, is an explicitlytyped variant of System F with firstclass type equality proofs called coercions. This extensible proof system forms the foundation for type system extensions such as type families (typelevel functions) and Generalized Al ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
(Show Context)
System FC, the core language of the Glasgow Haskell Compiler, is an explicitlytyped variant of System F with firstclass type equality proofs called coercions. This extensible proof system forms the foundation for type system extensions such as type families (typelevel functions) and Generalized Algebraic Datatypes (GADTs). Such features, in conjunction with kind polymorphism and datatype promotion, support expressive compiletime reasoning. However, the core language lacks explicit kind equality proofs. As a result, typelevel computation does not have access to kindlevel functions or promoted GADTs, the typelevel analogues to expressionlevel features that have been so useful. In this paper, we eliminate such discrepancies by introducing kind equalities to System FC. Our approach is based on dependent type systems with heterogeneous equality and the “TypeinType ” axiom, yet it preserves the metatheoretic properties of FC. In particular, type checking is simple, decidable and syntax directed. We prove the preservation and progress theorems for the extended language.
ΠΣ: A Core Language for Dependently Typed Programming
 ICFP
, 2008
"... We introduce ΠΣ, a core language for dependently typed programming. Our intention is that ΠΣ should play the role extensions of System F are playing for conventional functional languages with polymorphism, like Haskell. The core language incorporates mutual dependent recursive definitions, Type: Typ ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
We introduce ΠΣ, a core language for dependently typed programming. Our intention is that ΠΣ should play the role extensions of System F are playing for conventional functional languages with polymorphism, like Haskell. The core language incorporates mutual dependent recursive definitions, Type: Type, Π and Σtypes, finite sets of labels and explicit constraints. We show that standard constructions in dependently typed programming can be easily encoded in our language. We address some important issues: having an equality checker which unfolds recursion only when needed, avoiding looping when typechecking sensible programs; the simplification of type checking for eliminators like case by using equational constraints, allowing the flexible use of case expressions within dependently typed programming and the representation of dependent datatypes using explicit constraints.
Polytypic Functional Programming and Data Abstraction
, 2006
"... Structural polymorphism is a generic programming technique known within the functional programming community under the names of polytypic or datatypegeneric programming. In this thesis we show that such a technique conflicts with the principle of data abstraction and propose a solution for reconcil ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Structural polymorphism is a generic programming technique known within the functional programming community under the names of polytypic or datatypegeneric programming. In this thesis we show that such a technique conflicts with the principle of data abstraction and propose a solution for reconciliation. More concretely, we show that popular polytypic extensions of the functional programming language Haskell, namely, Generic Haskell and Scrap your Boilerplate have their genericity limited by data abstraction. We propose an extension to the Generic Haskell language where the `structure' in `structural polymorphism' is defined around the concept of interface and not the representation of a type.
The Probe Project
, 1992
"... This report presents a detailed overview of the issues concerning the construction of an object database system called Probe. Probe is based on the Ten15 persistent programming language, exploiting its strong type system and flexible persistence mechanism to build an efficient and malleable database ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
This report presents a detailed overview of the issues concerning the construction of an object database system called Probe. Probe is based on the Ten15 persistent programming language, exploiting its strong type system and flexible persistence mechanism to build an efficient and malleable database system. This document describes the Probe system and identifies the criteria for a successful database programming language. The success to which Probe matches these ideals is discussed. Probe is a based on a hierarchy of Ten15 data structures: data structures which manipulate the persistent store; which are used as a basis for database and bulk data structures; and a programming notation which provides a seamless programming environment for the abstract machine that Probe provides. A section of this document makes particular reference to the conceptual programming language for the system, called TDBPL. This page is left intentionally blank 1. Introduction Databases and programming lan...
Acknowledgments
"... The most thanks for this thesis go to Stephanie Weirich, who has been a fantastic research advisor and mentor. Stephanie always has time for her students—whenever I ran into technical difficulties she seemed genuinely happy to drop everything else to work together on the whiteboard (where her skills ..."
Abstract
 Add to MetaCart
The most thanks for this thesis go to Stephanie Weirich, who has been a fantastic research advisor and mentor. Stephanie always has time for her students—whenever I ran into technical difficulties she seemed genuinely happy to drop everything else to work together on the whiteboard (where her skills are very impressive). Her enthusiasm is contagious, and I always leave her office happy and full of energy. All in all I could not wish for a better phd advisor. The work described in this thesis came out of the Trellys project, and I benefitted very much from cooperation with the rest of the Trellys team. Their contributions are described in more detail in Section 1.2. Here I would like to particularly thank two of them. Chris Casinghino was my closest collaborator at Penn. Both our research (on two different parts of the same programming language) was improved by having someone to bounce ideas with. Aaron Stump was a constant source of new ideas and insights. I would also like to thank him for inviting me to spend a very enjoyable summer visiting the University of Iowa. The University of Pennsylvania is a great place to be a programming languages student. The Penn PL Club is a vibrant and tightlyknit place, the faculty (Benjamin Pierce and Steve Zdancewic) are very helpful to everyone in the group, and the students and postdocs always have interesting research projects to talk about. Special thanks to the plclub people who I shared my office with over the years—it was lots of fun chatting with you all the time! When typesetting this document, two very helpful tools were Ott by Sewell et al. [115], and pulp by Daniel Wagner.1