Results 11  20
of
81
Full Abstraction for Functional Languages with Control
 In Proceedings, Twelfth Annual IEEE Symposium on Logic in Computer Science
, 1997
"... This paper considers the consequences of relaxing the bracketing condition on `dialogue games', showing that this leads to a category of games which can be `factorized' into a wellbracketed substructure, and a set of classically typed morphisms. These are shown to be sound denotations for control o ..."
Abstract

Cited by 62 (5 self)
 Add to MetaCart
This paper considers the consequences of relaxing the bracketing condition on `dialogue games', showing that this leads to a category of games which can be `factorized' into a wellbracketed substructure, and a set of classically typed morphisms. These are shown to be sound denotations for control operators, allowing the factorization to be used to extend the definability result for PCF to one for PCF with control operators at atomic types. Thus we define a fully abstract and effectively presentable model of a functional language with nonlocal control as part of a modular approach to modelling nonfunctional features using games. 1.
Total Correctness by Local Improvement in the Transformation of Functional Programs
 ACM Transactions on Programming Languages and Systems
, 1996
"... ion. A common form of transformation, which is easily justified by appealing to reversibility, is abstraction. The abstraction transformation lifts some instances of subexpressions from the righthand sides of a set of definitions and replaces them with function calls for some new functions. The ab ..."
Abstract

Cited by 61 (6 self)
 Add to MetaCart
ion. A common form of transformation, which is easily justified by appealing to reversibility, is abstraction. The abstraction transformation lifts some instances of subexpressions from the righthand sides of a set of definitions and replaces them with function calls for some new functions. The abstraction process can be used in conjunction with a callbyneed implementation to avoid repeated evaluation of subexpressions. A wellknown example is Hughes' supercombinator abstraction [Hughes 1982]. Another form of abstraction which is common in program transformation is syntactic generalization in which an expression e is replaced by a function call g e 1 : : : e n , where g is a new function defined by g x 1 : : : xn \Delta = e 0 , such that e j e 0 f e 1 : : : e n= x 1 : : : xn g. General statements about abstractions and their correctness are notationally rather complex. In practice we have found it is easier to appeal to a reversibility argument on a casebycase basis than...
Program extraction from classical proofs
 Annals of Pure and Applied Logic
, 1994
"... 1 Introduction It is well known that it is undecidable in general whether a given program meets its specification. In contrast, it can be checked easily by a machine whether a formal proof is correct, and from a constructive proof one can automatically extract a corresponding program, which by its v ..."
Abstract

Cited by 54 (9 self)
 Add to MetaCart
1 Introduction It is well known that it is undecidable in general whether a given program meets its specification. In contrast, it can be checked easily by a machine whether a formal proof is correct, and from a constructive proof one can automatically extract a corresponding program, which by its very construction is correct as well. This at least in principle opens a way to produce correct software, e.g. for safetycritical applications. Moreover, programs obtained from proofs are "commented " in a rather extreme sense. Therefore it is easy to maintain them, and also to adapt them to particular situations. We will concentrate on the question of classical versus constructive proofs. It is known that any classical proof of a specification of the form 8x9yB with B quantifierfree can be transformed into a constructive proof of the same formula. However, when it comes to extraction of a program from a proof obtained in this way, one easily ends up with a mess. Therefore, some refinements of the standard transformation are necessary.
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).
Fully abstract semantics for observably sequential languages
 Information and Computation
, 1994
"... One of the major challenges in denotational semantics is the construction of a fully abstract semantics for a higherorder sequential programming language. For the past fifteen years, research on this problem has focused on developing a semantics for PCF, an idealized functional programming language ..."
Abstract

Cited by 49 (4 self)
 Add to MetaCart
One of the major challenges in denotational semantics is the construction of a fully abstract semantics for a higherorder sequential programming language. For the past fifteen years, research on this problem has focused on developing a semantics for PCF, an idealized functional programming language based on the typed λcalculus. Unlike most practical languages, PCF has no facilities for observing and exploiting the evaluation order of arguments to procedures. Since we believe that these facilities play a crucial role in sequential computation, this paper focuses on a sequential extension of PCF, called SPCF, that includes two classes of control operators: a possibly empty set of error generators and a collection of catch and throw constructs. For each set of error generators, the paper presents a fully abstract semantics for SPCF. If the set of error generators is empty, the semantics interprets all procedures—including catch and throw—as BerryCurien sequential algorithms. If the language contains error generators, procedures denote manifestly sequential functions. The manifestly sequential functions form a Scott domain that is isomorphic to a domain of decision trees, which is the natural
Observable Sequentiality and Full Abstraction
 In Proceedings of POPL ’92
, 1992
"... ion Robert Cartwright Matthias Felleisen Department of Computer Science Rice University Houston, TX 772511892 Abstract One of the major challenges in denotational semantics is the construction of fully abstract models for sequential programming languages. For the past fifteen years, research o ..."
Abstract

Cited by 39 (5 self)
 Add to MetaCart
