Results 1 
9 of
9
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 49 (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
"... ..."
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. ...
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 equational t ..."
Abstract

Cited by 5 (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.
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 3 (1 self)
 Add to MetaCart
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.
An Implementation of Type:Type
, 2000
"... We present a denotational semantics of a type system with dependent types, where types are interpreted as finitary projections. We prove then the correctness of a typechecking algorithm w.r.t. this semantics. In this way, we can justify some simple optimisation in this algorithm. We then sketch h ..."
Abstract
 Add to MetaCart
We present a denotational semantics of a type system with dependent types, where types are interpreted as finitary projections. We prove then the correctness of a typechecking algorithm w.r.t. this semantics. In this way, we can justify some simple optimisation in this algorithm. We then sketch how to extend this semantics to allow a simple record mechanism with manifest fields.
Draft for submission to ICFP 2013 Towards dependently typed Haskell: System FC with 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
 Add to MetaCart
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. 1.
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
 Add to MetaCart
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.