Monadic translation of classical sequent calculus

We introduce a domain-free $\lambda\mu$-calculus of call-by-value as a short-hand for the second order Church-style. Our motivation comes from the observation that in Curry-style polymorphic calculi, control operators such as ${\tt callcc}$ or $\mu$-operators cannot, in general, handle correctly the terms placed on the control operator's left, so that the Curry-style system can fail to prove the subject reduction property. Following the continuation semantics, we also discuss the notion of values in classical system, and propose an extended form of values. It is proved that the CPS-translation is sound with respect to domain-free $\lambda 2$ (second-order $\lambda$-calculus). As a by-product, we obtain the strong normalization property for the second-order $\lambda\mu$-calculus of call-by-value in domain-free style. We also study the problems of type inference, typability, and type checking for the call-by-value system. Finally, we give a brief comparison with standard ML plus c...

The monadic style of language specification [6, 16, 15, 26] has the advantages of modularity and extensibility: it is simple to add or change features in an interpreter to reflect modifications in the source language. It has proven difficult to extend the method to compilation, because there is considerable interaction between different features. We demonstrate that by introducing machine-like stores (code and data) into the monadic semantics (to achieve pass separation [12]) and then partially evaluating the resulting semantic expressions, we can achieve many of the same advantages for a compiler as for an interpreter. A number of language constructs and features are compiled: expressions, while loops, CBV and CBN evaluation of -expressions, dynamic scoping, and various imperative features. The treatment of recursive procedures is outlined as well. The resulting method allows compilers to be constructed in a mix-and-match fashion just as in a monad-structured interpreter. K...

Logical Methods in Computer Science, 2005

We present an abstract machine and a reduction semantics for the λ-calculus extended with control operators that give access to delimited continuations in the CPS hierarchy. The abstract machine is derived from an evaluator in continuation-passing style (CPS); the reduction semantics (i.e., a small-step operational semantics with an explicit representation of evaluation contexts) is constructed from the abstract machine; and the control operators are the shift and reset family. At level n of the CPS hierarchy, programs can use the control operators shift i and reset i for 1 ≤ i ≤ n, the evaluator has n + 1 layers of continuations, the abstract machine has n + 1 layers of control stacks, and the reduction semantics has n + 1 layers of evaluation contexts.

Electronic Notes in Theoretical Computer Science, 1999

We de ne a typed compiler intermediate language, MIL-lite, which incorporates computational types re ned with e ect information. We characterise MIL-lite observational congruence by using Howe's method to prove a ciu theorem for the language in terms of a termination predicate de ned directly on the term. We then de ne a logical predicate which captures an observable version of the intended meaning of each of our e ect annotations. Having proved the fundamental theorem for this predicate, we use it with the ciu theorem to validate a number of e ect-based transformations performed by the MLj compiler for Standard ML.

Information Processing Letters, 1995

The classical notion of P-reduction in the A-calculus has an arbitrary syntactically-imposed sequentiality. A new notion of reduction fi' is defined which is a generalization of P-reduction. This notion of reduction is shown to satisfy the Church-Rosser property as well as some other fundamental properties, leading to the conclusion that this generalized notion of P'-reduction can be used in place of p-reduction without sacrificing any of the fundamental properties.

Fixed Points in Computer Science, 2003

