Machines Th. STREICHER Fachbereich 4 Mathematik, TU Darmstadt, Schlossgartenstr. 7, 64289 Darmstadt, streiche@mathematik.th-darmstadt.de B. REUS Institut fur Informatik, Ludwig-Maximilians-Universitat, Oettingenstr. 67, D-80538 Munchen, reus@informatik.uni-muenchen.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 call-byname -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. call-by-value variants).

Abstract not found

. Call-by-push-value is a new paradigm that subsumes the call-by-name and call-by-value paradigms, in the following sense: both operational and denotational semantics for those paradigms can be seen as arising, via translations that we will provide, from similar semantics for call-by-push-value. To explain call-by-push-value, we first discuss general operational ideas, especially the distinction between values and computations, using the principle that "a value is, a computation does". Using an example program, we see that the lambda-calculus primitives can be understood as push/pop commands for an operand-stack. We provide operational and denotational semantics for a range of computational effects and show their agreement. We hence obtain semantics for call-by-name and call-by-value, of which some are familiar, some are new and some were known but previously appeared mysterious. 1 Introduction 1.1 Contribution In his invited lecture at POPL '98 [32], Reynolds, surveying over 30 year...

Most type systems are agnostic regarding the evaluation strategy for the underlying languages, with the value restriction for ML which is absent in Haskell as a notable exception. As type systems become more precise, however, detailed properties of the operational semantics may become visible because properties captured by the types may be sound under one strategy but not the other. For example, intersection types distinguish between call-by-name and call-by-value functions, because the subtyping law (A → B) ∩ (A → C) ≤ A → (B ∩ C) is unsound for the latter in the presence of effects. In this paper we develop a proof-theoretic framework for analyzing the interaction of types with evaluation order, based on the notion of polarity. Polarity was discovered through linear logic, but we propose a fresh origin in Dummett’s program of justifying the logical laws through alternative verificationist or pragmatist “meaning-theories”, which include a bias towards either introduction or elimination rules. We revisit Dummett’s analysis using the tools of Martin-Löf’s judgmental method, and then show how to extend it to a unified polarized logic, with Girard’s “shift ” connectives acting as intermediaries. This logic safely combines intuitionistic and dual intuitionistic reasoning principles, while simultaneously admitting a focusing interpretation for the classical sequent calculus. Then, by applying the Curry-Howard isomorphism to polarized logic, we obtain a single programming language in which evaluation order is reflected at the level of types. Different logical notions correspond directly to natural programming constructs, such as pattern-matching, explicit substitutions, values and call-by-value continuations. We give examples demonstrating the expressiveness of the language and type system, and prove a basic but modular type safety result. We conclude with a brief discussion of extensions to the language with additional effects and types, and sketch the sort of explanation this can provide for operationally-sensitive typing phenomena. 1

Most type systems are agnostic regarding the evaluation strategy for the underlying languages, with the value restriction for ML which is absent in Haskell as a notable exception. As type systems become more precise, however, detailed properties of the underlying operational semantics may become visible because properties captured by the types may be sound under one strategy but not the other. To give an example, intersection types distinguish between call-by-name and call-by-value functions because the subtyping rule (A → B) ∩ (A → C) ≤ A → (B ∩ C) is valid for the former but not the latter in the presence of effects. I propose to develop a unified, proof-theoretic approach to analyzing the interaction of types with evaluation order, based on the notion of polarity. Polarity was discovered and developed through linear logic, but I seek a fresh origin in Dummett’s program of justifying the logical laws through alternative “meaning-theories, ” essentially hypotheses as to whether the verification or use of a proposition has a canonical form. In my preliminary work, I showed how a careful judgmental analysis of Dummett’s ideas may be used to define a system of proofs and refutations, with a Curry-Howard interpretation as a single programming language in which the duality between call-by-value and call-by-name is realized as one of types. After extending its type system with (both positive and negative) union and intersection operators and a derived subtyping relationship, I found that many operationally-sensitive typing phenomena (e.g., alternative CBV/CBN subtyping distributivity principles, value and “covalue” restrictions) could be logically reconstructed. Here I give the technical details of this work, and present a plan for addressing open questions and extensions.

The duality of computation under focus Pierre-Louis Curien (CNRS and Paris 7) and Guillaume Munch-Maccagnoni (Paris 7) Abstract. We use the infrastructure of Curien-Herbelin’s λµ˜µ-calculus to provide a syntax with patterns for a (weakly) focalised version of LK, which we call LKQ given its close relation with Danos-Joinet-Schellinx’s LKQ. Exploiting a simple game of patterns and counterpatterns, we then move on to a fully focalised syntax close to Girard’s ludics and Zeilberger’s CU. We also provide a version of our syntax closer to Girard’s original LC (the first constructivisation of classical logic) and show its usefulness as the target of a translation of a mixed call-byname/call-by-value language. 1

The duality of computation under focus

Abstract. We study call-by-need from the point of view of the duality between call-by-name and call-by-value. We develop sequent-calculus style versions of call-by-need both in the minimal and classical case. As a result, we obtain a natural extension of call-by-need with control operators. This leads us to introduce a call-by-need λµ-calculus. Finally, by using the dualities principles of λµ˜µ-calculus, we show the existence of a new call-by-need calculus, which is distinct from call-by-name, call-byvalue and usual call-by-need theories.