Results 1  10
of
119
Ownership Types for Flexible Alias Protection
 In ObjectOriented Programming, Systems, Languages, and Applications (OOPSLA
, 1998
"... Objectoriented programming languages allow interobject aliasing. Although necessary to construct linked data structures and networks of interacting objects, aliasing is problematic in that an aggregate object's state can change via an alias to one of its components, without the aggregate being awa ..."
Abstract

Cited by 332 (38 self)
 Add to MetaCart
Objectoriented programming languages allow interobject aliasing. Although necessary to construct linked data structures and networks of interacting objects, aliasing is problematic in that an aggregate object's state can change via an alias to one of its components, without the aggregate being aware of any aliasing. Ownership types form a static type system that indicates object ownership. This provides a flexible mechanism to limit the visibility of object references and restrict access paths to objects, thus controlling a system's dynamic topology. The type system is shown to be sound, and the specific aliasing properties that a system's object graph satisfies are formulated and proven invariant for welltyped programs. Keywords Alias protection, sharing, containment, ownership, representation exposure, programming language design 1
Manifest Types, Modules, and Separate Compilation
, 1994
"... This paper presents a variant of the SML module system that introduces a strict distinction between abstract types and manifest types (types whose de nitions are part of the module speci cation), while retaining most of the expressive power of the SML module system. The resulting module system pro ..."
Abstract

Cited by 224 (8 self)
 Add to MetaCart
This paper presents a variant of the SML module system that introduces a strict distinction between abstract types and manifest types (types whose de nitions are part of the module speci cation), while retaining most of the expressive power of the SML module system. The resulting module system provides much better support for separate compilation. 1
LambdaCalculus Schemata
, 1993
"... A lambdacalculus schema is an expression of the lambda calculus augmented by uninterpreted constant and operator symbols. It is an abstraction of programming languages such as LISP which permit functions to be passed to and returned from other functions. When given an interpretation for its constan ..."
Abstract

Cited by 101 (1 self)
 Add to MetaCart
A lambdacalculus schema is an expression of the lambda calculus augmented by uninterpreted constant and operator symbols. It is an abstraction of programming languages such as LISP which permit functions to be passed to and returned from other functions. When given an interpretation for its constant and operator symbols, certain schemata, called lambda abstractions, naturally define partial functions over the domain of interpretation. Two implementation strategies are considered: the retention strategy in which all variable bindings are retained until no longer needed (implying the use of some sort of garbagecollected store) and the deletion strategy, modeled after the usual stack implementation of ALGOL 60, in which variable bindings are destroyed when control leaves the procedure (or block) in which they were created. Not all lambda abstractions evaluate correctly under the deletion strategy. Nevertheless, both strategies are equally powerful in the sense that any lambda abstraction can be mechanically translated into another that evaluates correctly under the deletion strategy and defines the same partial function over the domain of interpretation as the original. Proof is by translation into continuationpassing style.
Simple Ownership Types for Object Containment
, 2001
"... Containment of objects is a natural concept that has been poorly supported in objectoriented programming languages. For a predefined set of ownership contexts, this paper presents a type system that enforces certain containment relationships for runtime objects. A fixed ordering relationship is pr ..."
Abstract

Cited by 90 (2 self)
 Add to MetaCart
Containment of objects is a natural concept that has been poorly supported in objectoriented programming languages. For a predefined set of ownership contexts, this paper presents a type system that enforces certain containment relationships for runtime objects. A fixed ordering relationship is presumed between the owners. The formalisation of ownership types has developed from our work with flexible alias protection together with an investigation of structural properties of object graphs based on dominator trees. Our general ownership type system permits fresh ownership contexts to be created at runtime. Here we present a simplified system in which the ownership contexts are predefined. This is powerful enough to express and enforce constraints about a system's highlevel structure. Our formal system is presented in an imperative variant of the object calculus. We present type preservation and soundness results. Furthermore we highlight how these type theoretic results establish a containment invariant for objects, in which access to contained objects is only permitted via their owners. In effect, the predefined ownership ordering restricts the permissible interobject reference structure.
A Generic Account of ContinuationPassing Styles
 Proceedings of the Twentyfirst Annual ACM Symposium on Principles of Programming Languages
, 1994
"... We unify previous work on the continuationpassing style (CPS) transformations in a generic framework based on Moggi's computational metalanguage. This framework is used to obtain CPS transformations for a variety of evaluation strategies and to characterize the corresponding administrative reducti ..."
Abstract

Cited by 87 (34 self)
 Add to MetaCart
We unify previous work on the continuationpassing style (CPS) transformations in a generic framework based on Moggi's computational metalanguage. This framework is used to obtain CPS transformations for a variety of evaluation strategies and to characterize the corresponding administrative reductions and inverse transformations. We establish generic formal connections between operational semantics and equational theories. Formal properties of transformations for specific evaluation orders follow as corollaries. Essentially, we factor transformations through Moggi's computational metalanguage. Mapping terms into the metalanguage captures computational properties (e.g., partiality, strictness) and evaluation order explicitly in both the term and the type structure of the metalanguage. The CPS transformation is then obtained by applying a generic transformation from terms and types in the metalanguage to CPS terms and types, based on a typed term representation of the continuation ...
Representing control: a study of the CPS transformation
, 1992
"... This paper investigates the transformation of v terms into continuationpassing style (CPS). We show that by appropriate jexpansion of Fischer and Plotkin's twopass equational specification of the CPS transform, we can obtain a static and contextfree separation of the result terms into "esse ..."
Abstract

Cited by 81 (7 self)
 Add to MetaCart
This paper investigates the transformation of v terms into continuationpassing style (CPS). We show that by appropriate jexpansion of Fischer and Plotkin's twopass equational specification of the CPS transform, we can obtain a static and contextfree separation of the result terms into "essential" and "administrative" constructs. Interpreting the former as syntax builders and the latter as directly executable code, we obtain a simple and efficient onepass transformation algorithm, easily extended to conditional expressions, recursive definitions, and similar constructs. This new transformation algorithm leads to a simpler proof of Plotkin's simulation and indifference results. Further we show how CPSbased control operators similar to but more general than Scheme's call/cc can be naturally accommodated by the new transformation algorithm. To demonstrate the expressive power of these operators, we use them to present an equivalent but even more concise formulation of t...
Modular Denotational Semantics for Compiler Construction
 In European Symposium on Programming
, 1996
"... . We show the benefits of applying modular monadic semantics to compiler construction. Modular monadic semantics allows us to define a language with a rich set of features from reusable building blocks, and use program transformation and equational reasoning to improve code. Compared to denotational ..."
Abstract

Cited by 55 (4 self)
 Add to MetaCart
. We show the benefits of applying modular monadic semantics to compiler construction. Modular monadic semantics allows us to define a language with a rich set of features from reusable building blocks, and use program transformation and equational reasoning to improve code. Compared to denotational semantics, reasoning in monadic style offers the added benefits of highly modularized proofs and more widely applicable results. To demonstrate, we present an axiomatization of environments, and use it to prove the correctness of a wellknown compilation technique. The monadic approach also facilitates generating code in various target languages with different sets of builtin features. 1 Introduction We propose a modular semantics which allows language designers to add (or remove) programming language features without causing global changes to the existing specification, derive a compilation scheme from semantic descriptions, prove the correctness of program transformation and compilation...
Typed Memory Management via Static Capabilities
 ACM Transactions on Programming Languages and Systems
, 2000
"... Machine We have described the type constructor language of CL and the typing rules for the main termlevel constructs. In fact, the previous section contains all of the ACM Transactions on Programming Languages and Systems, Vol. TBD, No. TDB, Month Year. 20 D. Walker, K. Crary, and G. Morriset ..."
Abstract

Cited by 54 (5 self)
 Add to MetaCart
Machine We have described the type constructor language of CL and the typing rules for the main termlevel constructs. In fact, the previous section contains all of the ACM Transactions on Programming Languages and Systems, Vol. TBD, No. TDB, Month Year. 20 D. Walker, K. Crary, and G. Morrisett #; #;# # h at r : # # # # f : Type #; ## # ; #{f :# f , x 1 :# 1 , . . . , xn :# n}; C # e # # f = #[# # ].(C, # 1 , . . . , #n ) # 0 at r f, x 1 , . . . , xn ## Dom(#) # #; #;# # fix f[# # ](C, x 1 :# 1 , . . . , xn :# n ).e at r : # f (hfix) #; #;# # v i : # i (for 1 # i # n) # # r : Rgn #; #;# # #v 1 , . . . , vn # at r : ## 1 , . . . , #n # at r (htuple) #; #;# # h at r : # # # # # # = # : Type #; #;# # h at r : # (heq) #; #;# # v : # #; #;# # x : # (#(x) = #) (vvar) #; #;# # i : int (vint) #; #;# # v : #[#:#, # # ].(C, # 1 , . . . , #n ) # 0 at r # # c : # #; #;# # v[c] : (#[# # ].(C, # 1 , . . . , #n ) # 0)[c/#] at r (vtype) #; #;# # v : #[# # C ## , # # ].(C # , # 1 , . . . , #n ) # 0 at r # # C # C ## #; #;# # v[C] : (#[# # ].(C # , # 1 , . . . , #n ) # 0)[C/#] at r (vsub) #; #;# # v : # # # # # # = # : Type #; #;# # v : # (veq) Fig. 6. Capability static semantics: Heap and word values. information programmers or compilers require to write typesafe programs in CL. However, in order to prove a type soundness result in the style of Wright and Felleisen [Wright and Felleisen 1994], we must be able to type check programs at every step during their evaluation. In this section, we give the static semantics of the runtime values that are not normally manipulated by programmers, but are nevertheless necessary to prove our soundness result. At first, the formal definition ...
Classical Logic, Continuation Semantics and Abstract Machines
, 1998
"... Machines Th. STREICHER Fachbereich 4 Mathematik, TU Darmstadt, Schlossgartenstr. 7, 64289 Darmstadt, streiche@mathematik.thdarmstadt.de B. REUS Institut fur Informatik, LudwigMaximiliansUniversitat, Oettingenstr. 67, D80538 Munchen, reus@informatik.unimuenchen.de Abstract One of the ..."
Abstract

Cited by 52 (4 self)
 Add to MetaCart
Machines Th. STREICHER Fachbereich 4 Mathematik, TU Darmstadt, Schlossgartenstr. 7, 64289 Darmstadt, streiche@mathematik.thdarmstadt.de B. REUS Institut fur Informatik, LudwigMaximiliansUniversitat, Oettingenstr. 67, D80538 Munchen, reus@informatik.unimuenchen.de Abstract One of the goals of this paper is to demonstrate that denotational semantics is useful for operational issues like implementation of functional languages by abstract machines. This is exemplified in a tutorial way by studying the case of extensional untyped callbyname calculus with Felleisen's control operator C. We derive the transition rules for an abstract machine from a continuation semantics which appears as a generalization of the ::translation known from logic. The resulting abstract machine appears as an extension of Krivine's Machine implementing head reduction. Though the result, namely Krivine's Machine, is well known our method of deriving it from continuation semantics is new and applicable to other languages (as e.g. callbyvalue variants).
Back to Direct Style
, 1994
"... This paper describes the transformation of lambdaterms from continuationpassing style (CPS) to direct style. This transformation is the left inverse of Plotkin's lefttoright callbyvalue CPS encoding for the pure lambdacalculus. Not all terms are CPS terms, and not all CPS terms encode a left ..."
Abstract

Cited by 49 (22 self)
 Add to MetaCart
This paper describes the transformation of lambdaterms from continuationpassing style (CPS) to direct style. This transformation is the left inverse of Plotkin's lefttoright callbyvalue CPS encoding for the pure lambdacalculus. Not all terms are CPS terms, and not all CPS terms encode a lefttoright callbyvalue evaluation. These CPS terms are characterized here; they can be mapped back to direct style. In addition, the two transformations  to continuationpassing style and to direct style  are factored using a language where all intermediate values are named and their computation is sequentialized. The issue of proper tailrecursion is also addressed.