ion Robert Cartwright Matthias Felleisen Department of Computer Science Rice University Houston, TX 772511892 Abstract One of the major challenges in denotational semantics is the construction of fully abstract models for sequential programming languages. For the past fifteen years, research on this problem has focused on developing models for PCF, an idealized functional programming language based on the typed lambda calculus. Unlike most practical languages, PCF has no facilities for observing and exploiting the evaluation order of arguments in procedures. Since we believe that such facilities are crucial for understanding the nature of sequential computation, this paper focuses on a sequential extension of PCF (called SPCF) that includes two classes of control operators: error generators and escape handlers. These new control operators enable us to construct a fully abstract model for SPCF that interprets higher types as sets of errorsensitive functions instead of continuous...
Polymorphic type assignment and CPS conversion
 LISP and Symbolic Computation
, 1993
"... Meyer and Wand established that the type of a term in the simply typedcalculus may be related in a straightforward manner to the type of its callbyvalue CPS transform. This typing property maybe extended to Schemelike continuationpassing primitives, from which the soundness of these extensions ..."
Abstract

Cited by 35 (10 self)
 Add to MetaCart
Meyer and Wand established that the type of a term in the simply typedcalculus may be related in a straightforward manner to the type of its callbyvalue CPS transform. This typing property maybe extended to Schemelike continuationpassing primitives, from which the soundness of these extensions follows. We study the extension of these results to the DamasMilner polymorphic type assignment system under both the callbyvalue and callbyname interpretations. We obtain CPS transforms for the callbyvalue interpretation, provided that the polymorphic let is restricted to values, and for the callbyname interpretation with no restrictions. We prove that there is no callbyvalue CPS transform for the full DamasMilner language that validates the MeyerWand typing property and is equivalent to the standard callbyvalue transform up toconversion. 1
Operational Semantics for MultiLanguage Programs
, 2007
"... Interlanguage interoperability is big business, as the success of Microsoft’s.NET and COM and Sun’s JVM show. Programming language designers are designing programming languages that reflect that fact — SML#, Mondrian, and Scala, to name just a few examples, all treat interoperability with other lan ..."
Abstract

Cited by 33 (5 self)
 Add to MetaCart
Interlanguage interoperability is big business, as the success of Microsoft’s.NET and COM and Sun’s JVM show. Programming language designers are designing programming languages that reflect that fact — SML#, Mondrian, and Scala, to name just a few examples, all treat interoperability with other languages as a central design feature. Still, current multilanguage research tends not to focus on the semantics of interoperation features, but only on how to implement them efficiently. In this paper, we take first steps toward higherlevel models of interoperating systems. Our technique abstracts away the lowlevel details of interoperability like garbage collection and representation coherence, and lets us focus on semantic properties like typesafety and observable equivalence. Beyond giving simple expressive models that are natural compositions of singlelanguage models, our studies have uncovered several interesting facts about interoperability. For example, higherorder contracts naturally emerge as the glue to ensure that interoperating languages respect each other’s type systems. While we present our results in an abstract setting, they shed light on real multilanguage systems and tools such as the JNI, SWIG, and Haskell’s stable pointers.
Reasoning with Continuations II: Full Abstraction for Models of Control
 In Proceedings of the 1990 ACM Conference on Lisp and Functional Programming
, 1990
"... A fully abstract model of a programming language assigns the same meaning to two terms if and only if they have the same operational behavior. Such models are wellknown for functional languages but little is known about extended functional languages with sophisticated control structures. We show th ..."
Abstract

Cited by 32 (4 self)
 Add to MetaCart
A fully abstract model of a programming language assigns the same meaning to two terms if and only if they have the same operational behavior. Such models are wellknown for functional languages but little is known about extended functional languages with sophisticated control structures. We show that a direct model with error values and the conventional continuation model are adequate for functional languages augmented with first and higherorder control facilities, respectively. Furthermore, both models become fully abstract on adding a control delimiter and a parallel conditional to the programming languages.
A Syntactic Theory of Dynamic Binding
 HigherOrder and Symbolic Computation
, 1997
"... . Dynamic binding, which has always been associated with Lisp, is still semantically obscure to many. Although largely replaced by lexical scoping, not only does dynamic binding remain an interesting and expressive programming technique in specialised circumstances, but also it is a key notion in se ..."
Abstract

Cited by 32 (1 self)
 Add to MetaCart
. Dynamic binding, which has always been associated with Lisp, is still semantically obscure to many. Although largely replaced by lexical scoping, not only does dynamic binding remain an interesting and expressive programming technique in specialised circumstances, but also it is a key notion in semantics. This paper presents a syntactic theory that enables the programmer to perform equational reasoning on programs using dynamic binding. The theory is proved to be sound and complete with respect to derivations allowed on programs in "dynamicenvironment passing style". From this theory, we derive a sequential evaluation function in a contextrewriting system. Then, we exhibit the power and usefulness of dynamic binding in two different ways. First, we prove that dynamic binding adds expressiveness to a purely functional language. Second, we show that dynamic binding is an essential notion in semantics that can be used to define the semantics of exceptions. Afterwards, we further refin...