A call-by-value lambda-calculus with lists and control

Calculi with control operators have been studied to reason about control in programming languages and to interpret the computational content of classical proofs. To make these calculi into a real programming language, one should also include data types. As a step into that direction, this paper defines a simply typed call-by-value lambda calculus with the control operators catch and throw, a data type of lists, and an operator for primitive recursion (a la Goedel’s T). We prove that our system satisfies subject reduction, progress, confluence for untyped terms, and strong normalization for well-typed terms.

💡 Research Summary

The paper presents a simply‑typed, call‑by‑value λ‑calculus that integrates control operators (catch and throw), a list data type, and a primitive recursion operator reminiscent of Gödel’s T. The motivation is to move beyond the traditional study of control operators in isolation and to provide a formal foundation for a realistic programming language that includes both control flow mechanisms and data structures.

Syntax and Types
Terms consist of variables, λ‑abstractions, applications, list constructors (nil, cons), a recursion operator rec, and the control constructs catch t and throw t. Types include base types (e.g., natural numbers), function types τ→σ, list types List τ, and a special type ⊥ used for the throw operator. The typing rules extend the standard simply‑typed λ‑calculus: a catch expects a function of type τ→σ and yields a result of type σ, while throw has type τ→⊥, ensuring that a thrown value matches the expected type of the nearest enclosing catch.

Operational Semantics
Evaluation follows a call‑by‑value strategy: arguments are evaluated to values before β‑reduction. List recursion is defined by pattern matching: rec f nil → v₀ and rec f (cons x xs) → v₁. The control flow is modeled by propagating a throw v directly to the closest dynamic catch; if no catch is present, the term is stuck, but the typing discipline guarantees that a well‑typed term always has an enclosing catch for any thrown value.

Meta‑theoretical Results
Four central properties are proved:

1. Subject Reduction – Types are preserved under evaluation. The proof carefully handles the interaction between throw and catch, showing that the type of the thrown value is exactly the type expected by the catch.

2. Progress – A well‑typed closed term is either a value or can take a reduction step. Because throws are always caught by a statically guaranteed handler, there are no “uncaught exceptions” that could block progress.

3. Confluence (Untyped Terms) – The untyped reduction relation is confluent. The authors establish the Church‑Rosser property by showing that the critical pairs introduced by the control operators are joinable, and that the standard λ‑calculus reductions remain confluent.

4. Strong Normalization – Every well‑typed term terminates. The proof uses the reducibility candidates (Tait‑Girard) method, extending the usual construction to accommodate the recursion operator and the control constructs. A key technical contribution is the definition of a candidate set that is closed under the “catch‑throw” reduction, ensuring that the presence of control does not introduce infinite reduction sequences.

Significance
By proving subject reduction, progress, confluence, and strong normalization, the paper demonstrates that a language combining first‑class control operators with inductive data types can be both expressive and mathematically well‑behaved. This bridges a gap between theoretical studies of classical logic via control operators and practical language design, where data structures and recursion are indispensable.

Future Directions
The authors suggest extending the calculus with multiple exception handlers, richer data types such as trees or streams, and integrating effect systems to capture other computational effects. Another promising avenue is to investigate efficient abstract machines that implement the presented semantics while preserving the proven meta‑theoretical guarantees.

In summary, the work provides a solid formal foundation for a call‑by‑value functional language that supports exception‑style control flow together with list processing and primitive recursion, and it establishes the essential safety and termination properties required for reliable language implementation.