Adjunctions for exceptions

An algebraic method is used to study the semantics of exceptions in computer languages. The exceptions form a computational effect, in the sense that there is an apparent mismatch between the syntax of exceptions and their intended semantics. We solve this apparent contradiction by efining a logic for exceptions with a proof system which is close to their syntax and where their intended semantics can be seen as a model. This requires a robust framework for logics and their morphisms, which is provided by categorical tools relying on adjunctions, fractions and limit sketches.

💡 Research Summary

The paper tackles the longstanding mismatch between the syntactic treatment of exceptions in programming languages and their semantic modeling as computational effects. While exceptions are often represented semantically by monads or algebraic effects, the concrete syntax—declarations, throws, and catches—appears as a seamless flow that does not fit neatly into the abstract effect framework. The authors propose a categorical solution that bridges this gap by constructing a dedicated logic for exceptions whose proof system mirrors the syntax, yet whose models capture the intended semantics.

The core of the approach rests on three categorical tools: adjunctions, fractions, and limit sketches. Two categories are introduced: C, representing pure (exception‑free) computations, and E, representing computations that may raise exceptions. An adjunction (F \dashv G) is established where the left adjoint (F : C \to E) freely embeds pure programs into the exception‑enabled world, and the right adjoint (G : E \to C) extracts the pure part of an exception‑bearing program. This adjunction guarantees a systematic translation between the two realms and provides the structural backbone for the semantics.

To model the propagation of exceptions, the authors employ the notion of fractions. A throwing operation is represented as a morphism (e : X \to Y) that can be “inverted” in a fraction (e^{-1} \circ f), allowing subsequent computations to continue in a well‑defined way even after an exception has been raised. This formalism goes beyond partial functions by embedding exception flow directly into the categorical composition.

Limit sketches serve as the design language for the entire framework. A sketch specifies objects (types, exception tags), morphisms (functions, throw, catch), and limiting cones that encode the logical rules of the exception system. Models of the sketch are precisely the categorical structures (the adjunction and fraction calculus) that satisfy the intended equations, ensuring that the proof system derived from the sketch is sound and complete with respect to the semantics.

The paper defines a “logic for exceptions” comprising:

1. A signature that includes base types, ordinary functions, and exception constructors.
2. Operational rules for function application, throwing, propagating, and handling exceptions.
3. A natural deduction‑style proof system enriched with specific rules for exception propagation (e.g., if a term reduces to a throw, any surrounding term reduces via the corresponding fraction) and for handling (catch) that mirrors the syntactic try‑catch construct.

The authors demonstrate the adequacy of the logic by constructing a concrete model: they take a simple language of integer arithmetic, extend it with a single exception, and show how each syntactic construct maps into the categorical framework. The adjunction translates pure arithmetic expressions into exception‑aware ones, fractions encode the effect of a throw, and the sketch’s limits enforce the expected behavior of catch blocks.

In the related work discussion, the authors contrast their approach with traditional monadic treatments, which separate effectful and pure parts but do not provide a direct syntactic‑semantic correspondence. They also relate their framework to algebraic effects and effect systems, arguing that the adjunction‑fraction‑sketch combination yields a more fine‑grained and compositional account of exceptions, especially when multiple effects interact.

The paper concludes by acknowledging limitations: the current development handles a single, homogeneous exception type; extensions to hierarchical or asynchronous exceptions, as well as integration with real‑world language implementations and compiler optimizations, remain open research directions. Nonetheless, the work establishes a robust categorical foundation that unifies the syntax and semantics of exceptions, offering a promising path for future language design and formal verification efforts.