Results 1 
7 of
7
Type Inference for Record Concatenation and Multiple Inheritance
, 1989
"... We show that the type inference problem for a lambda calculus with records, including a record concatenation operator, is decidable. We show that this calculus does not have principal types, but does have finite complete sets of types: that is, for any term M in the calculus, there exists an effecti ..."
Abstract

Cited by 114 (2 self)
 Add to MetaCart
We show that the type inference problem for a lambda calculus with records, including a record concatenation operator, is decidable. We show that this calculus does not have principal types, but does have finite complete sets of types: that is, for any term M in the calculus, there exists an effectively generable finite set of type schemes such that every typing for M is an instance of one the schemes in the set. We show how a simple model of objectoriented programming, including hidden instance variables and multiple inheritance, may be coded in this calculus. We conclude that type inference is decidable for objectoriented programs, even with multiple inheritance and classes as firstclass values. 1. Introduction A practical motivation for type inference is to ensure an operational safety property of programs that are welltyped: that is, when we execute a welltyped program, we are guaranteed that we will never get an error message such as "bad function nil." Our goal is to ext...
Decidable Bounded Quantification
 IN 21ST ACM SYMP. ON PRINCIPLES OF PROGRAMMING LANGUAGES
, 1994
"... The standard formulation of bounded quantification, system F , is difficult to work with and lacks important syntactic properties, such as decidability. More tractable variants have been studied, but those studied so far either exclude significant classes of useful programs or lack a compelling ..."
Abstract

Cited by 26 (3 self)
 Add to MetaCart
The standard formulation of bounded quantification, system F , is difficult to work with and lacks important syntactic properties, such as decidability. More tractable variants have been studied, but those studied so far either exclude significant classes of useful programs or lack a compelling semantics. We propose
A Theory of Stack Allocation in Polymorphically Typed Languages
, 1993
"... We present a stackallocation scheme for the callbyvalue lambda calculus typed according to Milner's polymorphic type discipline. All the values a program produces, including function closures, are put into regions at runtime. Regions are allocated and deallocated in a stacklike manner. Region in ..."
Abstract

Cited by 24 (6 self)
 Add to MetaCart
We present a stackallocation scheme for the callbyvalue lambda calculus typed according to Milner's polymorphic type discipline. All the values a program produces, including function closures, are put into regions at runtime. Regions are allocated and deallocated in a stacklike manner. Region inference and effect inference is used to infer where regions can be allocated and deallocated. By allowing a limited form of polymorphic recursion in region types, the region inference is able to distinguish between the lifetimes of different invocations of a function, even when the function is recursive. The region analysis is eager in its attempt to reclaim memory as quickly as possible. The main result of this report is that region inference is safe, a result which entails that regions really can be deallocated, when region inference says they can. We give detailed proofs of this claim, which (in various forms) has been advanced several times in the literature. An algorithm for implementi...
A Library for LightWeight InformationFlow Security in Haskell
"... Protecting confidentiality of data has become increasingly important for computing systems. Informationflow techniques have been developed over the years to achieve that purpose, leading to specialpurpose languages that guarantee informationflow security in programs. However, rather than producin ..."
Abstract

Cited by 24 (7 self)
 Add to MetaCart
Protecting confidentiality of data has become increasingly important for computing systems. Informationflow techniques have been developed over the years to achieve that purpose, leading to specialpurpose languages that guarantee informationflow security in programs. However, rather than producing a new language from scratch, informationflow security can also be provided as a library. This has been done previously in Haskell using the arrow framework. In this paper, we show that arrows are not necessary to design such libraries and that a less general notion, namely monads, is sufficient to achieve the same goals. We present a monadic library to provide informationflow security for Haskell programs. The library introduces mechanisms to protect confidentiality of data for pure computations, that we then easily, and modularly, extend to include dealing with sideeffects. We also present combinators to dynamically enforce different declassification policies when release of information is required in a controlled manner. It is possible to enforce policies related to what, by whom, and when information is released or a combination of them. The wellknown concept of monads together with the lightweight characteristic of our approach makes the library suitable to build applications where confidentiality of data is an issue.
Embedding Type Structure in Semantics
, 1985
"... We show how a programming language designer may embed the type structure of of a programming language in the more robust type structure of the typed lambda calculus. This is done by translating programs of the language into terms of the typed lambda calculus. Our translation, however, does not alway ..."
Abstract

Cited by 13 (1 self)
 Add to MetaCart
We show how a programming language designer may embed the type structure of of a programming language in the more robust type structure of the typed lambda calculus. This is done by translating programs of the language into terms of the typed lambda calculus. Our translation, however, does not always yield a welltyped lambda term. Programs whose translations are not welltyped are considered meaningless, that is, illtyped. We give a conditionally typecorrect semantics for a simple language with continuation semantics. We provide a set of static typechecking rules for our source language, and prove that they are sound and complete: that is, a program passes the typing rules if and only if its translation is welltyped. This proves the correctness of our static semantics relative to the wellestablished typing rules of the typed lambdacalculus. 1. Introduction Denotational semantics has proved to be a powerful language for expressing the language designer's decisions about the beh...
A realistic compiler generator based on highlevel semantics
 In Fourteenth Symposium on Principles of Programming Languages
, 1987
"... peteOCAELN.engin.UMich.EDU We have developed a new style of semantic definition called highlevel semantics. In constrast to traditional denotational semantics, highlevel semantics is suitable for both defining the functional meaning of programming languages, as well as describing realistic compi ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
peteOCAELN.engin.UMich.EDU We have developed a new style of semantic definition called highlevel semantics. In constrast to traditional denotational semantics, highlevel semantics is suitable for both defining the functional meaning of programming languages, as well as describing realistic compiler implcmentations. Moreover, highlevel specifications are considerably more descriptive and intelligible than traditional specifications. This paper describer the compiler generator MESS, which embodies the principles of highlevel semantics. MESS has been used to generate compilers for nontrivial languages. The compilers are efficient, and produce object programs that are competitive with those generated by handwritten compilers. 1
Type Inference for Record Concatenation and Multiple Inheritance
, 1989
"... We show that the type inference problem for a lambda calculus with records, including a record concatenation operator, is decidable. We show that this calculus does not have principal types, but does have finite complete sets of types: that is, for any term M in the calculus, there exists an effecti ..."
Abstract
 Add to MetaCart
We show that the type inference problem for a lambda calculus with records, including a record concatenation operator, is decidable. We show that this calculus does not have principal types, but does have finite complete sets of types: that is, for any term M in the calculus, there exists an effectively generable finite set of type schemes such that every typing for M is an instance of one the schemes in the set. We show how a simple model of objectoriented programming, including hidden instance variables and multiple inheritance, may be coded in this calculus. We conclude that type inference is decidable for objectoriented programs, even with multiple inheritance and classes as firstclass values. 3 1. Introduction A practical motivation for type inference is to ensure an operational safety property of programs that are welltyped: that is, when we execute a welltyped program, we are guaranteed that we will never get an error message such as "bad function nil." Our goal is to e...