Axioms for Recursion in Call-by-Value

When designing languages for functional reactive programming (FRP) the main challenge is to provide the user with a simple, flexible interface for writing programs on a high level of abstraction while ensuring that all programs can be implemented efficiently in a low-level language. To meet this challenge, a new family of modal FRP languages has been proposed, in which variants of Nakano's guarded fixed point operator are used for writing recursive programs guaranteeing properties such as causality and productivity. As an apparent extension to this it has also been suggested to use Linear Temporal Logic (LTL) as a language for reactive programming through the Curry-Howard isomorphism, allowing properties such as termination, liveness and fairness to be encoded in types. However, these two ideas are in conflict with each other, since the fixed point operator introduces non-termination into the inductive types that are supposed to provide termination guarantees. In this paper we show that by regarding the modal time step operator of LTL a submodality of the one used for guarded recursion (rather than equating them), one can obtain a modal type system capable of expressing liveness properties while retaining the power of the guarded fixed point operator. We introduce the language Lively RaTT, a modal FRP language with a guarded fixed point operator and an `until' type constructor as in LTL, and show how to program with events and fair streams. Using a step-indexed Kripke logical relation we prove operational properties of Lively RaTT including productivity and causality as well as the termination and liveness properties expected of types from LTL. Finally, we prove that the type system of Lively RaTT guarantees the absence of implicit space leaks.

Based on the GES (Goncharov–Ershov–Sviridenko) theory of list superstructures [1, 2], we study the semantics of iterators which is used in the object iterated programming language Libretto [3]. We note that Libretto also allows us to give a strong logic interpretation and can be used for constructing and managing object oriented databases [4]. One of the main difficulties is to organize nondeterministic computations related to input collections of elements satisfying a certain condition. Iterators can be represented as a realization of bounded existential quantifier ∃x ∈ M.F (x). A basic “intrinsic” iterator in Libretto is responsible for the strategy of depthfirst search. However, there are other iterators simulating more delicate strategies for looking for solutions related, for example, with methods of constraint satisfaction [5]. In particular, it is of interest to consider iterators simulating semantic programming on finite domains [6]. Based on the Σ-definability of inductive definitions [7, 8] in the GES theory, it is possible to model recursive descriptions without additional constructions like fixed point operators. In this paper, we use this property of the GES theory coming back to the theory of admissible sets [9].

Many programming languages provides non-local exit. In C language, it is implemented by setjump and longjump functions in its standard library. In Java, a try-catch-finally statement is equipped as non-local exit with control capturing. The try-catch-finally mechanism can be categorized into two parts: global jump and control capturing. The non-local jump has been studied well for a long time by many researchers. On the other hand, control capturing has not yet been researched well enough. In this paper, we propose a lambda calculus with non-local jump and control capturing and its operational semantics based on small-step transition. We provide continuation-passing style translation of the calculus into the usual lambda calculus. The continuation-passing style translation is known as a translation style semantics of a control structure such as a non-local jump or first-class continuation. We extend the continuation passing style translation in order to formalize the control capturing in the framework of a functional programming language paradigm. We develop a type system for the calculus with control capturing and show conformity of the typed version of the CPS translation with the type system of the calculus.

We present the semantics of the annotations pcall and fork for parallel evaluation of Scheme. Annotated programs are proved to be behaviourly indistinguishable from their non-annotated counterparts, even in the presence of first-class continuations and side-effects. The semantics takes the form of an abstract machine, which can be regarded as a guideline for an implementation.KeywordsShared MemoryParallel ApplicationFunctional ProgrammingAbstract MachineFunctional LanguageThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Scores of compilers produce JavaScript, enabling programmers to use many languages on the Web, reuse existing code, and even use Web IDEs. Unfortunately, most compilers inherit the browser's compromised execution model, so long-running programs freeze the browser tab, infinite loops crash IDEs, and so on. The few compilers that avoid these problems suffer poor performance and are difficult to engineer. This paper presents Stopify, a source-to-source compiler that extends JavaScript with debugging abstractions and blocking operations, and easily integrates with existing compilers. We apply Stopify to ten programming languages and develop a Web IDE that supports stopping, single-stepping, breakpointing, and long-running computations. For nine languages, Stopify requires no or trivial compiler changes. For eight, our IDE is the first that provides these features. Two of our subject languages have compilers with similar features. Stopify's performance is competitive with these compilers and it makes them dramatically simpler. Stopify's abstractions rely on first-class continuations, which it provides by compiling JavaScript to JavaScript. We also identify sub-languages of JavaScript that compilers implicitly use, and exploit these to improve performance. Finally, Stopify needs to repeatedly interrupt and resume program execution. We use a sampling-based technique to estimate program speed that outperforms other systems.

We present a comprehensive analysis of all the components of creation, access and disposal of heap-allocated and stack-allocated activation records. Among our results are: •Although stack frames are known to have a better cache read-miss rate than heap frames, our simple analytical model (backed up by simulation results) shows that the difference is too trivial to matter. •The cache write-miss rate of heap frames is very high; we show that a variety of miss-handling strategies (exemplified by specific modern machines) can give good performance, but not all can. •Stacks restrict the flexibility of closure representations (for higher-order functions) in important (and costly) ways. •The extra load placed on the garbage collector by heap-allocated frames is small. •The demands of modern programming languages make stacks complicated to implement efficiently and correctly. Overall, the execution cost of stack-allocated and heap-allocated frames is similar; but heap frames are simpler to implement and allow very efficient first-class continuations.

We describe a type system with mixed linear and non-linear recursive types called LNL-FPC (the linear/non-linear fixpoint calculus). The type system supports linear typing which enhances the safety properties of programs, but also supports non-linear typing as well which makes the type system more convenient for programming. Just like in FPC, we show that LNL-FPC supports type-level recursion which in turn induces term-level recursion. We also provide sound and computationally adequate categorical models for LNL-FPC which describe the categorical structure of the substructural operations of Intuitionistic Linear Logic at all non-linear types, including the recursive ones. In order to do so, we describe a new technique for solving recursive domain equations within the category CPO by constructing the solutions over pre-embeddings. The type system also enjoys implicit weakening and contraction rules which we are able to model by identifying the canonical comonoid structure of all non-linear types. We also show that the requirements of our abstract model are reasonable by constructing a large class of concrete models that have found applications not only in classical functional programming, but also in emerging programming paradigms that incorporate linear types, such as quantum programming and circuit description programming languages.