Depending on Session-Typed Processes

The process layer is able to refer to terms of the functional layer via appropriate (dependently-typed) communication actions and through a spawn construct, allowing for processes encapsulated as functional values to be executed. Dually, the functional layer can refer to the process layer via a contextual monad [31] that internalises (open) typed processes as opaque functional values. This mutual dependency is also explicit in the type structure on several axes: process channel usages are typed by a language of session types, which specifies the communication protocols implemented on the used channels, extended with two dependent communication operations $\forall x{:}\tau.A$ and $\exists x{:}\tau.A$, where $\tau$ is a functional type and $A$ is a session type in which $x$ may occur. Moreover, we also extend the language of session types with type-level $\lambda$-abstraction over terms $\lambda x{:}\tau.A$ and session types $\lambda t{::}K.A$ (with the corresponding elimination forms $A\,M$ and $A\,B$). As we show in § 1, the combination of these features allows for a new degree of expressiveness, enabling us to construct session types whose structure depends on previously communicated values.

The remaining session constructs are standard, following [5]: ${!}A$ denotes a shared session of type $A$ that may be used an arbitrary (finite) number of times; $A\multimap B$ represents a session offering to input a session of type $A$ to then offer the session behaviour $B$; $A\otimes B$ is the dual operator, denoting a session that outputs $A$ and proceeds as $B$; $\oplus\{\overline{l_{i}:A_{i}}\}$ and $\mathbin{\binampersand}\{\overline{l_{i}:A_{i}}\}$ represent internal and external labelled choice, respectively; $\mathbf{1}$ denotes the terminated session.

The functional layer is a $\lambda$-calculus with dependent functions $\Pi x{:}\tau.\sigma$, type-level $\lambda$-abstractions over terms and types (and respective type-level applications) and a contextual monadic type $\{\overline{u_{j}{:}B_{j}};\overline{d_{i}{:}A_{i}}\vdash c{:}A\}$, denoting a (quoted) process offering session $c{:}A$ by using the linear sessions $\overline{d_{i}{:}A_{i}}$ and shared sessions $\overline{u_{j}{:}B_{j}}$ [31]. We often write $\{A\}$ for $\{\cdot;\cdot\vdash c{:}A\}$. The kinding system for our theory contains two base kinds $\mathsf{type}$ and $\mathsf{stype}$ of functional and session types, respectively. Type-level $\lambda$-abstractions require dependent kinds $\Pi x{:}\tau.K$ and $\Pi t{::}K.K^{\prime}$, respectively. We note that the functional connectives form a standard dependent type theory [11, 23].

Terms include the standard $\lambda$-abstractions $\lambda x{:}\tau.M$, applications $M\,N$ and variables $x$. In order to internalise processes within the functional layer we make use of a monadic process wrapper, written $\{c\leftarrow P\leftarrow\overline{u_{j}};\overline{d_{i}}\}$. In such a construct, the channels $c$, $\overline{u_{j}}$ and $\overline{d_{i}}$ are bound in $P$, where $c$ is the session channel being offered and $\overline{u_{j}}$ and $\overline{d_{i}}$ are the session channels (linear and shared, respectively) being used. We write $\{c\leftarrow P\leftarrow\epsilon\}$ when $P$ does not use any ambient channels, which we abbreviate to $\{P\}$.

The syntax of processes follows that of [5] extended with the monadic elimination form $c\leftarrow M\leftarrow\overline{u_{j}};\overline{d_{i}};Q$. Such a process construct denotes a term $M$ that is to be evaluated to a monadic value of the form $\{c\leftarrow P\leftarrow\overline{u_{j}};\overline{d_{i}}\}$ which will then be executed in parallel with $Q$, sharing with it a session channel $c$ and using the provided channels $\overline{u_{j}}$ and $\overline{d_{i}}$. We write $c\leftarrow M\leftarrow\epsilon;Q$ when no channels are provided for the execution of $M$ and often abbreviate this to $c\leftarrow M;Q$. The process $\overline{c}\langle d\rangle.P$ denotes the output of the fresh channel $d$ along channel $c$ with continuation $P$, which binds $d$; $({\boldsymbol{\nu}}c)P$ denotes channel hiding, restricting the scope of $c$ to $P$; $c(x).P$ denotes an input along $c$, bound to $x$ in $P$; $c\langle M\rangle.P$ denotes the output of term $M$ along $c$ with continuation $P$; ${!}c(x).P$ denotes a replicated input which spawns copies of $P$; the construct $c.\mathsf{case}\{\overline{l_{i}\Rightarrow P_{i}}\}$ codifies a process that waits to receive some label $l_{j}$ along $c$, with continuation $P_{j}$; dually, $c.l;P$ denotes a process that emits a label $l$ along $c$ and continues as $P$; $[c\leftrightarrow d]$ denotes a forwarder between $c$ and $d$, which is operationally implemented as renaming; $P\mid Q$ denotes parallel composition and $\boldsymbol{0}$ the null process.

