Call-By-Push-Value

Paul Blain Levy, University of Birmingham, UK

Call-by-push-value (CBPV) is a form of typed λ-calculus that plays a fundamental

role in the study of computational effects. This article is intended to be an accessible
introduction. I thank Mike Mislove and SIGLOG for inviting me to expound one of my
favourite subjects.

1. INTRODUCTION
1.1. Calculi for functional programming: pure and effectful
Programming language semantics is a field where we study simple programming lan-
guages or calculi, each of which can have various forms of mathematical descrip-
tion. Firstly, the syntax provides ways of constructing expressions—types and terms—
and a program is a special kind of term. An operational semantics prescribes how to
evaluate programs. By contrast, a denotational semantics (or model) provides every
expression—type or term—with a “denotation” or meaning. It does this composition-
ally, by interpreting each way of constructing expressions as an operation on denota-
tions. Lastly, an axiomatic theory, such as an equational theory, provides a formal way
of reasoning about expressions.
Prominent among the many calculi of interest is the simply typed λ-calculus. It can
be seen as a purely functional programming language: when a program is evaluated,
all that happens is that the result is returned.
However, many programs of interest are not purely functional, as they involve com-
putational effects. An effect can be defined as an “imperative feature” added to a func-
tional program, or perhaps more accurately as an “instruction to the interpreter”.
For example: raising an error; printing; interactive input; making nondeterministic or
probabilistic choices; running forever (via iteration or recursion); reading and writing
to memory; generating new memory cells; saving and restoring the execution stack.
CBPV is a variant of the simply typed λ-calculus that incorporates computational
effects, and therefore synthesizes functional and imperative programming. It was for-
mulated and developed in my book and related papers [Levy 2004; 2001; 1999; 2006a;
2005], building on a large amount of earlier research, especially [Moggi 1991; Filinski
1996].
The fundamental CBPV principle is the distinction between values and computa-
tions, with functions classified as computations. The distinction is not as severe as it
might seem, because to each computation there corresponds a value, called its thunk,
which can be forced (i.e. executed) when desired.
A special feature of CBPV is that it subsumes both the call-by-value (CBV) and call-
by-name (CBN) versions of the simply typed λ-calculus with effects. By “subsume”
I mean not only that CBV and CBN can be translated into CBPV, but that these
transforms preserve every known form of semantics. That includes operational and ab-
stract machine semantics, and also denotational models using domain theory, possible

ACM SIGLOG News 7 April 2022, Vol. 9, No. 2

worlds, continuations, games, and more.1 This phenomenon suggests that, from the
semantic viewpoint, CBV and CBN simply typed λ-calculi are nothing more than sub-
systems of CBPV.
Thus, while it was common practice in the 1990s to carry out each piece of seman-
tic research twice—once for CBV and once for CBN—this is no longer necessary. We
can just work with CBPV, and doing so gives a precise, fine-grained understanding
that was previously missing. For example, game models were developed for CBN and
CBV [Hyland and Ong 2000; Nickau 1996; McCusker 2000; Abramsky and McCusker
1998; Honda and Yoshida 1997], and they involve two kinds of move, dubbed “Ques-
tion” and “Answer”. These correspond, respectively, to the CBPV operations of forcing
and returning [Levy 2004, Chapter 8], which the CBN and CBV calculi do not make
explicit.
Working in CBPV has other advantages. For example, in the presence of type recur-
sion (Section 4), CBV can express simple lists and CBN can express lazy lists, so CBPV
can express both.2 CBPV also provides optimizations that compilers can exploit—an
example is given in Section 6.
The name “call-by-push-value” has sometimes been criticized, as CBPV is not inher-
ently about stack usage, or at least no more than CBV and CBN are. I chose this name
because, whilst in the CBN stack machine (known as the “Krivine machine”) function
application causes a term to be pushed, in the CBPV version it causes a value to be
pushed. (This is explained in Section 3.3.) So, in an alternative history, CBN would be
dubbed “call-by-push”, and we could then say that call-by-push-value combines call-
by-push and call-by-value.

1.2. Overview of the article

To set the scene, we begin (Section 2) with an account of the simply typed λ-calculus.
This, together with special equations known as β- and η-laws, constitutes the canon-
ical pure functional programming language. The word “pure” means that effects are
excluded.
Then we move to CBPV, which modifies simply typed λ-calcuus to allow the inclusion
of effects, while retaining all the β- and η-laws. We give the syntax and operational se-
mantics using an interpreter (Section 3.2), and using the CK-machine, which involves
stack terms (Section 3.3). We give syntax and operational semantics for various com-
putational effects (Section 4), and then give a denotational model for each extension
(Section 5), taking care to motivate each model via computational ideas. Section 6
presents the CBV and CBN subsystems of CBPV, and we wrap up in Section 7.

2. PURE FUNCTIONAL PROGRAMMING

2.1. Notation for sets and elements
Let’s begin with some mathematical notation. For sets A and B, we write A → B or B A
for the set of all functions from A to B. We write A × B for the set {ha, bi | a ∈ A, b ∈ B},
def
and A + B for the tagged union {inl a | a ∈ A} ∪ {inr b | b ∈ B}, where inl a = h0, ai and
def
inr b = h1, bi. We write 1 for the singleton set {h i} and 0 for the empty set.
We write λ for function abstraction, e.g. λxN . x + 3 is the function sending a natural
number x to x + 3. And we write application as juxtaposition, so (λxN . x + 3) 5 is 8.

1 Strictly
speaking, the preservation of operational semantics is up to administrative reductions, and that of
denotational semantics is up to isomorphism, but these are small matters.
2 In CBV, although in principle thunks can be used to express lazy lists, it is rather challenging to correctly
write the concatenation operator (for example), or even its type. See also [MacQueen et al. 1998].

ACM SIGLOG News 8 April 2022, Vol. 9, No. 2

 We write let for a list of local definitions, so let (x be 3, y be 4). x + y is 7. For an
ordered pair x, we write x.left for its left component and x.right for its right component.
Finally, we write match for pattern-matching, so match inl 8 as (inl x. x + 2, inr y. y + 3) is
10, and match h3, 5i as hx, yi. x + y is 8.
2.2. Formal syntax
The simply typed λ-calculus is a formalized version of the notation given in Section 2.1.
Its types are as follows.
A ::= 0 | A+A | 1 | A×A | A→A
Additional “base types” can be included, but we shall not do so. Let me stress that all
the type constructors are equally important for our purpose, although some authors
include only → and omit or downplay the others.
A variable declaration x : A consists of a variable and a type. A typing context Γ is
a list of such declarations with no variable declared more than once. The judgement
Γ ` M : A is intended to say that M is a term of type A whose free variables all appear
in Γ with an appropriate type. Let us now see the typing rules for this judgement.
The rules for variables and local definitions are as follows:
−−−−−−→ −−→
(x : A) ∈ Γ Γ ` N : A Γ, x : A ` M : B
−−−−→
Γ`x:A Γ ` let x be N . M : B
→
−
where the vector notation b stands for b0 , . . . , bn−1 . The type A → B has an introduc-
tion rule
Γ, x : A ` M : B
Γ ` λx. M : A → B
and an elimination rule
Γ`M :A→B Γ`N :A
Γ ` MN : B
The introduction rules for A + B are as follows:
Γ`M :A Γ`M :B
Γ ` inl M : A + B Γ ` inr M : A + B
and the elimination rules for A + B and 0 are as follows:
Γ`N :A+B Γ, x : A ` M : C Γ, y : B ` M 0 : C Γ`N :0
Γ ` match N as (inl x. M, inr y. M 0 ) : C Γ ` match N as ( ) : C
The introduction rules for A × B and 1 are as follows:
Γ`M :A Γ`N :B
Γ ` hM, N i : A × B Γ ` hi : 1
Elimination rules for these types can be given using projections:
Γ`M :A×B Γ`M :A×B
Γ ` M.left : A Γ ` M.right : B
Or using pattern-matching:
Γ`N :A×B Γ, x : A, y : B ` M : C Γ`N :1 Γ, ` M : C
Γ ` match N as hx, yi. M : C Γ ` match N as h i. M : C

