Monadic Reflection in CBPV

• Monadic Reflection is a programming abstraction that separates pure values from effectful actions within the call-by-push-value framework.
• It employs explicit reflection and reification operators to control user-defined monads and manage computational effects effectively.
• The λ-mon calculus formalizes this approach through extended syntax, operational semantics, and a rigorous type-and-effect system.

Monadic reflection is a programming abstraction for user-defined computational effects, introduced and analyzed within the context of the call-by-push-value (CBPV) paradigm. It provides a discipline for effectful computations by separating pure values from effectful actions, enabling fine-grained control over the introduction and elimination of user-specified monads via explicit operators for reflection and reification. The monadic reflection calculus λ-mon, as developed by Forster, Kammar, Lindley, and Pretnar, formalizes this approach by extending CBPV with monad definitions, and new primitives for embedding computations into, and extracting them from, monadic contexts (Forster et al., 2016).

1. Formal Syntax and Monad Definitions

The λ-mon calculus extends the CBPV core syntax (values $V$, computations $M$) with three new forms:

1. Monad-definition form: $T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$, where $x : \alpha$, $y : T\,\alpha$, $$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$ are bound in $N_u$ (the unit clause for return) and $N_b$ (the bind clause for monadic composition). The monad definition binds a fresh type variable $\alpha$, specifying the required algebraic structure for $T$.
2. Reflection: $M$0, embedding an $M$1-computation into the monad $M$2.
3. Reification: $M$3, extracting a $M$4-computation back into an $M$5-computation.

Thus, the grammar is:

$M$6

This expressive syntax enables user-defined monads whose return and bind are specified operationally.

2. Operational Semantics

The operational semantics of λ-mon is formulated by extending CBPV’s $M$7-reductions with rules for reflect and reify, using evaluation contexts $M$8 and hoisting contexts $M$9 (up to the nearest reify):

• Reflection:

$T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$0

This rule simply ‘opens’ a reflection, delegating to the underlying computation.

• Reification over Return:

$T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$1

A reify over a returned value invokes the unit clause of the monad definition.

• Reification over a Suspended Reflect:

$T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$2

Here, a reify over a reflected computation invokes the bind clause, passing the sub-continuation as $T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$3.

These operational rules provide direct and local reasoning about the interaction between computational effects and user-defined monads.

3. Type-and-Effect System

The type-and-effect discipline of λ-mon decorates each computation type with an effect, logically modeled as an ordered stack of monads. The kinding and typing judgments are:

$T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$4

Key typing rules include:

• (Define): Ensures that $T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$5 and $T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$6 implement a monad instance for $T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$7 over an effect stub $T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$8.
• (Reflect): $T\,x\,N_u\,y\,f\,N_b\ \text{where}\,\ldots$9
• (Reify): $x : \alpha$0

This system enables compositional type checking for computations with complex effect stacks.

4. Set-Theoretic Denotational Semantics

The denotational semantics interprets each effect stack $x : \alpha$1 as a set-theoretic monad $x : \alpha$2 and each computation type $x : \alpha$3 as the $x : \alpha$4–algebra $x : \alpha$5. Monad types $x : \alpha$6 are interpreted as $x : \alpha$7. The semantics for the new forms is:

$x : \alpha$8

where $x : \alpha$9 is the $y : T\,\alpha$0–algebra structure of $y : T\,\alpha$1.

Soundness and adequacy theorems hold:

• If $y : T\,\alpha$2 and $y : T\,\alpha$3, then $y : T\,\alpha$4.
• If $y : T\,\alpha$5 are closed of ground type $y : T\,\alpha$6 and $y : T\,\alpha$7, then $y : T\,\alpha$8.

5. Macro-Translation from Algebraic Effect Handlers

A macro-translation from the calculus of algebraic effect handlers (EFF) into λ-mon demonstrates the expressive power of monadic reflection. This translation fixes a continuation monad $y : T\,\alpha$9 with:

$$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$0

Given a handler term, the translation is:

$$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$1

Correctness: This translation simulates the operational behavior of algebraic handlers up to a finite number of $$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$2-steps.

Typeability: In monomorphic λ-mon, this translation does not type-check due to the polymorphism of handlers in EFF. Introducing first-class quantified (polymorphic) operations restores typeability, enabling a uniform expressive correspondence.

6. Meta-Theoretic Properties

The λ-mon calculus enjoys fundamental meta-theoretic properties:

• Safety: For $$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$3, either $$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$4, or $$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$5 and $$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$6.
• Termination: For every proper closed $$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$7, there is no infinite reduction sequence, and eventually $$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$8 uniquely.
• Soundness: If $$f : T\,\alpha \to (\alpha \to T\,\beta) \to T\,\beta$$9, then $N_u$0.
• Adequacy: If $N_u$1 are closed, ground-type computations in the identity monad, and $N_u$2, then $N_u$3.

These properties guarantee the operational reliability, semantic faithfulness, and contextual equivalence for effectful computations modeled in λ-mon (Forster et al., 2016).

7. Expressive Power and Limitations

Felleisen's notion of macro translation establishes that monadic reflection, effect handlers, and delimited control (without answer-type modification) can macro-express each other, subject to typeability constraints. However, using the set-theoretic denotational semantics for λ-mon, it is shown that effect handlers cannot be macro-expressed while preserving typeability either by monadic reflection or delimited control. This demonstrates precise boundaries in the expressive power of these abstractions and highlights the sensitivity of their relative expressiveness to language features such as type polymorphism (Forster et al., 2016).