An excerpt of the typing rules for terms and processes is given in Fig. 3 and 4, respectively, noting that typing enforces types to be of base kind $\mathsf{type}$ (respectively $\mathsf{stype}$). The rules for dependent functions are standard, including the type conversion rule which internalises definitional equality of types. We highlight the introduction rule for the monadic construct, which requires the appropriate session types to be well-formed and the process $P$ to offer $c{:}A$ when provided with the appropriate session contexts.

In the typing rules for processes (Fig. 4), presented as a set of right and left rules (the former identifying how to offer a session of a given type and the latter how to use such a session), we highlight the rules for dependently-typed communication and monadic elimination (for type-checking purposes we annotate constructs with the respective dependent type – this is akin to functional type theories). To offer a session $c{:}\exists x{:}\tau.A$ we send a term $M$ of type $\tau$ and then offer a session $c{:}A\{M/x\}$; dually, to use such a session we perform an input along $c$, bound to $x$ in $Q$, warranting a use of $c$ as a session of (open) type $A$. The rules for the universal are dual. Offering a session $c{:}\forall x{:}\tau.A$ entails receiving on $c$ a term of type $\tau$ and offering $c{:}A$. Using a session of such a type requires sending along $c$ a term $M$ of type $\tau$, warranting the use of $c$ as a session of type $A\{M/x\}$.

The rule for the monadic elimination form requires that the term $M$ be of the appropriate monadic type and that the provided channels $\overline{u_{j}}$ and $\overline{y_{i}}$ adhere to the typing specified in $M$’s type. Under these conditions, the process $Q$ may then use the session $c$ as session $A$. The type conversion rules reflect session type definitional equality in typing.

The crux of any dependent type theory lies in its definitional equality. Type equality relies on equality of terms which, by including the monadic construct, necessarily relies on a notion of process equality.

Our presentation of an intensional definitional equality of terms follows that of [12], where we consider an intrinsically typed relation, including $\beta$ and $\eta$ conversion (similarly for type equality which includes $\beta$ and $\eta$ principles for the type-level $\lambda$-abstractions). An excerpt of the rules for term equality is given in Fig. 5. The remaining rules are congruence rules and closure under symmetry, reflexivity and transitivity. Rule $(\mathsf{TMEq}\beta)$ captures the $\beta$-reduction, identifying a $\lambda$-abstraction applied to an argument with the substitution of the argument in the function body (typed with the appropriately substituted type). We highlight rule $(\mathsf{TMEq}\{\}\eta)$, which codifies a general $\eta$-like principle for arbitrary terms of monadic type: We form a monadic term that applies the monadic elimination form to $M$, forwarding the result along the appropriate channel, which becomes a term equivalent to $M$.

Definitional equality of processes is summarised in Fig. 6. We rely on process reduction defined below. Definitional equality of processes consists of the usual congruence rules, (typed) reductions and the commutting conversions of linear logic and $\eta$-like principles, which allows for forwarding actions to be equated with the primitive syntactic forwarding construct. Commutting conversions amount to sound observational equivalences between processes [24], given that session composition requires name restriction (embodied by the $(\mathsf{cut})$ rule): In rule $(\mathsf{PEqCC}\forall)$, either process can only be interacted with via channel $c$ and so postponing actions of $P$ to after the input on $c$ (when reading the equality from left to right) cannot impact the process’ observable behaviours. While $P$ can in general interact with sessions in $\Delta$ (or with $Q$), these interactions are unobservable due to hiding in the $(\mathsf{cut})$ rule.