ACM SIGLOG News 9 April 2022, Vol. 9, No. 2

2.3. Infinitary extension
The simply typed λ-calculus has an infinitary extension with the following types:
P Q
A ::= 0 | A + A | 1 | A × A | A → A | i∈N Ai | i∈N Ai
P
The type i∈N Ai has the following introduction and elimination rules:
Γ ` M : Aı̂
P
Γ ` N : i∈I Ai (Γ, x : Ai ` Mi : B)i∈N
P ı̂ ∈ N
Γ ` inı̂ M : i∈N Ai Γ ` match N as (ini x. Mi )i∈I : B
Q
The type i∈N Ai has the following introduction and elimination rules:
(Γ ` Mi : Ai )i∈N
Q
Γ ` M : i∈N Ai
Q ı̂ ∈ N
Γ ` λ(i. Mi )i∈N : i∈N Ai Γ ` Mı̂ : Aı̂
Henceforth we shall include these extra types, but readers who prefer to stick to fini-
def def P
tary syntax can ignore them. We abbreviate bool = 1 + 1 and nat = n∈N 1 with the
usual constants.
2.4. Denotational semantics: sets and functions
We furnish the calculus with a denotational semantics. Firstly, each type A denotes a
set [[A]]. This is given by induction on A, using clauses such as
def
[[A → B]] = [[A]] → [[B]]
Let me stress that → in the LHS is a formal symbol, whereas → in the RHS is an
operation on sets. Each typing context Γ also denotes a set, given by
def
Y
[[Γ]] = [[A]]
(x:A)∈Γ

An element of this set is called a semantic Γ-environment , as it provides an element

for each variable.
Finally each term Γ ` M : B denotes a function from [[Γ]] to [[B]]. It is written
[[Γ ` M : B]], or [[M ]] for short, and is defined by induction on the derivation as follows:

[[x]] : ρ 7→ ρ(x)
[[λx. M ]] : ρ 7→ λa ∈ [[A]]. [[M ]](ρ, x 7→ a)
[[M N ]] : ρ → 7 ([[M ]]ρ)([[N ]]ρ)
and so forth. Strictly speaking, we must prove semantic coherence, the property that
any two derivations of a judgement Γ ` M : B lead to the same denotation. Alterna-
tively, sufficient type annotations can be put into the syntax, so that derivations are
unique. Henceforth we ignore the issue.
2.5. Weakening and substitution
If Γ ⊆ Γ0 , i.e. each declaration in Γ appears also in Γ0 , then the judgement Γ ` M : A
implies Γ0 ` M : A. The weakening lemma obtains [[Γ0 ` M : A]] from [[Γ ` M : A]] by
environment restriction.
Terms that are α-equivalent, i.e. differ only by renaming of bound variables, can be
shown to have the same denotation. Henceforth we identify such terms.
For typing contexts Γ and Γ0 , a substitution k : Γ → Γ0 sends each variable (x : A) ∈ Γ
to (k(x) : A) ∈ Γ0 , and it denotes a function [[k]] : [[Γ0 ]] → [[Γ]] sending ρ to (ρ(k(x))(x:A)∈Γ .
Any term Γ ` M : B gives a substituted term Γ0 ` M [k] : A, which is M with each

ACM SIGLOG News 10 April 2022, Vol. 9, No. 2

identifier (x : A) ∈ Γ replaced by k(x), avoiding capture. The substitution lemma says
that we can obtain [[M [k]]] from [[M ]] and [[k]] by composition.
There is a connection to category theory, as contexts and substitutions form a cat-
egory, and the mapping Γ 7→ [[Γ]] gives a contravariant functor from this category to
Set.

2.6. The βη-theory

Two kinds of equation between terms are important. Firstly, we have the β-laws, which
can be seen as a reduction mechanism. For example, here is the β-law for functions:
Γ ` N : A Γ, x : A ` M : B
Γ ` (λx. .M )N = M [N/x] : B
Here is one for pairs using projection syntax:
Γ`M :A Γ`N :B
Γ ` (M, N ).left = M : A
Here is one for tagged terms:
Γ ` N : A Γ, x : A ` M : C Γ, y : B M0 : C
Γ ` match inl N as (inl x. M, inr y. M 0 ) = M [N/x] : C
And one for local definition:
−−−−−−→ −−→
Γ ` N : A Γ, x : A ` M : B
−−−−→ −−→
Γ ` let x be N . M = M [N/x] : B
Secondly, we have the η-laws, which can be seen as an expansion mechanism. For
example, the following η-law for the type A → B expresses the idea that everything of
this type is a λ-abstraction:
Γ`M :A→B
x#Γ
Γ ` M = λx. M x : A → B
where the freshness condition x # Γ means that x does not appear in Γ. The following
η-law for the type A × B (using projection syntax) expresses the idea that everything
of this type is a pair:
Γ`M :A×B
Γ ` M = (M.left, M.right) : A × B
The following η-law for the type A + B expresses the idea that everything of this type
is constructed by inl or inr:
Γ`N :A+B Γ, z : A + B ` M : C
x, y # Γ
Γ ` M [N/z] = match N as (inl x. M [inl x/z], inr y. M [inr y/z]) : C
The βη-theory is defined to be the least congruence that contains all the β- and η-laws.
We write Γ ` M = N : A to say that M and N are equated. The typing context Γ is
essential because, for example, the equation x : 0 ` true = false : bool holds but the
equation ` true = false : bool does not.
We can show that Γ ` M = N : A implies Γ0 ` M [k] = N [k] : A for all k : Γ → Γ0 , and
also implies [[M ]] = [[N ]].

ACM SIGLOG News 11 April 2022, Vol. 9, No. 2

 3. INTRODUCING CALL-BY-PUSH-VALUE
3.1. Preface
In this section, I introduce CBPV by “pulling it out of a hat”. I have made this decision
for the sake of accessibility and brevity, but it has the drawback of requiring the reader
to accept the calculus on trust to a certain extent. Only in Section 6 do we see the
translations from CBV and CBN, and the semantics they give rise to.
(The alternative—more suitable for sceptical readers who want to know exactly why
CBPV is formulated the way it is—would be to start with an arduous study of the CBV
and CBN simply typed λ-calculi, including various syntactic options and the associ-
ated semantics. A comparison of all these semantics reveals that the same pattern of
operations appears in each one, and the components of this pattern constitute CBPV.
This story is rather long and intricate, but makes clear that CBPV is an empirically
observed calculus.)
The name “call-by-push-value” is unintelligible in Section 3.2, as it is only in Sec-
tion 3.3 that we learn about the stack.

3.2. Values and Computations

To present CBPV, we begin with the distinction between values, which have value type,
and computations, which have computation type. The CBPV types are given as follows.
P
value type A ::= U B | 1 | A × A | 0 | A + A | i∈N Ai
Q
computation type B ::= F A | A → B | 1Π | B Π B | i∈N B i
This includes the type U B of thunks of computations in B, and the type F A of compu-
tations that aim to return a value in A. We write × for multiplication of value types
and Π for that of computation types, and 1 and 1Π for their respective units. We think
of A Π B as a type of functions on the set {left, right}, and 1Π as a type of functions on
def def P
the empty set. We define the types bool = 1 + 1 P and nat =Q i∈N 1.
As in Section 2.3, the infinitary connectives i∈N and i∈N are an optional extra,
and readers who prefer to stick to finitary syntax can ignore them. Here is a stream-
lined presentation of the type syntax:
P
value type A ::= U B | 1 | A × A | i∈I AN
Q
computation type B ::= F A | A → B | i∈I B i
where the set I can be either ∅ or {left, right} or N. Any chosen element of I is written ı̂.
A variable declaration x : A consists of a variable with value type. A typing context
Γ is a list of such declarations with no variable declared more than once. The typing
judgements are Γ `v V : A for a value (where A is a value type), and Γ `c M : B for a
computation (where B is a computation type). They are defined inductively in Figure 1.
A closed term is one with no free variables. The terminals are the closed computations
of the form return V or λ(i. Mi )i∈I or λx. M . The following interpreter says how to
evaluate a closed computation M : B to a terminal T : B.
— To evaluate a terminal T : return T . −−→
−−−−→
— To evaluate let x be V . M : evaluate M [V /x].
— To evaluate M to x. N : first evaluate M to return V , then evaluate N [V /x].
— To evaluate force thunk M : evaluate M .
— To evaluate match inı̂ V as (ini x. Mi )i∈I : evaluate Mı̂ [V /x].
— To evaluate match hi as hi. M : evaluate M .
— To evaluate match hV, V 0 i as hx, yi. M : evaluate M [V /x, V 0 /y].
— To evaluate Mı̂: first evaluate M to λ(i. Ni )i∈I , then evaluate Nı̂ .

ACM SIGLOG News 12 April 2022, Vol. 9, No. 2

 −−−v−−−−→ −−→
(x : A) ∈ Γ Γ ` V : A Γ, x : A `c M : B
Γ `v x : A −−−−→ let
Γ `c let x be V . M : B

Γ `c M : B Γ `v V : U B
Γ `v thunk M : U B Γ `c force V : B

Γ `v V : A Γ `c M : F A Γ, x : A `c N : B
Γ `c return V : F A Γ `c M to x. N : B

Γ `v V : Aı̂ Γ `v V : i∈I Ai Γ, x : Ai `c Mi : B
P
ı̂ ∈ I
Γ `v inı̂ V : i∈I Ai Γ `c match V as (ini x. Mi )i∈I : B
P

Γ `v V : 1 Γ `c M : B
Γ `v hi : 1 Γ `v match V as hi. M : B

Γ `v V : A Γ `v V 0 : A0 Γ `v V : A × A0 Γ, x : A, y : A0 `c M : C
Γ `v hV, V 0 i : A × A0 Γ `c match V as hx, yi. M : C

(Γ `c Mi : B i )i∈I Γ `c M : i∈I B i
Q
ı̂ ∈ I
Γ `c λ(i. Mi )i∈I : i∈I B i Γ `c Mı̂ : B ı̂
Q

Γ, x : A `c M : B Γ `c M : A → B Γ `v V : A
Γ `c λx. M : A → B Γ `c M V : B

Fig. 1. CBPV typing rules for values Γ `v V : A and computations Γ `c M : B

— To evaluate M V : first evaluate M to λx. N , then evaluate N [V /x].

Figure 2 inductively defines a single-valued relation M ⇓ T , where M : B is a closed
computation and T : B a terminal. The intended reading of M ⇓ T is that the evalua-
tion of M returns T , so ⇓ is called the evaluation relation. It is clearly single-valued,
and can be shown to be total [Levy 2006a, Proposition 1].
A program is a closed computation of type F A, where A is a ground type such as bool
or nat. Again, the definition of a program’s “behaviour” will depend on the effects we
are considering. Two terms Γ ` M, N : A are said to be observationally equivalent when
replacing one by the other within a program does not affect the program’s behaviour.
The CBPV equational theory is shown in Figure 3, and the equations shown are
observational equivalences for all the effects we consider. Note that CBPV satisfies the
η-law for + types (unlike CBN) and also for → types (unlike CBV).

3.3. Stacks
There are various kinds of operational semantics. So far we have seen two of them:
interpreter and big-step semantics. Another is the CK-machine [Felleisen and Fried-
man 1986], where C stands for “Computation” and K for “stacK”. The idea is that a
computation is evaluated using a stack, which is initially empty. When we evaluate N ,
and are instructed (by the interpreter) to first evaluate one part of N , the rest is placed
on the stack until this evaluation phase is complete.

ACM SIGLOG News 13 April 2022, Vol. 9, No. 2

 T : B terminal M ⇓T M ⇓ return V N [V /x] ⇓ T
T ⇓T force thunk M ⇓ T M to x. N ⇓ T
−−→
M [V /x] ⇓ T M ⇓T
−−−−→ match hi as hi. M ⇓ T
let x be V . M ⇓ T

M ⇓ λx. N N [V /x] ⇓ T M [V /x, V 0 /y] ⇓ T

MV ⇓ T match hV, V 0 i as hx, yi. M ⇓ T

M ⇓ λ(i. Ni )i∈I Nı̂ ⇓ T Mı̂ [V /x] ⇓ T

Mı̂ ⇓ T match inı̂ V as (ini x. Mi )i∈I ⇓ T

Fig. 2. Big-step semantics of CBPV

β-laws
−−−−→ −−→
let x be V . M = M [V /x]
(return V ) to x. M = M [V /x]
force thunk M = M
match inı̂ V as (ini x. Mi )i∈I = Mı̂ [V /x]
match h i as hi. M = M
match hV, V 0 i as hx, yi. M = M [V /x, V 0 /y]
λ(i. Mi )i∈I ı̂ = Mı̂
(λx.M )V = M [V /x]

η-laws
V = thunk force V
M [V /z] = match V as (ini x. M [ini x/z])i∈I
M [V /z] = match V as h i.M [h i/z]
M [V /z] = match V as hx, yi.M [hx, yi/z]
M = λ(i. M i)i∈I
M = λx.(M x)

Sequencing laws
M = M to x. return x
(P to x. M ) to y. N = P to x. (M to y. N )
(P to x. M )ı̂ = P to x. (Mı̂)
(P to x. M )V = P to x. (M V )

Fig. 3. Equational laws of CBPV (typing assumptions omitted)

The judgement Γ `k K : B =⇒ C says that, once values are provided for the identi-
fiers in Γ, the stack K may accompany a computation of type B. The top-level type C
is the type of the computation initially loaded onto the machine. (Some readers may
prefer to think of K as an “evaluation context” of type C, with a hole of type B.) The
typing rules are shown in Figure 4.
The CK-machine itself is shown in Figure 5. A configuration M, K : C consists of a
computation type B (which we omit), a computation `c M : B and a stack `k K : B =⇒

ACM SIGLOG News 14 April 2022, Vol. 9, No. 2

 Γ, x : A `c M : B Γ `k K : B =⇒ C
Γ `k nil : C =⇒ C Γ `k to x. M :: K : F A =⇒ C

Γ `k K : B ı̂ =⇒ C Γ `v V : A Γ `k K : B =⇒ C
ı̂ ∈ I
Γ `k ı̂ :: K : i∈I B i =⇒ C Γ `k V :: K : A → B =⇒ C
Q

Fig. 4. CBPV typing rules for stacks Γ `k K : B =⇒ C

Initial configuration for evaluation of M

M nil
Transitions
−−−−→ −−→
let x be V . M K M [V /x] K
M to x. N K M to x. N :: K
return V to x. N :: K N [V /x] K
force thunk M K M K
match inı̂ V as (ini x. Mi )i∈I K Mı̂ [V /x] K
0 0
match hV, V i as hx, yi. M K M [V /x, V /y] K
Mı̂ K M ı̂ :: K
λ(i. Mi )i∈I ı̂ :: K Mı̂ K
MV K M V :: K
λx. M V :: K M [V /x] K
Terminal configuration yielding a terminal T
T nil

Fig. 5. CK-Machine For CBPV

C. We write for the transition relation between configurations. It is easily seen that,
if M, K is not terminal, then M, K N, L for a unique configuration N, L : C.
So far, we have used operator-first notation for application. But we can also use
operand-first, writing V ‘M instead of M V , and ı̂‘M instead of Mı̂. Using this notation,
λx can be read as “pop x”, and V ‘ can be read as “push V ”. Likewise, λi can be read as
“pop i” and ı̂‘ can be read as “push ı̂”. This is illustrated by following program, which
uses printing and arithmetic.
print "hello0".
let 3 be x.
let thunk (
print "hello1".
λz.
print "we just popped "z.
return x + z
) be y.
print "hello2".

ACM SIGLOG News 15 April 2022, Vol. 9, No. 2

 ( print "hello3".
7‘
print "we just pushed 7".
force y
) to w.
print "w is bound to "w.
return w + 5

Following the CK-machine transitions (and evaluating arithmetical expressions where

necessary), we print the following:

hello0
hello2
hello3
we just pushed 7
hello1
we just popped 7
w is bound to 10

and finally return the value 15. We now can understand the CBPV slogan: “A value is,
a computation does.” Here is a summary of the types, from this perspective.

— A value of type U B is a thunk of a computation of type B.

— A value of type 1 is the empty tuple h i.
0 0
P× A is a pair consisting of a value of type A and a value of type A .
— A value of type A
— A value of type i∈I Ai is a pair consisting of a tag ı̂ ∈ I and a value of type Aı̂ .
— A computation of type F A aims to return a value of type A.
— A computation of type A Q → B aims to pop a value of type A and then behave in B.
— A computation of type i∈I B i aims to pop a tag ı̂ ∈ B and then behave in B ı̂ .

There are three important operations on stacks [Levy 2005]. Firstly, the dismantling
of a Γ `k K : B =⇒ C onto a computation Γ `c M : B is written Γ `c M • K : C. It is
defined by induction on K as follows.
def
M • nil = M
def
M • (to x. N :: K) = (M to x. N ) • K
def
M • (ı̂ :: K) = (Mı̂) • K
def
M • (V :: K) = (M V ) • K

Secondly, the concatenation of stacks Γ `k K : A =⇒ B and Γ `k L : B =⇒ C is written

Γ `k K ++L : A =⇒ C. It is defined by induction on K as follows.
def
nil++L = L
def
(to x. N :: K)++L = to x. N :: (K ++L)
def
(ı̂ :: K)++L = ı̂ :: (K ++L)
def
(V :: K)++L = V :: (K ++L)

Thirdly, given a stack Γ `k K : B =⇒ C, we can substitute values for the variables in

Γ.

ACM SIGLOG News 16 April 2022, Vol. 9, No. 2

 A stack from an F type is called a continuation, and the following is called the pure
continuation law:
Γ `k K : F A =⇒ B Γ `k L : B =⇒ C
Γ `k K ++L = to x. ((return x) • K) :: L : F A =⇒ C
It can be seen as an η-law for the F connective.

4. EXTENDING CBPV WITH VARIOUS EFFECTS

So far we have seen only the pure CBPV calculus. Let’s now adapt the syntax and
operational semantics to incorporate various effects.

4.1. Recursion with isorecursive types

Besides the term-level variables (x), we also have value type variables (X) and compu-
tation type variables (X). The type syntax is extended as follows:
A ::= · · · | X | rec X. A
B ::= · · · | X | rec X. B
Only closed types may be used in a variable declaration or typing judgement. The term
syntax is extended as follows:
Γ, x : U B `c M : B Γ `v V : A[rec X. A/X]
Γ `c rec x. M : B Γ `v fold V : rec X. A
Γ `v V : rec X. A Γ, x : A[rec X. A/X] `c M : B Γ `c M : B[rec X. B/X]
Γ `c match V as fold x. M : B Γ `c fold M : rec X. B

Γ `c M : rec X. B Γ `k K : B[rec X. B/X] =⇒ C

Γ `c unfold M : B[rec X. B/X] Γ `k unfold :: K : rec X. B =⇒ C
We consider fold M to be terminal, and extend the interpreter as follows:
— To evalute rec x. M : evaluate M [thunk rec x. M/x].
— To evaluate match fold V as fold x. M : evaluate M [V /x].
— To evaluate unfold M : evaluate M to fold N , then evaluate N .
The ⇓ relation and CK-machine transltion are extended accordingly. A closed compu-
tation M is divergent when execution of it runs forever, which is equivalent to the
nonexistence of T such that M ⇓ T . We write M ⇑ to say that M diverges.

4.2. Nondeterminism
We add to the language the following typing rule
(Γ `c Mi : B)i∈I
Γ `c choose (Mi )i∈I : B
According to preference, we can require I to be {left, right}, or to be N, or allow it to be
any set (in which case the terms form a proper class).
To evaluate choose (Mi )i∈I : nondeterministically choose some i ∈ I, then evaluate
Mi . The ⇓ relation and CK-machine transltion are extended accordingly. Allowing I to
be empty requires us to say that evaluation may die at any time.

ACM SIGLOG News 17 April 2022, Vol. 9, No. 2

 4.3. Errors
Let E be a set of errors, for example {CRASH, BANG}. We extend CBPV with the
typing rule

Γ `c error e : B
for each e ∈ E. To evaluate error e: halt and print the error message e. We extend the
big-step semantics with a relation M e, saying that evaluation of M results in the
error e, in the evident way.

4.4. Printing
Let A be a set of letters, for example {a, b, c, d, e} . We extend CBPV with the typing
rule
Γ `c M : B
Γ `c print c. M : B
for each c ∈ A. To evaluate print c. M : firstly print c and then evaluate M . We can
present the operational semantics for this language in various ways.

— The inductively defined “big-step” relation has the form M ⇓ m, T , where M : B is a

closed computation and m ∈ A∗ is a string and T : B is terminal; this means that the
evaluation of M prints m and returns T .
— The inductively defined “medium-step” relation [Plotkin and Power 2001] has the
form M ↓ S, where M : B is a closed computation and S : B is either terminal or of
the form print c. M .
— For CK-machine semantics, note that every CK-configuration either has the form
T, nil, where T is terminal, or has the form print c. M, K, or has a successor.

4.5. Interactive input

Let s = (Kr )r∈R be a signature, i.e. an indexed family of sets. For a set A, an s-tree on
A is a tree in which each leaf is labelled with some a ∈ A, and each internal node is
labelled with some r ∈ R and has a Kr -indexed set of children.
We extend CBPV with the typing rule

(Γ `c Mk : B)k∈Kr
Γ ` inr (Mk )k∈Kr : B

for each r ∈ R. To evaluate inr (Mk )k∈Kr : firstly print r and pause, and if the user then
inputs k ∈ Kr , evaluate Mk . The medium-step and CK-machine semantics are defined
as in Section 4.4. The big-step semantics takes the form M ⇓ t, where M : B is a closed
computation and t is a well-founded s-tree on the set of terminals of type B.
Note that interactive input generalizes both errors and printing, as the set E of
errors gives the signature (∅)e∈E , and the set A of letters gives the signature (1)c∈A .

ACM SIGLOG News 18 April 2022, Vol. 9, No. 2

 4.6. Dynamically generated store
To keep things simple, let’s suppose that each memory cell stores a boolean. We extend
CBPV with the value type loc for the cell locations, and the following typing rules.
Γ `v V : loc Γ, x : bool `c M : B Γ `v V : loc Γ `v W : bool Γ `c M : B
Γ `c read V as x. M : B Γ `c V := W. M : B

Γ `v V : bool Γ, x : loc `c M : B
Γ `c new x := V ; M

Γ `v V : loc Γ `v V 0 : loc Γ `c M : B Γ `c M 0 : B
Γ `c if V = V 0 then M else M 0 : B
A world is a natural number, indicating how many cells exist at a given time. The poset
of worlds is written W. (Here W is N, since we allow just one sort of cell.) The empty
world is 0. We have judgements w|Γ `v V : A and w|Γ `c M : B and w|Γ `k K : B =⇒ C
for terms at world w—the case w = 0 giving the ordinary judgements—and we have
the additional rule
06i<w
w|Γ `v li : loc
For a world w, a state at w is a list of w booleans. The big-step semantics takes the form
w, s, M ⇓ w0 , s0 , T , where
— w is a world
— s is a state at w
— M : B is a closed computation at w
— w0 is a world such that w0 > w
— s0 is a state at w0
— T : B is a terminal at w0 .
A WSC-configuration w, s, M : B consists of a world w, and a state s and closed compu-
tation M : B at w. Likewise a WSCK-configuration w, s, M, K : C consists of a world w,
and a state s and closed computation M : B and closed stack K : B =⇒ C at w. For a
world w, a WSC-configuration x, s, M : B or WSCK-configuration x, s, M, K : C is said
to be at w when w 6 x.
4.7. Global store
The global store extension of CBPV is formulated the same way, except that we fix the
world w and disallow new. The big-step semantics takes the form s, M ⇓ s0 , T , and we
simply speak of an SC-configuration s, M : B and an SCK-configuration s, M, K : C.
4.8. Control effects
We extend CBPV with an instruction letstk α meaning “let α be the current stack”,
and an instruction changestk α meaning “change the current stack to α”. We use
α, β, . . . for stack variables, which are distinct from ordinary variables.
A stack variable declaration α : B says (informally) that α is a stack from B to some
unspecified type. A stack context ∆ is a list of these, with no stack variable declared
more than once. The value judgement takes the form Γ `v V : A | ∆ and the computa-
tion judgement Γ `c M : B | ∆, with the following extra rules.
Γ `c M : B | ∆, α : B (α : B) ∈ ∆ Γ `c M : B | ∆
Γ `c letstk α. M | ∆ Γ `c changestk α. M : B 0 | ∆

ACM SIGLOG News 19 April 2022, Vol. 9, No. 2

 To describe execution with top-level type C, we need the judgements Γ `v V : A [C] ∆
for execution values, and Γ `c M : B [C] ∆ for execution computations, and Γ `k K :
B =⇒ C | ∆ for stacks. The extra rules for these are as follows.
(α : B) ∈ ∆
k
Γ ` α : B =⇒ C | ∆

Γ `c M : B | ∆, α : B Γ `k K : B =⇒ C | ∆ Γ `c M : B [C] ∆
Γ `c letstk α. M | ∆ Γ `c changestk K. M : B 0 [C] ∆
Clearly Γ `c M : B | ∆ implies Γ `c M : B [C] ∆, and likewise for values.
Say that a CK-configuration M, K : C consists of a closed execution computation
M : B [C] and a closed stack K : B =⇒ C. So any closed computation M : C gives a
CK-configuration M, nil : C. The extra transition rules are as follows.
letstk α. M K M [K/α] K
changestk K. M L M K
5. DENOTATIONAL SEMANTICS
Having presented many effectful extensions of CBPV, let us give (in outline) a denota-
tional semantics for each of them. These models satisfy the equational laws, including
the pure continuation law.
5.1. Recursion
For CBPV extended with recursion, the observational preorder relates two terms Γ `
M, N : A when any program that returns n continues to do so when M is replaced by
N . This motivates the use of posets for denotational semantics. W
A cpo A is a poset in which every ω-chain a0 6 a1 6 · · · has a supremum n∈N an .
A function between cpos A → B is continuous when it preserves these suprema (and
hence is monotone). The set of continuous functions from A to B, ordered pointwise,
is written A → B. A cppo is a cpo with bottom element, written ⊥. Any cpo A can be
“lifted” to form a cppo
def
A⊥ = {up(a) | a ∈ A} ∪ {⊥}
ordered as A with an additional bottom element.
Now for the denotational semantics. A value type A denotes a cpo [[A]], thought of
as a semantic domain for values of type A. A computation type B denotes a cppo [[B]],
thought of as a semantic domain for computations of type B. Specifically:
def
[[U B]] = [[B]]
def
[[F A]] = [[A]]⊥
def
[[A → B]] = [[A]] → [[B]]
and so forth. Recursive types—of both kinds—are interpreted using a recipe that was
given in [Smyth and Plotkin 1982]; this leads, for example, to the type rec X. bool × X
denoting the empty cpo. Q
A typing context Γ denotes the cpo (x:A)∈Γ [[A]], whose elements are semantic envi-
ronments. Then:
— A value Γ `v V : A denotes a continuous function [[Γ]] → [[A]].
— A computation Γ `c M : B denotes a continuous function [[Γ]] → [[B]].

ACM SIGLOG News 20 April 2022, Vol. 9, No. 2

— A stack Γ `k K : B =⇒ C denotes a function [[K]] : [[Γ]] × [[B]] → [[C]] that is strict (i.e.
preserves ⊥) in its second argument.
The strictness property expresses the fact that if M : B diverges then so does the
configuration M, K.
Here are some example semantic equations:
def
[[thunk M ]](ρ) = [[M ]](ρ)
def
[[force V ]](ρ) = [[V ]](ρ)
def
[[return V ]](ρ) = up([[V ]](ρ))

def [[N ]](ρ[x 7→ a]) if [[M ]](ρ) = up(a)
[[M to x. N ]](ρ) =
⊥ if [[M ]](ρ) = ⊥
def
_
n
[[rec x. M ]] = f (⊥) where f : b 7→ [[M ]](ρ[x 7→ b])
n∈N

All the CBPV equational laws are satisfied, and the pure continuation law follows from
strictness.
A key result is the agreement of the denotational and operational semantics, which
is called “computational adequacy”. Writing ε for the empty environment, we have
that M ⇓ T implies [[M ]]ε = [[T ]]ε, and that M ⇑ implies [[M ]]ε = ⊥. Furthermore, if
we say that a CK-configuration M, K : C denotes the element [[K]](ε, [[M ]]ε) ∈ [[C]], then
M, K N, L implies [[M, K]] = [[N, L]], and M, K ω implies [[M, K]] = ⊥.

5.2. Errors, printing, interactive input

To give denotational semantics for these effects, we use the following kinds of struc-
tured set.
— For errors: let E be a set. An E-pointed set consists of a set X (the carrier) and a
distinguished element pe for each e ∈ E. On a set Y , the free E-pointed set is Y + E
with the evident structure.
— For printing: let A be a set. An A-set consists of a set X (the carrier) and a map
pc : X → X for each c ∈ A. For m = (c0 , . . . , cn−1 ) ∈ A∗ and x ∈ X, we define
m ∗ ∗ x ∈ X to be c0 ∗ · · · ∗ cn−1 ∗ x right-associated. On a set Y , the free A-pointed set
is A∗ × Y with the evident structure.
— For interactive input: let s = (Kr )r inR be a signature. An s-algebra consists of a set
X (the carrier) and a map pr : X Kr → X for each r ∈ R. On a set Y , the free s-algebra
is the set of well-founded s-trees on Y with the evident structure.
Let us describe the model for errors, as the others are similar. Each value type A
denotes a set [[A]], thought of as a semantic domain for values V : A, and each com-
putation type B denotes an E-pointed set [[B]], thought of as a semantic domain for
computations M : B. In particular:
— [[U B]] is the carrier of [[B]]
— [[F A]] is the
Qfree E-pointed set on [[A]]
— A → B is a∈[[A]] [[B]].
Q
A typing context Γ denotes the set (x:A)∈Γ [[A]], whose elements are semantic environ-
ments. Then:
— A value Γ ` V : B denotes a function [[Γ]] → [[B]].
— A computation Γ `c M : B denotes a function [[Γ]] → [[B]].

ACM SIGLOG News 21 April 2022, Vol. 9, No. 2

— A stack Γ `k K : B =⇒ C denotes a function from [[Γ]]×[[B]] to [[C]] that is homomorphic
(i.e. pe -preserving for all e ∈ E) in its second argument.
The requirement for a stack K to denote a homomorphism expresses the fact that if
M : B raises an error e, then so does the configuration M, K. It is crucial that errors
cannot be caught by K.
The semantic equations are omitted, but note the following clauses:
[[thunk M ]] = [[M ]]
[[force V ]] = [[V ]]
Again, we have adequacy: if M ⇓ T then [[M ]] = [[T ]], and if M e then [[M ]] = pe .
These are straightforwardly proved by induction. For printing, we have that M ⇓ m, T
implies [[M ]] = m ∗ ∗[[T ]], and similarly for interactive input.

5.3. Nondeterminism
Let us give in outline a denotational semantics for CBPV extended with nondetermin-
ism. A value type A denotes a set, thought of a semantic domain for values V : A.
A computation type B denotes a set, thought of a semantic domain for possible be-
haviours of computations M : B. Specifically:
def
[[F A]] = [[A]] since a computation : F A may return a value : A.
def
[[A → B]] = [[A]] × [[B]] since a computation : A → B may pop an value : A
and then behave as a computation : B.
Q def P Q
[[ i∈I B i ]] = i∈I [[B i ]] since a computation : i∈I may pop i ∈ I
and then behave as a computation : B i .
def
[[U B]] = P[[B]] since a value : U B, when forced,
can exhibit a range of possible behaviours : B.
def Q
A typing context Γ denotes the set [[Γ]] = (x:A)∈Γ [[A]]. Then:
— A value Γ `v V : A denotes a function from [[Γ]] to [[A]].
— A computation Γ `c M : B denotes a relation from [[Γ]] to [[B]]. This is thought of as
relating ρ to b when b is a possible behaviour of M [ρ].
— A stack Γ `k K : B =⇒ C denotes a relation from [[Γ]] × [[B]] to [[C]]. This is thought of
as relating (ρ, b) to c when a CK-configuration consisting of a computation exhibiting
behaviour b and the stack K[ρ] may exhibit behaviour c.
The semantic equations are omitted, but note the following clause:
[[return V ]] = [[V ]]
using the fact that a function is a special kind of relation. Adequacy takes the form
[
[[M ]] = [[T ]]
M ⇓T

5.4. Global store

Let us say that we have one cell l of type bool and one l0 of type nat. So the set of
def
states is S = B × N. Our denotational semantics for CBPV extended with these global
cells is arranged as follows.
— A value type A denotes a set, thought of as a semantic domain for values V : A

ACM SIGLOG News 22 April 2022, Vol. 9, No. 2

— A computation type B denotes a set, thought of as a semantic domain for SC-
configurations s, M : B.
Here is the semantics of types:
def
[[F A]] = S × [[A]] since an SC-configuration : F A evaluates to s, return V
for a state s and closed value V : A.
def
[[A → B]] = [[A]] → [[B]] since a configuration : A → B, pops a value : A,
and then accordingly behaves as an SC-configuration : B.
Q def Q Q
[[ i∈I B i ]] = i∈I [[B i ]] since an SC-configuration : i∈I B i pops i ∈ I
and then accordingly behaves as an SC-configuration : B i .
def
[[U B]] = S → [[B]] since a value V : U B, when forced in any state s,
gives an SC-configuration s, force V .
def Q
A typing context Γ denotes the set [[Γ]] = (x:A)∈Γ [[A]]. Then:
— A value Γ `v V : A denotes a function [[Γ]] → [[A]].
— A computation Γ `c M : B denotes a function from S × [[Γ]] to [[B]], thought of as
sending (s, ρ) to the SC-configuration s, M [ρ].
— A stack Γ `k K : B =⇒ C denotes a function from [[Γ]] × [[B]] to [[C]], thought of as
sending an environment ρ and SC-configuration s, M to the SC-configuration s, M •
K[ρ].
Again, the semantic equations are easy to write, and validate all the CBPV equational
laws, as well as the pure continuation law. The adequacy theorem says that s, M ⇓ s0 , T
implies [[M ]](s, ε) = [[T ]](s, ε), and is proved by induction.
5.5. Dynamically generated, globally visible cells
Now we develop the semantics of store to allow dynamic generation of cells. It is often
considered desirable to validate equations such as
M = new x := V. M (where x is fresh)
new x := V. new y := W. M = new y := W. new x := V. M
But the model described here is a simple one in which generated cells are “globally
visible” and so these equations are not validated.
The semantics of types is arranged as follows.
— A value type A denotes a functor from W to Set. Spelling this out, for each world w, we
provide a set [[A]]w, thought of as a semantic domain for values : A at w. Furthermore,
for any worlds w 6 x, we provide a function [[A]]wx from [[A]]w to [[A]]x, since any value
id
,
at w is also one at x,. Finally, the diagram [[A]]w 2 [[A]]w commutes for each world
[[A]]w
w

[[A]]w
w, and the diagram [[A]]w
x
/ [[A]]x commutes for all worlds w 6 x 6 y.
[[A]]x
y
[[A]]w
y #
[[A]]y
— A computation type B denotes a a functor from W op to Set. Spelling this out, for
each world w, we provide a set [[B]]w, thought of as a semantic domain for WSC-
configurations : B at w. For worlds w 6 x, we provide a function [[B]]w
x from [[B]]x

ACM SIGLOG News 23 April 2022, Vol. 9, No. 2

 to [[B]]w, since any WSC-configuration at x is also one at w. Finally, the diagram
id
, [[B]]x
y
/ [[B]]x
[[B]]w 2 [[B]]w commutes for each world w, and the diagram [[B]]y
[[B]]w
w
[[B]]w
x
[[B]]w
y # 
[[B]]w
commutes for all worlds w 6 x 6 y.

def
For a world w, write Sw = Bw for the set of states at w. The semantics of types is as
follows.

def P
[[F A]]w = x>w (Sx × [[A]]x) since an WSC-configuration : F A at w
evaluates to x, s, return V for a world x > w
and state s and closed value V : A at x.
def
[[A → B]]w = [[A]]w → [[B]]w since a WSC-configuration : A → B
pops a value : A and behaves as an WSC-configuration : B.
Q def Q Q
[[ i∈I B i ]]w = i∈I [[B i ]]w since a WSC-configuration : i∈I B i
pops i ∈ I and behaves as a WSC-configuration : B i .
def Q
[[U B]]w = x>w (Sx → [[B]]x) since a value V : U B at w,
when forced in any world x > w and state s at x,
gives a WSC-configuration x, s, force V at x.

def
A
Q typing context Γ denotes the functor given at the world w by the set [[Γ]]w =
(x:A)∈Γ [[A]]w, an element of which is a semantic environment. Then:

— A value w|Γ `v V : A denotes a family of functions ([[V ]]x : [[Γ]]x → [[A]]x)x>w that is
“natural” in the following sense: for any w 6 x 6 y, the square of functions

[[V ]]x
[[Γ]]x / [[A]]x

[[Γ]]x
y [[A]]x
y
 
[[Γ]]y / [[A]]y
[[V ]]y

commutes. (Informal explanation: for any Γ-environment ρ at x, each path leads to

the same value V [ρ] : A at y.)
— A computation w|Γ `c M : B denotes a family of functions ([[M ]]x : Sx × [[Γ]]x →
[[B]]x)x>w , where [[M ]]w : (s, ρ) 7→ b means that M , in the world w and state s and
environment ρ, has behaviour b.
— A stack w|Γ `k K : B =⇒ C denotes a family of functions ([[K]]x : [[Γ]]x × [[B]]x →
[[C]]x)x>w that is “dinatural” in the following sense: for any w 6 x 6 y, the pentagon

ACM SIGLOG News 24 April 2022, Vol. 9, No. 2

 of functions
[[K]]x
[[Γ]]x × [[B]]x / [[C]]x
7 O
[[Γ]]x×[[B]]x
y

[[Γ]]x × [[B]]y [[C]]x

y

[[Γ]]x
y ×[[B]]y '
[[Γ]]y × [[B]]y / [[C]]y
[[K]]y

commutes. (Informal explanation: for any Γ-environment ρ at x and WSC-

configuration y 0 , s, M : B at y, each path leads to the same WSC-configuration
y 0 , s, M • K[ρ] : C at x.)
Again, the semantic equations are easy to write, and validate all the CBPV equational
laws, as well as the pure continuation law. The adequacy theorem says that w, s, M ⇓
x, s0 , T at type B implies [[M ]]w(s, ε) = ([[B]]w 0
x )([[T ]]x(s , ε), and is proved by induction.

5.6. Control
The denotational semantics for CBPV extended with control operators is rather subtle,
and I shall explain it using some imaginary notions. For any computation type B,
imagine a notion of idealized stack K from B that has no top-level type; this excludes
nil. Likewise, imagine a notion of an idealized CK-configuration, which consists of a
closed computation M : B and an idealized stack K from B. Although idealized stacks
and CK-configurations do not actually exist, these notions are conceptually helpful.
Let us now fix a set R, thought of as a semantic domain for idealized CK-
configurations. The semantics of types is arranged as follows.
— A value type A denotes a set, thought of as a semantic domain for values of type A.
— A computation type B denotes a set, thought of as a semantic domain for idealized
stacks from B.
The clauses are as follows.
def
[[F A]] = [[A]] → R since an idealized stack K from F A converts a value V : A
into an idealized CK-configuration return V, K.
def
[[A → B]] = [[A]] × [[B]] since an idealized stack V :: K from A → B consists of
a value V : A and an idealized stack K from B.
Q def P Q
[[ i∈I B i ]] = i∈I [[B i ]] since an idealized stack ı̂ :: K from i∈I B i consists of
ı̂ ∈ I and an idealized stack K from B i .
def
[[U B]] = [[B]] → R since a value V : U B, when forced alongside any idealized stack
K from B, gives an idealized CK-configuration force V, K.
Q
An ordinary context Γ denotes the set (x:A)∈Γ [[A]], an element of which is a semantic
def Q
environment. A stack context ∆ denotes the set [[∆]] = (α:B)∈Γ [[B]], an element of
which can be called an “idealized stack environment”. Then:
— A value Γ `v V : A | ∆ denotes a function from [[Γ]] × [[∆]] to [[A]].
— A computation Γ `c M : B denotes a function from [[Γ]] × [[∆]] × [[B]] to R. Intuitively,
given environments ρ ∈ [[Γ]] and ν ∈ [[∆]], and an idealized stack K from B, we obtain
an idealized CK-configuration M [ρ, ν], K.

ACM SIGLOG News 25 April 2022, Vol. 9, No. 2

— A stack Γ `k K : B =⇒ C | ∆ denotes a function from [[Γ]]×[[∆]]×[[C]] to [[B]]. Intuitively,
given environments ρ ∈ [[Γ]] and ν ∈ [[∆]], and an idealized stack L from C, we obtain
an idealized stack K[ρ, ν]++L from B.
— An execution value Γ `v V : A [C] ∆ denotes a function from [[Γ]] × [[∆]] × [[C]] to [[A]].
Intuitively, V reduces to an ordinary value when we replace nil by an idealized stack
from C.
— Likewise, an execution computation Γ `c M [C] B denotes a function from [[Γ]] × [[∆]] ×
[[C]] × [[B]] to R.
Here are some key semantic equations:
[[return V ]](ρ, ν, k) = k([[V ]](ρ, ν))
[[force V ]](ρ, ν, k) = ([[V ]](ρ, ν))k
[[letstk α. M ]](ρ, ν, k) = [[M ]](ρ, ν[α 7→ k], k)
[[changestk α. M ]](ρ, ν, k) = [[M ]](ρ, ν, ν(α))
[[V :: K]](ρ, ν, k) = h[[V ]](ρ, ν), [[K]](ρ, ν, k)i
Lastly, a CK-configuration M, K : C denotes a function from [[C]] to R, given by
def
[[M, K]](c) = [[M ]](ε, ε, c, [[K]](ε, , ε, c))
and transition preserves denotation. If we take R to be N, then, for any program M :
F nat that evaluates to n, we can recover n from [[M ]] as follows:
[[M ]](ε, ε, idN ) = [[M, nil]](idN )
= [[return n, nil]](idN )
= n
6. CALL-BY-VALUE AND CALL-BY-NAME
So far we have considered CBPV as a whole; let us now turn to the CBV and CBN sub-
systems. The translations into CBPV are outlined in Figure 6. A more detailed analysis
can be given using a special syntax called jumbo λ-calculus [Levy 2006b]. Furthermore,
the translation from CBV can be presented in two stages; the intermediate calculus is
called fine-grain call-by-value [Levy et al. 2003].
Since CBV allows an application M N to be evaluated either operator-first or
operand-first, we have to give two translations. The operand-first translation can be
“optimized” in the CBPV theory to the following:
N to x. (M to f. force f)x
Using ‘ notation this becomes
N to x. x‘(M to f. force f)
which means that we first evaluate N and push the result. Interestingly, the operand-
first version of the (call-by-value) ML language has a compiler called ZINC that does
precisely this [Leroy 1991], so we have a semantic explanation of what seemed to be a
mere compiler trick.3
Via the given translations, each CBPV semantics gives rise to a semantics of CBV
and CBN, and in many cases this is standard. For example, in the CBN model of re-
cursion, each type denotes a cppo, and we have
[[A + B]] = ([[A]] + [[B]])⊥
[[A → B]] = [[A]] → [[B]]
3I thank Hayo Thielecke for bringing this feature of ZINC to my attention.

ACM SIGLOG News 26 April 2022, Vol. 9, No. 2

 CBV type CBPV value type
A+B A+B
A→B U (A → F B)
CBV term x : A, y : B ` M : C CBPV computation x : A, y : B ` M : F C
x return x
inl M M to x. return inl x
λx. M return thunk λx. M
M N (operator-first) M to f. N to x. (force f)x
M N (operand-first) N to x. M to f. (force f)x
CBN type CBPV computation type
A+B F (U A + U B)
A→B UA → B
CBN term x : A, y : B ` M : C CBPV computation x : U A, y : U B ` M : C
x force x
inl M return inl thunk M
λx. M λx. M
MN M (thunk N )

Fig. 6. Decomposition of CBV and CBN into CBPV (selected clauses)

Here are some CBV examples:

Errors [[A → B]] = [[A]] → ([[B]] + E)
Printing [[A → B]] = [[A]] → (A∗ × [[B]])
Nondeterminism [[A → B]] = P([[A]] × [[B]])
Global store [[A → B]] = S → ([[A]] → (S × [[B]]))
Q P
Dynamically generated store [[A → B]]w = x>w (Sx → ([[A]]x → y>x (Sy × [[B]]y)))
Control [[A → B]] = ([[A]] × ([[B]] → R)) → R
These are all the same as (or isomorphic to) the model given in [Moggi 1991], except
for the model of dynamically generated store, which appeared in [Levy 2002].
7. WRAPPING UP
This article has provided a brief introduction to CBPV. We have seen operational se-
mantics in various forms including the CK-machine. We have also presented denota-
tional models for various effects, explained using computational ideas such as config-
uration, behaviour and observational preorder. Lastly, we have described (in outline)
how the CBV and CBN versions of the simply typed λ-calculus with effects can be seen
as subsystems of CBPV. This makes CBPV a natural framework to study many aspects
of λ-calculus, especially ones relating to effects.
Since this article is aimed at a general audience, it simply pulled CBPV out of a hat,
without giving a priori justification. Sceptical readers may object to this, but (as men-
toned in Section 3.1) the alternative is arduous: we would begin by carefully investi-
gating the semantics of CBV and CBN—far more complicated than that of CBPV—and
then observe empirically the CBPV structure common to all the models.
Another part of the λ-calculus and CBPV story that I have omitted is the connection
to category theory. Roughly speaking, whereas a model of λ-calculus is a certain kind
of category, a model of CBPV (with stacks and the pure continuation law) consists
of an adjunction between a category V that interprets value types and values and

ACM SIGLOG News 27 April 2022, Vol. 9, No. 2

 F /
Effectful setting Vo ⊥ D
U

Lift /
Recursion Cpo o ⊥ Cppo(
Inclusion

Free s-algebra
/
Interactive input Set o ⊥ Algs
Carrier

Inclusion /
Nondeterminism Set o ⊥ Rel
P

S×−
/
Global store Set o ⊥ Set
S→−

/
Dynamically generated store [W, Set] o ⊥ [W op , Set]

−→R
/
Control Set o ⊥ Setop
−→R

Free T -algebra
/
Monad T on Set Set o ⊥ SetT
Carrier

Fig. 7. Examples of adjunctions used in CBPV semantics

another category D that interprets computation types and stacks. The connectives U /F
and the computations are interpreted using the adjunction structure. Thus, whereas
Moggi [Moggi 1991] proposed to model effects using a certain kind of category V with a
monad, CBPV provides a more refined picture. For more details, see [Levy 2005; 2004].

Some examples are shown in Figure 7. Here we write Cpo for the category of cpos
and continuous functions; and Cppo( for the category of pointed cpos and strict
continuous functions; and Algs for the category of s-algebras and homomorphisms;
and Rel for the category of sets and relations; and [W, Set] for the category of func-
tors W → Set and natural transformations; and SetT for the category of Eilenberg-
Moore T -algebras and homomorphisms.
P In the case of dynamically generated store,
the left adjoint sends A to ( x>w (Sx × Ax))w∈W , and the right adjoint sends B to
Q
( x>w (Sx → Ax))w∈W .
Despite the omission of these advanced topics (and others), I hope that the diverse
semantics included in this article have made clear that, just as the simply typed λ-
calculus with all of its β- and η-laws is a fundamental calculus of pure functional pro-
gramming, so CBPV with its laws is a fundamental calculus of functional programming
with effects.

ACM SIGLOG News 28 April 2022, Vol. 9, No. 2

REFERENCES
S. Abramsky and G. McCusker. 1998. Call-by-Value Games. In Computer Science Logic: 11th International
Workshop Proceedings (LNCS), M. Nielsen and W. Thomas (Eds.). Springer, 1–17.
M. Felleisen and D. Friedman. 1986. Control operators, the SECD-machine, and the λ-calculus. In Formal
Description of Programming Concepts III, M. Wirsing (Ed.). North-Holland, 193–217.
A. Filinski. 1996. Controlling Effects. Ph.D. Dissertation. School of Computer Science, Carnegie Mellon Uni-
versity, Pittsburgh, Pennsylvania.
K. Honda and N. Yoshida. 1997. Game Theoretic Analysis of Call-by-Value Computation. In Automata,
Languages and Programming, 24th International Colloquium (LNCS), P. Degano, R. Gorrieri, and
A. Marchetti-Spaccamela (Eds.), Vol. 1256. Springer, Bologna, Italy, 225–236.
J. M. E. Hyland and C.-H. L. Ong. 2000. On Full Abstraction for PCF: I, II, and III. Information and Com-
putation 163, 2 (2000), 285–408.
X. Leroy. 1991. The ZINC experiment: an economical implementation of the ML language. Technical Report
117. INRIA.
P. B. Levy. 1999. Call-By-Push-Value: a Subsuming Paradigm (Extended Abstract). In Proceedings, Typed
λ-Calculi and Applications (LNCS), J-Y Girard (Ed.), Vol. 1581. 228–242.
P. B. Levy. 2001. Call-by-push-value. Ph.D. Dissertation. Queen Mary, University of London.
P. B. Levy. 2002. Possible World Semantics for General Storage in Call-By-Value. In Proceedings, 16th An-
nual Conference of the European Assocation for Computer Science Logic (CSL) (LNCS), J. Bradfield
(Ed.), Vol. 2471. Springer, 232–246.
P. B. Levy. 2004. Call-By-Push-Value. A Functional/Imperative Synthesis. Springer.
P. B. Levy. 2005. Adjunction Models For Call-By-Push-Value With Stacks. Theory and Applications of Cate-
gories 14 (2005), 75–110.
P. B. Levy. 2006a. Call-By-Push-Value: Decomposing Call-By-Value And Call-By-Name. Higher-Order and
Symbolic Computation 19, 4 (2006), 377–414.
P. B. Levy. 2006b. Jumbo λ-calculus. In Proc. , 33rd International Colloquium on Automata, Languages and
Programming (LNCS), Vol. 4052. Springer, 444–455.
P. B. Levy, A J Power, and H Thielecke. 2003. Modelling environments in call-by-value programming lan-
guages. Information and Computation 185 (2003), 182–210.
D. B. MacQueen, P. Wadler, and W. Taha. 1998. How to add laziness to a strict language without even being
odd. In Proceedings of the 1998 ACM SIGPLAN Workshop on Standard ML. Association for Computing
Machinery, Baltimore, MD, 24–30.
G. McCusker. 2000. Games and Full Abstraction for FPC. Information and Computation 160, 1-2 (2000),
1–61.
E Moggi. 1991. Notions of Computation and Monads. Information and Computation 93 (1991), 55–92.
H. Nickau. 1996. Hereditarily Sequential Functionals: A Game-Theoretic Approach to Sequentiality. Shaker-
Verlag. Dissertation, Universität Gesamthochschule Siegen.
G. D. Plotkin and J. Power. 2001. Adequacy for Algebraic Effects. In Proceedings of the 4th International
Conference on Foundations of Software Science and Computation Structures (FoSSaCS ’01). Springer-
Verlag, Berlin, Heidelberg, 1–24.
M. Smyth and G. D. Plotkin. 1982. The category-theoretic solution of recursive domain equations. SIAM
Journal on Computing 11 (1982), 761–783.

ACM SIGLOG News 29 April 2022, Vol. 9, No. 2