Recently, higher-rank datatypes have drawn interest in the functional pro grainming community [0ka99,0ka96,HinOl]. Rank-2 non-regular types, so-called nested datatypes, have been investigated in the context of Haskell. To define total functions which traverse nested datastructures, Bird et al. [B P99] have developed generalized folds which implement an iteration scheme and are strong enough to encode most of the known algorithms for nested datatypes. In this note, we in vestigate a scheme to overcome some limitations of iteration which we expound in the following. Since the work of Böhm et al. [BB85] it is well-known that iteration for rank-1 datatypes can be simulated in typed lambda-calculi. The easiest examples are iterative definitions of addition and multiplication for Church numerals. The iterative definition of the predecessor, however, is inefficient: It traverses the whole numeral in order to remove one constructor. Surely, taking the predecessor should run in constant time. Primitive recursion is the combination of iteration and efficient predecessor. A typical example for a prim. rec. algorithm is the natural definition of the factorial function. It is common belief that prim. rec. cannot be reduced to it eration in a computationally faithful manner. This is because no encoding of natural numbers in the polymorphic lambda-calculus (System F) seems possible which supports a constant-time predecessor operation (see Splawski and Urzy czyn [SU99]). Mendler extended System F by a scheme of prim. rec. for rank-i datatypes and proved strong normalization [Men87]. Mendler's formulation does not follow the usual category-theoretic approach with initial recursive algebras (see Geuvers [Geu92]). For rank-2 datatypes there are also examples of functions which can most naturally be implemented with prim. rec. One is redecoration for triangular ma- ti-ices which is presented below. These examples are not instances of generalized folds a Ia Bird et al., which remain within the realm of iteration but hardwire Kan extensions into the recursion scheme. Rank-2 prim. rec., which we propose in this work, seeks to extend rank-2 iteration in the same way that prim. rec. extends rank-i iteration. We achieve this by lifting Mendler's scheme of prim. rec. to rank 2. The decision for Mendler-style and against the traditional way roots in the following observation: Experiments with formulations according to the traditional style showed unnecessary but unavoidable traversals of the whole data structures in our examples. Mendler's style, however, yielded precisely the The first author is supported by the GraduiertenkoUeg "Logik in der Informatik" of the Deutsche Forschungsgemeinschaft. Both authors acknowledge financial support by ETAPS 2003. desired efficient reduction behavior. This was crucial since the only reason to incorporate prim. rec. is operational efficiency as opposed to denotational ex pressiveness. We work within the framework System F" of higher-order parametric poly morphism formulated in Curry-style, i.e., as a type assignment system for the pure lambda-calculus. For type transformers X, Y : * -* * we abbreviate the type of natural transformations VA. XA -* YA from X to Y by X C Y. Let id = .Xx.x denote the identity function. We extend the framework by a new constructor constant p and two term constants in and MRec and a new reduction rule as follows. Formation. p :((*-+*)--**-+*)-+*-+* Introduction. in VF'-'. F (pF) ç pF Elimination. MRec : VF(**) (VX. X C pF - X ç C -, F X ç C) -pF ç C Reduction. MRecs(int) -+ a id(MRecs)t The type transfomer pF : * -+ * is the least fixed-point of the constructor F : (* -÷ *) -, * -* and denotes a simultaneously defined family of types of well-founded trees, their shape depending on F. For instance, using F = ),X),A. 1 + A x X A the well-known type of polymorphic lists is recovered. The term in is the general constructor, which, in case of lists, codes together nil and cons. The term MRec establishes a scheme of primitive recursion in the style of Mendler. Typical for this style is the universally quantified constructor variable X in the type of the step term a which ensures termination without any positivity restrictions on F. During reduction, X is instantiated by pF, and the first parameter, i: X C pF, by id. The presence of a transformation i from the blank type X back into the fixed-point pF is what distinguishes Mendler-style prim. rec. from Mendler-style iteration.

Theoretical Computer Science, 2005

We extend our correspondence between evaluators and abstract machines from the pure setting of the λ-calculus to the impure setting of the computational λ-calculus. Specifically, we show how to derive new abstract machines from monadic evaluators for the computational λ-calculus. Starting from a monadic evaluator and a given monad, we inline the components of the monad in the evaluator and we derive the corresponding abstract machine by closure-converting, CPS-transforming, and defunctionalizing this inlined interpreter. We illustrate the construction first with the identity monad, obtaining yet again the CEK machine, and then with a state monad, an exception monad, and a combination of both.

Electronic Notes in Theoretical Computer Science, 2001

Plotkin has advocated the combination of linear lambda calculus, polymorphism and fixed point recursion as an expressive semantic metalanguage. We study its expressive power from an operational point of view. We show that the naturally call-by-value operators of linear lambda calculus can be given a call-by-name semantics without affecting termination at exponential types and hence without affecting ground contextual equivalence. This result is used to prove properties of a logical relation that provides a new extensional characterisation of ground contextual equivalence and relational parametricity properties of polymorphic types.

The notion of delimited continuations has been proved useful in various areas of computer programming such as partial evaluation, mobile computing, and web transaction. In our previous work, we proposed polymorphic calculi with control operators for delimited continuations. This paper presents a proof of strong normal- ization (SN) of these calculi based on a refined (i.e. administrative redex-free) CPS translation.

Proceedings of the 21st International Symposium on Principles and Practice of Programming Languages 2019, 2019

We observe that normalization by evaluation for simply-typed lambda-calculus with weak coproducts can be carried out in a weak bi-cartesian closed category of presheaves equipped with a monad that allows us to perform case distinction on neutral terms of sum type. The placement of the monad influences the normal forms we obtain: for instance, placing the monad on coproducts gives us eta-long beta-pi normal forms where pi refers to permutation of case distinctions out of elimination positions. We further observe that placing the monad on every coproduct is rather wasteful, and an optimal placement of the monad can be determined by considering polarized simple types inspired by focalization. Polarization classifies types into positive and negative, and it is sufficient to place the monad at the embedding of positive types into negative ones. We consider two calculi based on polarized types: pure call-by-push-value (CBPV) and polarized lambda-calculus, the natural deduction calculus corresponding to focalized sequent calculus. For these two calculi, we present algorithms for normalization by evaluation. We further discuss different implementations of the monad and their relation to existing normalization proofs for lambda-calculus with sums. Our developments have been partially formalized in the Agda proof assistant.