The operational semantics for the $\lambda$-calculus is standard, noting that no reduction can take place inside monadic terms. The operational (reduction) semantics for processes is presented below where we omit closure under structural congruence and the standard congruence rules [4, 27, 31]. The last rule defines spawning a process in a monadic term.

Given the observation above, a seemingly reasonable option would be to attempt an encoding that maintains monadic objects solely at the level of type indices and then exploits Girard’s encoding [9] of function types $\tau\rightarrow\sigma$ as ${!}\llbracket\tau\rrbracket\rightarrow\llbracket\sigma\rrbracket$, which is adequate for session-typed processes [30]. Thus a candidate encoding for the type $\Pi x{:}\tau.\sigma$ would be $\forall x{:}\{\llbracket\tau\rrbracket\}.{!}\llbracket\tau\rrbracket\multimap\llbracket\sigma\rrbracket$, where $\llbracket{-}\rrbracket$ denotes our encoding on types. If we then consider the encoding at the level of terms, typing dictates the following (we write $\llbracket M\rrbracket_{z}$ for the process encoding of $M:\tau$, where $z$ is the session channel along which one may observe the “result” of the encoding, typed with $\llbracket\tau\rrbracket$):

However, this candidate encoding breaks down once we consider definitional equality. Specifically, compositionality (i.e. the relationship between $\llbracket M\{N/x\}\rrbracket_{z}$ and the encoding of $N$ substituted in that of $M$) requires us to relate $\llbracket M\{N/x\}\rrbracket_{z}$ with $({\boldsymbol{\nu}}x)(\llbracket M\rrbracket_{z}\{\{\llbracket N\rrbracket_{y}\}/x\}\mid{!}x^{\prime}(y).\llbracket N\rrbracket_{y})$, which relies on reasoning up-to observational equivalence of processes, a much stronger relation than our notion of definitional equality. Therefore it is fundamentally impossible for such an encoding to preserve our definitional equality, and thus it cannot preserve typing in the general case.

We now develop our embedding of the functional layer into the process layer which is compatible with definitional equality. Our target calculus is reminiscent of a higher-order (in the sense of higher-order processes [25]) session calculus [21]. Our encoding $\llbracket{-}\rrbracket$ is inductively defined on kinds, types, session types, terms and processes. As usual in process encodings of the $\lambda$-calculus, the encoding of a term $M$ is indexed by a result channel $z$, written $\llbracket M\rrbracket_{z}$, where the behaviour of $M$ may be observed.

The embedding is presented in Fig. 7, noting that the encoding extends straightforwardly to typing contexts, where functional contexts $\Psi,x{:}\tau$ are mapped to $\{\llbracket\Psi\rrbracket\},x{:}\{\llbracket\tau\rrbracket\}$. The mapping of base kinds is straightforward. Dependent kinds $\Pi x{:}\tau.K$ rely on the monad for well-formedness and are encoded as (session) kinds of the form $\Pi x{:}\{\llbracket\tau\rrbracket\}.\llbracket K\rrbracket$. The higher-kinded types in the functional layer are translated to the corresponding type-level constructs of the process layer where all objects that must be $\mathsf{type}$-kinded rely on the monad to satisfy this constraint. For instance, $\lambda x{:}\tau.\sigma$ is mapped to the session-type abstraction $\lambda x{:}\{\llbracket\tau\rrbracket\}.\llbracket\sigma\rrbracket$ and the type-level application $\tau\,M$ is translated to $\llbracket\tau\rrbracket\,\{\llbracket M\rrbracket_{c}\}$. Given the observation above on embedding the dependent function type $\Pi x{:}\tau.\sigma$, we translate it directly to $\forall x{:}\{\llbracket\tau\rrbracket\}.\llbracket\sigma\rrbracket$, that is, functions from $\tau$ to $\sigma$ are mapped to sessions that input processes implementing $\llbracket\tau\rrbracket$ and then behave as $\llbracket\sigma\rrbracket$ accordingly. The encoding for monadic types simply realises the contextual nature of the monad by performing a sequence of inputs of the appropriate types (with the shared sessions being of ${!}$ type).