Intersections and Unions of Session Types

Co\c{s}ku Acay (Carnegie Mellon University); Frank Pfenning (Carnegie; Mellon University)

arXiv:1702.02272·cs.PL·February 9, 2017·ITRS

Intersections and Unions of Session Types

Co\c{s}ku Acay (Carnegie Mellon University), Frank Pfenning (Carnegie, Mellon University)

PDF

TL;DR

This paper extends session types with intersection and union types to better express multiple behavioral properties of processes, proving key properties like session fidelity and deadlock freedom, and illustrating their expressive power.

Contribution

It introduces intersection and union types into session-typed calculi, enhancing expressiveness and providing formal proofs of correctness properties.

Findings

01

Representation of internal and external choice using intersection and union

02

Proofs of session fidelity and deadlock freedom

03

Demonstration of increased expressive power

Abstract

Prior work has extended the deep, logical connection between the linear sequent calculus and session-typed message-passing concurrent computation with equi-recursive types and a natural notion of subtyping. In this paper, we extend this further by intersection and union types in order to express multiple behavioral properties of processes in a single type. We prove session fidelity and absence of deadlock and illustrate the expressive power of our system with some simple examples. We observe that we can represent internal and external choice by intersection and union, respectively, which was previously suggested by Padovani for a different language of session types motivated by operational rather than logical concerns.

Equations60

c_{1} : A_{1}, \dots, c_{n} : A_{n} ⊢ P :: (c : A)

c_{1} : A_{1}, \dots, c_{n} : A_{n} ⊢ P :: (c : A)

Ψ, Ψ^{'} ⊢ c \leftarrow P_{c}; Q_{c} :: (d : D) \lx@proof@logical@and Ψ ⊢ P_{c} :: (c : A) Ψ^{'}, c : A ⊢ Q_{c} :: (d : D)

Ψ, Ψ^{'} ⊢ c \leftarrow P_{c}; Q_{c} :: (d : D) \lx@proof@logical@and Ψ ⊢ P_{c} :: (c : A) Ψ^{'}, c : A ⊢ Q_{c} :: (d : D)

d : A ⊢ c \leftarrow d :: (c : A)

d : A ⊢ c \leftarrow d :: (c : A)

η ::= \cdot ∣ η, t = A ∣ X :: (c : A) = P_{c}

η ::= \cdot ∣ η, t = A ∣ X :: (c : A) = P_{c}

\begin{array}[]{lcl}\mathsf{Nat}&=&\oplus\{\mathsf{zero}:\mathbf{1},\mathsf{succ}:\mathsf{Nat}\}\\ \mathsf{z}::(c:\mathsf{Nat})&=&c.\mathsf{zero}\mathrel{;}\mbox{\bf close}\;c\\ \mathsf{s}::(c:\mathsf{Nat}\multimap\mathsf{Nat})&=&d\leftarrow\mbox{\bf recv}\;c\mathrel{;}c.\mathsf{succ}\mathrel{;}c\leftarrow d\end{array}

\begin{array}[]{lcl}\mathsf{Nat}&=&\oplus\{\mathsf{zero}:\mathbf{1},\mathsf{succ}:\mathsf{Nat}\}\\ \mathsf{z}::(c:\mathsf{Nat})&=&c.\mathsf{zero}\mathrel{;}\mbox{\bf close}\;c\\ \mathsf{s}::(c:\mathsf{Nat}\multimap\mathsf{Nat})&=&d\leftarrow\mbox{\bf recv}\;c\mathrel{;}c.\mathsf{succ}\mathrel{;}c\leftarrow d\end{array}

\begin{array}[]{l}\mathsf{double}::(c:\mathsf{Nat}\multimap\mathsf{Nat})=\\ \quad d\leftarrow\mbox{\bf recv}\;c\mathrel{;}\\ \quad\mbox{\bf case}\;d\;\mbox{\bf of}\\ \quad\quad\mathsf{zero}\rightarrow\mbox{\bf wait}\;d\mathrel{;}c.\mathsf{zero}\mathrel{;}\mbox{\bf close}\;c\\ \quad\quad\mathsf{succ}\rightarrow c.\mathsf{succ}\mathrel{;}c.\mathsf{succ}\mathrel{;}\\ \hskip 60.00009pte\leftarrow\mathsf{double}\mathrel{;}\mbox{\bf send}\;e\;(d^{\prime}\leftarrow(d^{\prime}\leftarrow d))\mathrel{;}c\leftarrow e\end{array}

\begin{array}[]{l}\mathsf{double}::(c:\mathsf{Nat}\multimap\mathsf{Nat})=\\ \quad d\leftarrow\mbox{\bf recv}\;c\mathrel{;}\\ \quad\mbox{\bf case}\;d\;\mbox{\bf of}\\ \quad\quad\mathsf{zero}\rightarrow\mbox{\bf wait}\;d\mathrel{;}c.\mathsf{zero}\mathrel{;}\mbox{\bf close}\;c\\ \quad\quad\mathsf{succ}\rightarrow c.\mathsf{succ}\mathrel{;}c.\mathsf{succ}\mathrel{;}\\ \hskip 60.00009pte\leftarrow\mathsf{double}\mathrel{;}\mbox{\bf send}\;e\;(d^{\prime}\leftarrow(d^{\prime}\leftarrow d))\mathrel{;}c\leftarrow e\end{array}

\begin{array}[]{ll}e\leftarrow\mathsf{double}&\mbox{cut: start a new process $\mathsf{double}$ which provides along the new channel $e$}\\ \mbox{\bf send}\;e\;(d^{\prime}\leftarrow(d^{\prime}\leftarrow d))&\mbox{essentially, send $d$ along $e$ to the new process, but we have to use a forward}\\ c\leftarrow e&\mbox{now forward $e$ to $c$}\end{array}

\begin{array}[]{ll}e\leftarrow\mathsf{double}&\mbox{cut: start a new process $\mathsf{double}$ which provides along the new channel $e$}\\ \mbox{\bf send}\;e\;(d^{\prime}\leftarrow(d^{\prime}\leftarrow d))&\mbox{essentially, send $d$ along $e$ to the new process, but we have to use a forward}\\ c\leftarrow e&\mbox{now forward $e$ to $c$}\end{array}

\begin{array}[]{l}\mathsf{double}:\mathsf{Nat}\multimap\mathsf{Nat}\\ c\leftarrow\mathsf{double}\;d=\\ \quad\mbox{\bf case}\;d\;\mbox{\bf of}\\ \quad\quad\mathsf{zero}\rightarrow\mbox{\bf wait}\;d\mathrel{;}c.\mathsf{zero}\mathrel{;}\mbox{\bf close}\;c\\ \quad\quad\mathsf{succ}\rightarrow c.\mathsf{succ}\mathrel{;}c.\mathsf{succ}\mathrel{;}\\ \hskip 60.00009ptc\leftarrow\mathsf{double}\;d\end{array}

\begin{array}[]{l}\mathsf{double}:\mathsf{Nat}\multimap\mathsf{Nat}\\ c\leftarrow\mathsf{double}\;d=\\ \quad\mbox{\bf case}\;d\;\mbox{\bf of}\\ \quad\quad\mathsf{zero}\rightarrow\mbox{\bf wait}\;d\mathrel{;}c.\mathsf{zero}\mathrel{;}\mbox{\bf close}\;c\\ \quad\quad\mathsf{succ}\rightarrow c.\mathsf{succ}\mathrel{;}c.\mathsf{succ}\mathrel{;}\\ \hskip 60.00009ptc\leftarrow\mathsf{double}\;d\end{array}

⊢_{η} \emptyset ⊢_{η} η^{'}, t = A \lx@proof@logical@and ⊢_{η} η^{'} ⊢_{η} A : type ⊢_{η} η^{'}, X :: (c : A) = P_{c} \lx@proof@logical@and ⊢_{η} η^{'} ⊢_{η} A : type \emptyset ⊢_{η} P_{c} :: (c : A)

⊢_{η} \emptyset ⊢_{η} η^{'}, t = A \lx@proof@logical@and ⊢_{η} η^{'} ⊢_{η} A : type ⊢_{η} η^{'}, X :: (c : A) = P_{c} \lx@proof@logical@and ⊢_{η} η^{'} ⊢_{η} A : type \emptyset ⊢_{η} P_{c} :: (c : A)

c : A ⊢ d \leftarrow c :: (d : A) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, Ψ^{'} ⊢ c \leftarrow P_{c}; Q_{c} :: (d : D) \lx@proof@logical@and Ψ ⊢ P_{c} :: (c : A) Ψ^{'}, c : A ⊢ Q_{c} :: (d : D) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt \emptyset ⊢ close c :: (c : 1) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : 1 ⊢ wait c; P :: (d : A) Ψ ⊢ P :: (d : A) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, Ψ^{'} ⊢ send c (d \leftarrow P_{d}); Q :: (c : A \otimes B) \lx@proof@logical@and Ψ ⊢ P_{d} :: (d : A) Ψ^{'} ⊢ Q :: (c : B) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : A \otimes B ⊢ d \leftarrow recv c; P_{d} :: (e : E) Ψ, d : A, c : B ⊢ P_{d} :: (e : E) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ ⊢ c . l a b_{i}; P :: (c : \oplus {l a b_{k} : A_{k}}_{k \in I}) \lx@proof@logical@and i \in I Ψ ⊢ P :: (c : A_{i}) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : \oplus {l a b_{k} : A_{k}}_{k \in I} ⊢ case c of {l a b_{k} \to P_{k}}_{k \in J} :: (d : D) \lx@proof@logical@and I \subseteq J Ψ, c : A_{k} ⊢ P_{k} :: (d : D) for k \in I \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ ⊢ d \leftarrow recv c; P_{d} :: (c : A ⊸ B) Ψ, d : A ⊢ P_{d} :: (c : B) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, Ψ^{'}, c : A ⊸ B ⊢ send c (d \leftarrow P_{d}); Q :: (e : E) \lx@proof@logical@and Ψ ⊢ P_{d} :: (d : A) Ψ^{'}, c : B ⊢ Q :: (e : E) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ ⊢ case c of {l a b_{k} \to P_{k}}_{k \in I} :: (c : & {l a b_{k} : A_{k}}_{k \in J}) \lx@proof@logical@and J \subseteq I Ψ ⊢ P_{k} :: (c : A_{k}) for k \in J \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : & {l a b_{k} : A_{k}}_{k \in I} ⊢ c . l a b_{i}; P :: (d : D) \lx@proof@logical@and i \in I Ψ, c : A_{i} ⊢ P :: (d : D) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt \emptyset ⊢ X :: (d : A) X = P :: (c : A) \in η

c : A ⊢ d \leftarrow c :: (d : A) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, Ψ^{'} ⊢ c \leftarrow P_{c}; Q_{c} :: (d : D) \lx@proof@logical@and Ψ ⊢ P_{c} :: (c : A) Ψ^{'}, c : A ⊢ Q_{c} :: (d : D) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt \emptyset ⊢ close c :: (c : 1) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : 1 ⊢ wait c; P :: (d : A) Ψ ⊢ P :: (d : A) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, Ψ^{'} ⊢ send c (d \leftarrow P_{d}); Q :: (c : A \otimes B) \lx@proof@logical@and Ψ ⊢ P_{d} :: (d : A) Ψ^{'} ⊢ Q :: (c : B) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : A \otimes B ⊢ d \leftarrow recv c; P_{d} :: (e : E) Ψ, d : A, c : B ⊢ P_{d} :: (e : E) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ ⊢ c . l a b_{i}; P :: (c : \oplus {l a b_{k} : A_{k}}_{k \in I}) \lx@proof@logical@and i \in I Ψ ⊢ P :: (c : A_{i}) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : \oplus {l a b_{k} : A_{k}}_{k \in I} ⊢ case c of {l a b_{k} \to P_{k}}_{k \in J} :: (d : D) \lx@proof@logical@and I \subseteq J Ψ, c : A_{k} ⊢ P_{k} :: (d : D) for k \in I \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ ⊢ d \leftarrow recv c; P_{d} :: (c : A ⊸ B) Ψ, d : A ⊢ P_{d} :: (c : B) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, Ψ^{'}, c : A ⊸ B ⊢ send c (d \leftarrow P_{d}); Q :: (e : E) \lx@proof@logical@and Ψ ⊢ P_{d} :: (d : A) Ψ^{'}, c : B ⊢ Q :: (e : E) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ ⊢ case c of {l a b_{k} \to P_{k}}_{k \in I} :: (c : & {l a b_{k} : A_{k}}_{k \in J}) \lx@proof@logical@and J \subseteq I Ψ ⊢ P_{k} :: (c : A_{k}) for k \in J \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : & {l a b_{k} : A_{k}}_{k \in I} ⊢ c . l a b_{i}; P :: (d : D) \lx@proof@logical@and i \in I Ψ, c : A_{i} ⊢ P :: (d : D) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt \emptyset ⊢ X :: (d : A) X = P :: (c : A) \in η

A \leq_{η} t \lx@proof@logical@and (t = B \in η) A \leq_{η} B \penalty 50 pl u s 0.5 f i l min u s 5.0 ptt \leq_{η} B \lx@proof@logical@and (t = A \in η) A \leq_{η} B

A \leq_{η} t \lx@proof@logical@and (t = B \in η) A \leq_{η} B \penalty 50 pl u s 0.5 f i l min u s 5.0 ptt \leq_{η} B \lx@proof@logical@and (t = A \in η) A \leq_{η} B

Ψ ⊢_{η} P :: (c : A) \lx@proof@logical@and Ψ ⊢_{η} P :: (c : A^{'}) A^{'} \leq_{η} A \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : A ⊢_{η} P :: (d : B) \lx@proof@logical@and Ψ, c : A^{'} ⊢_{η} P :: (d : B) A \leq_{η} A^{'}

Ψ ⊢_{η} P :: (c : A) \lx@proof@logical@and Ψ ⊢_{η} P :: (c : A^{'}) A^{'} \leq_{η} A \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : A ⊢_{η} P :: (d : B) \lx@proof@logical@and Ψ, c : A^{'} ⊢_{η} P :: (d : B) A \leq_{η} A^{'}

⊨ \emptyset :: \emptyset \penalty 50 pl u s 0.5 f i l min u s 5.0 pt ⊨ Ω, proc_{c} (P) :: (c : A) \lx@proof@logical@and ⊨ Ω :: Ψ Ψ ⊢ P :: (c : A) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt ⊨ Ω_{1}, \dots, Ω_{n} :: (c_{1} : A_{1}, \dots, c_{n} : A_{n}) \lx@proof@logical@and ⊨ Ω_{i} :: (c_{i} : A_{i}) for i \in {1, \dots, n} n > 1

⊨ \emptyset :: \emptyset \penalty 50 pl u s 0.5 f i l min u s 5.0 pt ⊨ Ω, proc_{c} (P) :: (c : A) \lx@proof@logical@and ⊨ Ω :: Ψ Ψ ⊢ P :: (c : A) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt ⊨ Ω_{1}, \dots, Ω_{n} :: (c_{1} : A_{1}, \dots, c_{n} : A_{n}) \lx@proof@logical@and ⊨ Ω_{i} :: (c_{i} : A_{i}) for i \in {1, \dots, n} n > 1

\begin{array}[]{lcll}\Omega,\mathtt{proc}_{c}(c\leftarrow d)&\longrightarrow&[d/c]\Omega\\ \Omega,\mathtt{proc}_{c}(x\leftarrow P_{x}\,;\,Q_{x})&\longrightarrow&\Omega,\mathtt{proc}_{a}(P_{a}),\mathtt{proc}_{c}(Q_{a})&\mbox{($a$ fresh)}\\ \Omega,\mathtt{proc}_{c}(X)&\longrightarrow&\lx@intercol\hfil\Omega,\mathtt{proc}_{c}([c/d]P)\quad\mbox{($X=P::(d:A)\in\eta$)}\lx@intercol\\ \Omega,\mathtt{proc}_{c}(\mathrm{close}\;c),\mathtt{proc}_{e}(\mathrm{wait}\;c\,;\,P)&\longrightarrow&\Omega,\mathtt{proc}_{e}(P)\\ \Omega,\mathtt{proc}_{c}(\mathrm{send}\;c\;(x\leftarrow P_{x})\,;\,Q),\mathtt{proc}_{e}(x\leftarrow\mathrm{recv}\;c\,;\,R_{x})&\longrightarrow&\\ &\lx@intercol\hfil\Omega,\mathtt{proc}_{a}(P_{a}),\mathtt{proc}_{c}(Q),\mathtt{proc}_{e}(R_{a})\quad\mbox{($a$ fresh)}\lx@intercol\\ \Omega,\mathtt{proc}_{c}({c}.lab_{i}\,;\,{P}),\mathtt{proc}_{e}(\mathrm{case}\;c\;\mathrm{of}\;\{lab_{k}\rightarrow Q_{k}\}_{k\in I})&\longrightarrow&\Omega,\mathtt{proc}_{c}(P),\mathtt{proc}_{e}(Q_{i})&\mbox{($i\in I$)}\\ \Omega,\mathtt{proc}_{c}(x\leftarrow\mathrm{recv}\;c\,;\,P_{x}),\mathtt{proc}_{d}(\mathrm{send}\;c\;(x\leftarrow Q_{x})\,;\,R)&\longrightarrow&\\ &\lx@intercol\hfil\Omega,\mathtt{proc}_{c}(P_{a}),\mathtt{proc}_{a}(Q_{a}),\mathtt{proc}_{d}(R)\quad\mbox{($a$ fresh)}\lx@intercol\\ \Omega,\mathtt{proc}_{c}(\mathrm{case}\;c\;\mathrm{of}\;\{lab_{k}\rightarrow P_{k}\}_{k\in I}),\mathtt{proc}_{e}({c}.lab_{i}\,;\,{Q})&\longrightarrow&\Omega,\mathtt{proc}_{c}(P_{i}),\mathtt{proc}_{e}(Q)&\mbox{($i\in I$)}\\ \end{array}

\begin{array}[]{lcll}\Omega,\mathtt{proc}_{c}(c\leftarrow d)&\longrightarrow&[d/c]\Omega\\ \Omega,\mathtt{proc}_{c}(x\leftarrow P_{x}\,;\,Q_{x})&\longrightarrow&\Omega,\mathtt{proc}_{a}(P_{a}),\mathtt{proc}_{c}(Q_{a})&\mbox{($a$ fresh)}\\ \Omega,\mathtt{proc}_{c}(X)&\longrightarrow&\lx@intercol\hfil\Omega,\mathtt{proc}_{c}([c/d]P)\quad\mbox{($X=P::(d:A)\in\eta$)}\lx@intercol\\ \Omega,\mathtt{proc}_{c}(\mathrm{close}\;c),\mathtt{proc}_{e}(\mathrm{wait}\;c\,;\,P)&\longrightarrow&\Omega,\mathtt{proc}_{e}(P)\\ \Omega,\mathtt{proc}_{c}(\mathrm{send}\;c\;(x\leftarrow P_{x})\,;\,Q),\mathtt{proc}_{e}(x\leftarrow\mathrm{recv}\;c\,;\,R_{x})&\longrightarrow&\\ &\lx@intercol\hfil\Omega,\mathtt{proc}_{a}(P_{a}),\mathtt{proc}_{c}(Q),\mathtt{proc}_{e}(R_{a})\quad\mbox{($a$ fresh)}\lx@intercol\\ \Omega,\mathtt{proc}_{c}({c}.lab_{i}\,;\,{P}),\mathtt{proc}_{e}(\mathrm{case}\;c\;\mathrm{of}\;\{lab_{k}\rightarrow Q_{k}\}_{k\in I})&\longrightarrow&\Omega,\mathtt{proc}_{c}(P),\mathtt{proc}_{e}(Q_{i})&\mbox{($i\in I$)}\\ \Omega,\mathtt{proc}_{c}(x\leftarrow\mathrm{recv}\;c\,;\,P_{x}),\mathtt{proc}_{d}(\mathrm{send}\;c\;(x\leftarrow Q_{x})\,;\,R)&\longrightarrow&\\ &\lx@intercol\hfil\Omega,\mathtt{proc}_{c}(P_{a}),\mathtt{proc}_{a}(Q_{a}),\mathtt{proc}_{d}(R)\quad\mbox{($a$ fresh)}\lx@intercol\\ \Omega,\mathtt{proc}_{c}(\mathrm{case}\;c\;\mathrm{of}\;\{lab_{k}\rightarrow P_{k}\}_{k\in I}),\mathtt{proc}_{e}({c}.lab_{i}\,;\,{Q})&\longrightarrow&\Omega,\mathtt{proc}_{c}(P_{i}),\mathtt{proc}_{e}(Q)&\mbox{($i\in I$)}\\ \end{array}

\begin{array}[]{lcll}\mathsf{Nat}&=&\oplus\{\mathsf{zero}:\mathbf{1},\mathsf{succ}:\mathsf{Nat}\}\\[10.00002pt] \mathsf{Pos}&=&\oplus\{\mathsf{succ}:\mathsf{Nat}\}\\ \mathsf{Even}&=&\oplus\{\mathsf{zero}:\mathbf{1},\mathsf{succ}:\mathsf{Odd}\}\\ \mathsf{Odd}&=&\oplus\{\mathsf{succ}:\mathsf{Even}\}\\[10.00002pt] \end{array}

\begin{array}[]{lcll}\mathsf{Nat}&=&\oplus\{\mathsf{zero}:\mathbf{1},\mathsf{succ}:\mathsf{Nat}\}\\[10.00002pt] \mathsf{Pos}&=&\oplus\{\mathsf{succ}:\mathsf{Nat}\}\\ \mathsf{Even}&=&\oplus\{\mathsf{zero}:\mathbf{1},\mathsf{succ}:\mathsf{Odd}\}\\ \mathsf{Odd}&=&\oplus\{\mathsf{succ}:\mathsf{Even}\}\\[10.00002pt] \end{array}

\begin{array}[]{l@{\hspace{2em}}l@{\hspace{2em}}l}\mathsf{z}:\mathsf{Nat}\hfil\hskip 20.00003pt&\mathsf{s}:\mathsf{Nat}\multimap\mathsf{Nat}\hfil\hskip 20.00003pt&\mathsf{double}:\mathsf{Nat}\multimap\mathsf{Nat}\\ c\leftarrow\mathsf{z}=\hfil\hskip 20.00003pt&c\leftarrow\mathsf{s}\;d=\hfil\hskip 20.00003pt&c\leftarrow\mathsf{double}\;d=\\ \quad c.\mathsf{zero}\mathrel{;}\mbox{\bf close}\;c\hfil\hskip 20.00003pt&\quad c.\mathsf{succ}\mathrel{;}c\leftarrow d\hfil\hskip 20.00003pt&\quad\mbox{\bf case}\;d\;\mbox{\bf of}\\ \hfil\hskip 20.00003pt&\hfil\hskip 20.00003pt&\quad\quad\mathsf{zero}\rightarrow\mbox{\bf wait}\;d\mathrel{;}c.\mathsf{zero}\mathrel{;}\mbox{\bf close}\;c\\ \hfil\hskip 20.00003pt&\hfil\hskip 20.00003pt&\quad\quad\mathsf{succ}\rightarrow c.\mathsf{succ}\mathrel{;}c.\mathsf{succ}\mathrel{;}\\ \hfil\hskip 20.00003pt&\hfil\hskip 20.00003pt&\hskip 60.00009ptc\leftarrow\mathsf{double}\;d\end{array}

\begin{array}[]{l@{\hspace{2em}}l@{\hspace{2em}}l}\mathsf{z}:\mathsf{Nat}\hfil\hskip 20.00003pt&\mathsf{s}:\mathsf{Nat}\multimap\mathsf{Nat}\hfil\hskip 20.00003pt&\mathsf{double}:\mathsf{Nat}\multimap\mathsf{Nat}\\ c\leftarrow\mathsf{z}=\hfil\hskip 20.00003pt&c\leftarrow\mathsf{s}\;d=\hfil\hskip 20.00003pt&c\leftarrow\mathsf{double}\;d=\\ \quad c.\mathsf{zero}\mathrel{;}\mbox{\bf close}\;c\hfil\hskip 20.00003pt&\quad c.\mathsf{succ}\mathrel{;}c\leftarrow d\hfil\hskip 20.00003pt&\quad\mbox{\bf case}\;d\;\mbox{\bf of}\\ \hfil\hskip 20.00003pt&\hfil\hskip 20.00003pt&\quad\quad\mathsf{zero}\rightarrow\mbox{\bf wait}\;d\mathrel{;}c.\mathsf{zero}\mathrel{;}\mbox{\bf close}\;c\\ \hfil\hskip 20.00003pt&\hfil\hskip 20.00003pt&\quad\quad\mathsf{succ}\rightarrow c.\mathsf{succ}\mathrel{;}c.\mathsf{succ}\mathrel{;}\\ \hfil\hskip 20.00003pt&\hfil\hskip 20.00003pt&\hskip 60.00009ptc\leftarrow\mathsf{double}\;d\end{array}

\begin{array}[]{lcl}\mathsf{z}&:&\mathsf{Nat}\mathrel{\sqcap}\mathsf{Even}\\ \mathsf{s}&:&(\mathsf{Nat}\multimap\mathsf{Nat})\mathrel{\sqcap}(\mathsf{Even}\multimap\mathsf{Odd})\mathrel{\sqcap}(\mathsf{Odd}\multimap\mathsf{Even})\\ \mathsf{double}&:&(\mathsf{Nat}\multimap\mathsf{Nat})\mathrel{\sqcap}(\mathsf{Nat}\multimap\mathsf{Even})\end{array}

\begin{array}[]{lcl}\mathsf{z}&:&\mathsf{Nat}\mathrel{\sqcap}\mathsf{Even}\\ \mathsf{s}&:&(\mathsf{Nat}\multimap\mathsf{Nat})\mathrel{\sqcap}(\mathsf{Even}\multimap\mathsf{Odd})\mathrel{\sqcap}(\mathsf{Odd}\multimap\mathsf{Even})\\ \mathsf{double}&:&(\mathsf{Nat}\multimap\mathsf{Nat})\mathrel{\sqcap}(\mathsf{Nat}\multimap\mathsf{Even})\end{array}

Ψ ⊢_{η} P :: (c : A ⊓ B) \lx@proof@logical@and Ψ ⊢_{η} P :: (c : A) Ψ ⊢_{η} P :: (c : B)

Ψ ⊢_{η} P :: (c : A ⊓ B) \lx@proof@logical@and Ψ ⊢_{η} P :: (c : A) Ψ ⊢_{η} P :: (c : B)

Ψ, c : A ⊓ B ⊢_{η} P :: (d : D) Ψ, c : A ⊢_{η} P :: (d : D) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : A ⊓ B ⊢_{η} P :: (d : D) Ψ, c : B ⊢_{η} P :: (d : D)

Ψ, c : A ⊓ B ⊢_{η} P :: (d : D) Ψ, c : A ⊢_{η} P :: (d : D) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : A ⊓ B ⊢_{η} P :: (d : D) Ψ, c : B ⊢_{η} P :: (d : D)

\begin{array}[]{l}\mathsf{s}:(\mathsf{Even}\multimap\mathsf{Odd})\mathrel{\sqcap}(\mathsf{Odd}\multimap\mathsf{Even})\quad\mbox{\it(from before)}\\[4.30554pt] \mathsf{s2}:\mathsf{Even}\multimap\mathsf{Even}\\[4.30554pt] c\leftarrow\mathsf{s2}\;d=\\ \quad d_{1}\leftarrow\mathsf{s}\;d\hskip 50.00008pt\mbox{\it(use $\mathsf{s}:\mathsf{Even}\multimap\mathsf{Odd}$ by $\mathrel{\sqcap}\texttt{L}_{1}$)}\\ \quad c\leftarrow\mathsf{s}\;d_{1}\hskip 50.00008pt\mbox{\it(use $\mathsf{s}:\mathsf{Odd}\multimap\mathsf{Even}$ by $\mathrel{\sqcap}\texttt{L}_{2}$)}\end{array}

\begin{array}[]{l}\mathsf{s}:(\mathsf{Even}\multimap\mathsf{Odd})\mathrel{\sqcap}(\mathsf{Odd}\multimap\mathsf{Even})\quad\mbox{\it(from before)}\\[4.30554pt] \mathsf{s2}:\mathsf{Even}\multimap\mathsf{Even}\\[4.30554pt] c\leftarrow\mathsf{s2}\;d=\\ \quad d_{1}\leftarrow\mathsf{s}\;d\hskip 50.00008pt\mbox{\it(use $\mathsf{s}:\mathsf{Even}\multimap\mathsf{Odd}$ by $\mathrel{\sqcap}\texttt{L}_{1}$)}\\ \quad c\leftarrow\mathsf{s}\;d_{1}\hskip 50.00008pt\mbox{\it(use $\mathsf{s}:\mathsf{Odd}\multimap\mathsf{Even}$ by $\mathrel{\sqcap}\texttt{L}_{2}$)}\end{array}

A \leq B_{1} ⊓ B_{2} A \leq B_{1} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt A \leq B_{2} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt A_{1} ⊓ A_{2} \leq B A_{1} \leq B \penalty 50 pl u s 0.5 f i l min u s 5.0 pt A_{1} ⊓ A_{2} \leq B A_{2} \leq B

A \leq B_{1} ⊓ B_{2} A \leq B_{1} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt A \leq B_{2} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt A_{1} ⊓ A_{2} \leq B A_{1} \leq B \penalty 50 pl u s 0.5 f i l min u s 5.0 pt A_{1} ⊓ A_{2} \leq B A_{2} \leq B

Ψ ⊢_{η} P :: (c : A ⊔ B) Ψ ⊢_{η} P :: (c : A) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ ⊢_{η} P :: (c : A ⊔ B) Ψ ⊢_{η} P :: (c : B) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : A ⊔ B ⊢_{η} P :: (d : D) \lx@proof@logical@and Ψ, c : A ⊢_{η} P :: (d : D) Ψ, c : B ⊢_{η} P :: (d : D)

Ψ ⊢_{η} P :: (c : A ⊔ B) Ψ ⊢_{η} P :: (c : A) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ ⊢_{η} P :: (c : A ⊔ B) Ψ ⊢_{η} P :: (c : B) \penalty 50 pl u s 0.5 f i l min u s 5.0 pt Ψ, c : A ⊔ B ⊢_{η} P :: (d : D) \lx@proof@logical@and Ψ, c : A ⊢_{η} P :: (d : D) Ψ, c : B ⊢_{η} P :: (d : D)

A \leq B_{1} ⊔ B_{2} A \leq B_{1} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt A \leq B_{1} ⊔ B_{2} A \leq B_{2} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt A_{1} ⊔ A_{2} \leq B \lx@proof@logical@and A_{1} \leq B A_{2} \leq B

A \leq B_{1} ⊔ B_{2} A \leq B_{1} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt A \leq B_{1} ⊔ B_{2} A \leq B_{2} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt A_{1} ⊔ A_{2} \leq B \lx@proof@logical@and A_{1} \leq B A_{2} \leq B

\begin{array}[]{lcl}\mathsf{Bits}&=&\oplus\{\mathsf{eps}:\mathbf{1},\mathsf{zero}:\mathsf{Bits},\mathsf{one}:\mathsf{Bits}\}\end{array}

\begin{array}[]{lcl}\mathsf{Bits}&=&\oplus\{\mathsf{eps}:\mathbf{1},\mathsf{zero}:\mathsf{Bits},\mathsf{one}:\mathsf{Bits}\}\end{array}

\begin{array}[]{lcl}\mathsf{Std}&=&\mathsf{Empty}\mathrel{\sqcup}\mathsf{StdPos}\\ \mathsf{Empty}&=&\oplus\{\mathsf{eps}:\mathbf{1}\}\\ \mathsf{StdPos}&=&\oplus\{\mathsf{one}:\mathsf{Std},\mathsf{zero}:\mathsf{StdPos}\}\end{array}

\begin{array}[]{lcl}\mathsf{Std}&=&\mathsf{Empty}\mathrel{\sqcup}\mathsf{StdPos}\\ \mathsf{Empty}&=&\oplus\{\mathsf{eps}:\mathbf{1}\}\\ \mathsf{StdPos}&=&\oplus\{\mathsf{one}:\mathsf{Std},\mathsf{zero}:\mathsf{StdPos}\}\end{array}

\begin{array}[]{l}\mathsf{inc}:\mathsf{Std}\multimap\mathsf{Std}\mathrel{\sqcap}\mathsf{StdPos}\multimap\mathsf{StdPos}\mathrel{\sqcap}\mathsf{Empty}\multimap\mathsf{StdPos}\\[4.30554pt] c\leftarrow\mathsf{inc}\;d=\\ \quad\mbox{\bf case}\;d\;\mbox{\bf of}\\ \qquad\mathsf{eps}\rightarrow\mbox{\bf wait}\;d\mathrel{;}c.\mathsf{one}\mathrel{;}c.\mathsf{eps}\mathrel{;}\mbox{\bf close}\;c\\ \qquad\mathsf{zero}\rightarrow c.\mathsf{one}\mathrel{;}c\leftarrow d\\ \qquad\mathsf{one}\rightarrow c.\mathsf{zero}\mathrel{;}\mathsf{inc}\;d\end{array}

\begin{array}[]{l}\mathsf{inc}:\mathsf{Std}\multimap\mathsf{Std}\mathrel{\sqcap}\mathsf{StdPos}\multimap\mathsf{StdPos}\mathrel{\sqcap}\mathsf{Empty}\multimap\mathsf{StdPos}\\[4.30554pt] c\leftarrow\mathsf{inc}\;d=\\ \quad\mbox{\bf case}\;d\;\mbox{\bf of}\\ \qquad\mathsf{eps}\rightarrow\mbox{\bf wait}\;d\mathrel{;}c.\mathsf{one}\mathrel{;}c.\mathsf{eps}\mathrel{;}\mbox{\bf close}\;c\\ \qquad\mathsf{zero}\rightarrow c.\mathsf{one}\mathrel{;}c\leftarrow d\\ \qquad\mathsf{one}\rightarrow c.\mathsf{zero}\mathrel{;}\mathsf{inc}\;d\end{array}

(A_{1} ⊔ B) ⊓ (A_{2} ⊔ B) \equiv (A_{1} ⊓ A_{2}) ⊔ B \penalty - 10000 pl u s 0.5 f i l min u s 5.0 pt (A_{1} ⊔ A_{2}) ⊓ B \equiv (A_{1} ⊓ B) ⊔ (A_{2} ⊓ B)

(A_{1} ⊔ B) ⊓ (A_{2} ⊔ B) \equiv (A_{1} ⊓ A_{2}) ⊔ B \penalty - 10000 pl u s 0.5 f i l min u s 5.0 pt (A_{1} ⊔ A_{2}) ⊓ B \equiv (A_{1} ⊓ B) ⊔ (A_{2} ⊓ B)

α \Rightarrow β, A_{1} ⊓ A_{2} α \Rightarrow β, A_{1} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α \Rightarrow β, A_{2} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, A_{1} ⊓ A_{2} \Rightarrow β α, A_{1}, A_{2} \Rightarrow β \penalty - 10000 pl u s 0.5 f i l min u s 5.0 pt α \Rightarrow β, A_{1} ⊔ A_{2} α \Rightarrow β, A_{1}, A_{2} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, A_{1} ⊔ A_{2} \Rightarrow β \lx@proof@logical@and α, A_{1} \Rightarrow β α, A_{2} \Rightarrow β \penalty - 10000 pl u s 0.5 f i l min u s 5.0 pt α, 1 \Rightarrow β, 1 \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, A \otimes B \Rightarrow β, A^{'} \otimes B^{'} \lx@proof@logical@and A \Rightarrow A^{'} B \Rightarrow B^{'} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, \oplus {l a b_{k} : A_{k}}_{k \in I} \Rightarrow β, \oplus {l a b_{k} : A^{'}_{k}}_{k \in J} \lx@proof@logical@and I \subseteq J A_{k} \Rightarrow A_{k}^{'} for k \in I \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, A ⊸ B \Rightarrow β, A^{'} ⊸ B^{'} \lx@proof@logical@and A^{'} \Rightarrow A B \Rightarrow B^{'} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, & {l a b_{k} : A_{k}}_{k \in I} \Rightarrow β, & {l a b_{k} : A^{'}_{k}}_{k \in J} \lx@proof@logical@and J \subseteq I A_{k} \Rightarrow A_{k}^{'} for k \in J \penalty - 10000 pl u s 0.5 f i l min u s 5.0 pt α \Rightarrow β, t \lx@proof@logical@and (t = A \in η) α \Rightarrow β, A \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, t \Rightarrow β \lx@proof@logical@and (t = A \in η) α, A \Rightarrow β

α \Rightarrow β, A_{1} ⊓ A_{2} α \Rightarrow β, A_{1} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α \Rightarrow β, A_{2} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, A_{1} ⊓ A_{2} \Rightarrow β α, A_{1}, A_{2} \Rightarrow β \penalty - 10000 pl u s 0.5 f i l min u s 5.0 pt α \Rightarrow β, A_{1} ⊔ A_{2} α \Rightarrow β, A_{1}, A_{2} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, A_{1} ⊔ A_{2} \Rightarrow β \lx@proof@logical@and α, A_{1} \Rightarrow β α, A_{2} \Rightarrow β \penalty - 10000 pl u s 0.5 f i l min u s 5.0 pt α, 1 \Rightarrow β, 1 \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, A \otimes B \Rightarrow β, A^{'} \otimes B^{'} \lx@proof@logical@and A \Rightarrow A^{'} B \Rightarrow B^{'} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, \oplus {l a b_{k} : A_{k}}_{k \in I} \Rightarrow β, \oplus {l a b_{k} : A^{'}_{k}}_{k \in J} \lx@proof@logical@and I \subseteq J A_{k} \Rightarrow A_{k}^{'} for k \in I \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, A ⊸ B \Rightarrow β, A^{'} ⊸ B^{'} \lx@proof@logical@and A^{'} \Rightarrow A B \Rightarrow B^{'} \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, & {l a b_{k} : A_{k}}_{k \in I} \Rightarrow β, & {l a b_{k} : A^{'}_{k}}_{k \in J} \lx@proof@logical@and J \subseteq I A_{k} \Rightarrow A_{k}^{'} for k \in J \penalty - 10000 pl u s 0.5 f i l min u s 5.0 pt α \Rightarrow β, t \lx@proof@logical@and (t = A \in η) α \Rightarrow β, A \penalty 50 pl u s 0.5 f i l min u s 5.0 pt α, t \Rightarrow β \lx@proof@logical@and (t = A \in η) α, A \Rightarrow β

& {l a b_{k} : A_{k}}_{k \in I} ≜ \bigsqcap_{k \in I} & {l a b_{k} : A_{k}} \penalty - 10000 pl u s 0.5 f i l min u s 5.0 pt \oplus {l a b_{k} : A_{k}}_{k \in I} ≜ k \in I ⨆ \oplus {l a b_{k} : A_{k}}

& {l a b_{k} : A_{k}}_{k \in I} ≜ \bigsqcap_{k \in I} & {l a b_{k} : A_{k}} \penalty - 10000 pl u s 0.5 f i l min u s 5.0 pt \oplus {l a b_{k} : A_{k}}_{k \in I} ≜ k \in I ⨆ \oplus {l a b_{k} : A_{k}}

Peer Reviews

No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.

Videos

No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.

Full text

Intersections and Unions of Session Types

Coşku Acay Carnegie Mellon University

Pennsylvania, USA [email protected] Carnegie Mellon University

Pennsylvania, USA

Frank Pfenning Carnegie Mellon University

Pennsylvania, USA [email protected]

Abstract

Prior work has extended the deep, logical connection between the linear sequent calculus and session-typed message-passing concurrent computation with equi-recursive types and a natural notion of subtyping. In this paper, we extend this further by intersection and union types in order to express multiple behavioral properties of processes in a single type. We prove session fidelity and absence of deadlock and illustrate the expressive power of our system with some simple examples. We observe that we can represent internal and external choice by intersection and union, respectively, which was previously suggested in [7, 19] for a different language of session types motivated by operational rather than logical concerns.

1 Introduction

Prior work has established a Curry-Howard correspondence between intuitionistic linear sequent calculus and session-typed message-passing concurrency [6, 20, 18]. In this formulation, linear propositions are interpreted as session types, proofs as processes, and cut reduction as communication. Session types are assigned to channels and prescribe the communication behavior along them. Each channel is offered by a unique process and used by exactly one, which is ensured by linearity. When the behavior along a channel $c$ satisfies the type $A$ and $P$ is the process that offers along $c$ , we say that $P$ provides a session of type $A$ along $c$ .

In the base system, each type directly corresponds to a process of a certain form. For example, a process providing the type $A\otimes B$ first sends out a channel satisfying $A$ , then acts as $B$ . Similarly, a process offering $\mathbf{1}$ sends the label end and terminates. We call these structural types since they correspond to processes of a certain structure. In this paper, we extend the base type system with intersections and unions. We call these property types since they do not correspond to specific forms of processes in that any process may be assigned such a type. In addition, if we interpret a type as specifying a property, then intersection corresponds to satisfying two properties simultaneously and union corresponds to satisfying one or the other.

Our goal is to show that the base system extended with intersection, unions, recursive types, and a natural notion of subtyping is type-safe. We do this by proving the usual type preservation and progress theorems, which correspond to session fidelity and deadlock freedom in the concurrent context. In the presence of a strong subtyping relation and transparent (i.e. non-generative) equi-recursive types, intersections and unions turn out to be powerful enough to specify many interesting communications behaviors, which we demonstrate with examples analogous to those in functional languages [13, 11].

Our contributions are summarized below:

•

We introduce intersection and union types to a session-typed concurrent calculus and prove session fidelity and deadlock freedom.

•

We give a simple and sound coinductive subtyping relation in the presence of equi-recursive types, intersections, and unions reminiscent of Gentzen’s multiple conclusion sequent calculus [15, 16].

•

We show how intersections and unions can be used as refinements of recursive types in a linear setting.

•

We show decidability of subtyping and present a system for algorithmic type checking.

•

We demonstrate how internal and external choice can be understood as singletons interacting with intersection and union.

An extended version of this paper can be found at [2].

2 From Linear Logic to Session Types

We give only a brief review of linear logic and its connection to session types here. Interested readers are referred to [6, 20, 18]. The key idea of linear logic is to treat logical propositions as resources: each must be used exactly once in a proof. According to the Curry-Howard isomorphism for intuitionistic linear logic, propositions are interpreted as session types, proofs as concurrent processes, and cut-elimination steps as communication. For this correspondence, hypotheses are labelled with channels (rather than with variables). We also assign a channel name to the conclusion so that a process providing a session can refer to the same channel name as process using it. This replaces the usual notion of duality in classical session-typed calculi [18] and gives us the following form for typing judgments:

[TABLE]

which should be interpreted as “ $P$ provides along the channel $c$ the session $A$ using channels $c_{1},\ldots,c_{n}$ (linearly) with their corresponding types”. We assume $c_{1},\ldots,c_{n}$ and $c$ are all distinct so that when a channel $c$ occurs in $P$ , its reference is unambiguous. We abbreviate hypotheses using $\Psi$ , $\Psi^{\prime}$ , etc.

Two key rules explaining this judgment are cut and identity. Logically, cut means that if we can prove $A$ , then we can use it as a resource in the proof of some other proposition $C$ . Operationally, it corresponds to parallel composition with a private shared variable for communication.

[TABLE]

We write $c\leftarrow P_{c}\,;\,Q_{c}$ instead of the customary $(\nu c)(P_{c}\mid Q_{c})$ because it is more readable in actual programs. The subscript here indicates that $c$ is a bound variable and occurs in both $P_{c}$ and $Q_{c}$ .

Logically, the identity states the fundamental principle that the resource $A$ can be used to prove the conclusion $A$ . Operationally, it corresponds to forwarding: we provide a session along channel $c$ by forwarding to $d$ . Note that forwarding does not have a direct correspondence in the $\pi$ -calculus but can be implemented in terms of other primitives (for example, $!(c(d).\overline{c}\langle d\rangle+d(c).\overline{d}\langle c\rangle)$ ).

[TABLE]

Forwarding is employed in session-typed programming with surprising frequency as will be evident from the examples we provide.

Cut and identity are general constructs, independent of any particular proposition. The isomorphism takes shape once we work out the interpretations of all of the connectives of linear logic as session types. We foreshadow the operational interpretation from the perspective of the provider of a session:

[TABLE]

In this paper, we do not need ${!}A$ . Instead of replication, we use recursive types to describe recurring behavior. We also generalize the binary $A\oplus B$ to $\oplus\{lab_{k}:{A}_{k}\}_{k\in I}$ and $A\&B$ to $\&\{lab_{k}:{A}_{k}\}_{k\in I}$ , which is in the tradition of much prior work on session types and makes programs more readable. Here, $I$ is a finite non-empty set of distinct labels whose order does not matter. We call $\oplus\{lab_{k}:{A}_{k}\}_{k\in I}$ an internal choice since the provider selects which branch to take (i.e. the provider sends the label), and $\&\{lab_{k}:{A}_{k}\}_{k\in I}$ an external choice since the client makes the decision.

2.1 Process Expressions

The processes (or proof terms) corresponding to these types are given below with the sending construct followed by the receiving construct. The notation $P_{x}$ emphasizes the scope of a bound variable $x$ in the cut, send, and receive constructs. As a shorthand for substitution, we write $P_{a}$ for $[{a}/{x}]{P}$ , the capture-avoiding substitution of $a$ for $x$ in $P$ .

[TABLE]

Because a process $P$ always provides a session along a unique channel, we sometimes identify a process with the channel along which it provides. Keeping this in mind, the intuitive readings of process expressions are as follows. $x\leftarrow P_{x}\,;\,Q_{x}$ creates a fresh channel $c$ , spawns a new process $P_{c}$ providing along the channel $c$ , and $Q_{c}$ uses this new channel. The forwarding process $c\leftarrow d$ terminates by globally identifying channels $c$ and $d$ . Further communication along $c$ will instead take place along $d$ . A possible implementation of a forwarding process might tell the two end-points to communicate with each other and itself terminate, effectively, tying the two ends together and stepping out of the way. Process $\mathrm{close}\;c$ sends the token end and terminates, whereas the matching $\mathrm{wait}\;c\,;\,P$ waits for end along $c$ and continues as $P$ . Processes $\mathrm{send}$ and $\mathrm{recv}$ are used for communicating channels along channels. In the case of $\mathrm{send}\;c\;(y\leftarrow P_{y})\,;\,Q$ , a new channel $d$ is created and a process $P_{d}$ is spawned, but unlike cut, the continuation ( $Q$ ) cannot refer to the new channel $d$ , since it is sent along $c$ to be used by a different process. Finally, ${c}.lab\,;\,{P}$ sends $lab$ along $c$ , and $\mathrm{case}\;c\;\mathrm{of}\;\{lab_{k}\rightarrow Q_{k}\}_{k\in I}$ receives a label along $c$ and branches on it. These are used to determine which branches to take in internal and external choices.

2.2 Recursively Defined Types and Processes

For practical programming, we of course need recursive types and recursively defined processes. Usually, this is incorporated into the type language in a local way by introducing a new construct $\mu{t}.{A_{t}}$ and identifying $\mu{t}.{A}$ with its unfolding $[{\mu{t}.{A}}/{t}]{A}$ in the style of Amadio and Cardelli [3]. This makes it harder to incorporate mutual recursion, however, requiring type level pairs [22] for a fully formal treatment. We therefore go with the much simpler approach of using a global signature $\eta$ of mutually recursive type definitions and process definitions. Type definitions are straightforward with the form $t=A$ . They add defined type names as a new alternative to possible types. The fact that type definitions are transparent, that is, the fact that they are identified with their definition (or unfolding) without process-level terms to witness the isomorphism, corresponds to an equi-recursive interpretation of types. Process definitions have the form $X::(c:A)=P_{c}$ where $P$ provides session $A$ along $c$ .

[TABLE]

Note that $c$ is a bound variable with scope $P$ . Formally, our judgments are now decorated with a fixed signature $\eta$ , but we might elide it since the signature usually does not change during a derivation.

The identification of defined type names and their unfoldings is normally formalized by defining a new type equivalence judgment and adding conversion rules to process typing. In our formalization, we will integrate this into the subtyping judgment, but we delay its discussion to section 2.4. For now, it suffices to think of type definitions as finite representations of possibly infinite trees. For example, the definition $t=t\otimes t$ stands for the tree $(\ldots\otimes\ldots)\otimes(\ldots\otimes\ldots)$ . However, for this to make sense, we need to slightly restrict valid type definitions to those that are contractive [22, 14]. In our setting, this means every type definition must have a structural type at the top. For example, the previous example of $t=t\otimes t$ is contractive since its top level construct is $\otimes$ whereas $t=t$ and $t=u$ are not.

As an example for signatures with recursion, consider processes producing a sequence of the label $\mathsf{succ}$ followed a single $\mathsf{zero}$ (i.e. Peano naturals).

[TABLE]

The $\mathsf{s}$ process here receives a channel $d$ representing a natural number, outputs one $\mathsf{succ}$ , and then behaves like $d$ . Effectively, this computes the successor. To double a natural number, we need a recursive process definition.

[TABLE]

The last line here implements the following sequence:

[TABLE]

This is a frequent pattern, so we make two small improvements in the surface syntax: (1) we parameterize process definitions with the channels that they provide and use, and (2) instead of creating a new process and then forwarding it, we directly implement the provider channel with a new call. Then the definition becomes the much more readable

[TABLE]

In an actual implementation, the new definition would be “desugared” to the previous one.

2.3 Type Assignment for Processes

The typing rules for processes are derived from linear logic by decorating derivations with proof terms. The rules are given in fig. 1. Note that in $\oplus\texttt{L}$ and $\&\texttt{R}$ , we allow unused branches in case expressions. This makes width subtyping easier, which is discussed in section 2.4. In addition, the $\mathsf{def}$ rule implicitly renames the channel name in the signature to the one expected by the judgment.

In our simple language, checking that a type is valid, $\vdash_{\eta}A:\mathsf{type}$ , just verifies that all type names in $A$ are defined in $\eta$ and that $A$ is contractive. A signature $\eta$ itself is checked with the rules below. Note that we allow mutual recursion in the definitions which is witnessed by the fact that the signature $\eta$ is propagated identically everywhere.

[TABLE]

2.4 Subtyping

Gay and Hole [14] add coinductive subtyping (denoted $A\leq B$ in this paper) to their system in order to admit width and depth subtyping for $n$ -ary choices, which are standard for record-like and variant-like structures. In our system, subtyping also doubles as a convenient way of identifying a recursive type and its unfolding using the following rules:

[TABLE]

Double lines here indicate that the rules should be interpreted coinductively as is common with theories using equi-recursive types. We will not go into the details of Gay and Hole’s system since we will switch to a different relation in the next section anyway. Either way, we relate subtyping to process typing with subsumption rules:

[TABLE]

2.5 Process Configurations

So far in the theory, we have only considered processes in isolation. In this section, we introduce process configurations in order to talk about the interactions between multiple processes. A process configuration, denoted by $\Omega$ , is simply a set of processes where each process is labelled with the channel along which it provides. We use the notation $\mathtt{proc}_{c}(P)$ for labelling the process $P$ , and require all labels in a configuration to be distinct.

With the above restriction, each process offers along a specific channel and each channel is offered by a unique process. Since channels are linear resources in our system, they must be used by exactly one process. In addition, we do not allow cyclic dependence, which imposes an implicit forest (set of trees) structure on a process configuration where each node has one outgoing edge and any number of incoming edges that correspond to channels the process uses. This observation suggests the typing rules below, which mimic the structure of a multi-way tree. Note that the definition is well founded since the size of the configuration gets strictly smaller.

[TABLE]

2.6 Operational Semantics

A process configuration evolves over time when a process takes a step, either by spawning a new process (cut), forwarding (id) or when two matching processes communicate. Our configurations are sets, so order is not significant when we match the left-hand sides against the configuration $\Omega$ . When we require a new name to be chosen, it must not already be offered by some process in the configuration. These rules are an example of a substructural operational semantics [21], presented in the form of a multiset rewriting system [8].

[TABLE]

This concludes the discussion of the base system. In the next section, we introduce intersections, unions, and a multiple-conclusion subtyping relation which constitute our main contributions.

3 Intersections and Unions

Recall our definition of process-level naturals ${\rm Nature}$ . One can imagine cases where we would like to know more about the exact nature of the natural. For example, if we are using a natural to track the size of a list, we might want to ensure it is non-zero. Sometimes, it might be relevant to track whether we have an even or an odd number. The system we have described so far turns out to be strong enough to describe all these refinements as illustrated below

[TABLE]

Recall also the definitions

[TABLE]

Intuitively, it is easy to see that Pos, Even, and Odd are all subtypes of ${\rm Nature}$ . We run into a problem when we try to implement the behavior described by these types, however. The $\mathsf{s}$ process, for example, satisfies many properties: ${\rm Nature}\multimap{\rm Nature}$ , ${{\text{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@frame\lst@@@set@numbers\lst@@@set@rulecolor{\@listingGroup{ltx_lst_identifier}{Pos}}}}}}\multimap\text{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@frame\lst@@@set@numbers\lst@@@set@rulecolor{\@listingGroup{ltx_lst_identifier}{Pos}}}}}}$ , ${{\text{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@frame\lst@@@set@numbers\lst@@@set@rulecolor{\@listingGroup{ltx_lst_identifier}{Even}}}}}}\multimap\text{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@frame\lst@@@set@numbers\lst@@@set@rulecolor{\@listingGroup{ltx_lst_identifier}{Odd}}}}}}$ , ${{\text{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@frame\lst@@@set@numbers\lst@@@set@rulecolor{\@listingGroup{ltx_lst_identifier}{Odd}}}}}}\multimap\text{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@frame\lst@@@set@numbers\lst@@@set@rulecolor{\@listingGroup{ltx_lst_identifier}{Even}}}}}}$ etc. Subtyping can be used to combine some of these (e.g. ${{\rm Nature}\multimap\text{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@frame\lst@@@set@numbers\lst@@@set@rulecolor{\@listingGroup{ltx_lst_identifier}{Pos}}}}}}$ for ${\rm Nature}\multimap{\rm Nature}$ and ${{\text{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@frame\lst@@@set@numbers\lst@@@set@rulecolor{\@listingGroup{ltx_lst_identifier}{Pos}}}}}}\multimap\text{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@frame\lst@@@set@numbers\lst@@@set@rulecolor{\@listingGroup{ltx_lst_identifier}{Pos}}}}}}$ ) but it is not expressive enough to combine all properties. An elegant solution is to add intersections to the type system.

3.1 Intersection Types

We denote the intersection of two types $A$ and $B$ as $A\mathrel{\sqcap}B$ . A process offers an intersection type if its behavior satisfies both types simultaneously. Using intersections, we can assign the programs introduced in section 2.1 types specifying all behavioral properties we care about:

[TABLE]

Note that as is usual with intersections, multiple types are assigned to the same process. Put differently, we cannot use two different processes or specify two different behaviors to satisfy the different branches of an intersection. This leads to the following typing rule:

[TABLE]

When we are using a channel on the left that offers an intersection of two types, we know it has to satisfy both properties so we get to pick the one we want:

[TABLE]

It may seem as if the two left typing rules for intersection are somehow unnecessary: because of linearity, only one of $A$ or $B$ can be selected in any given derivation. But process definitions are used arbitrarily often, essentially spawning a new process along a new linear channel at each use point, so we may need to select a different component of the type at each occurrence. For example:

[TABLE]

The standard subtyping rules are given below. It should be noted that the left typing rules above are derivable by an application of subsumption on the left using $\leq{\mathrel{\sqcap}\texttt{L}_{1}}$ and $\leq{\mathrel{\sqcap}\texttt{L}_{2}}$ , so we will not explicitly add these to the final system. Also, we will have to modify the subtyping relation later in this section, so these rules are only a first attempt.

[TABLE]

One final note about intersection types and recursion is that intersections are not considered structural types and thus do not contribute to contractiveness. That is, the type $t=t\mathrel{\sqcap}t$ is not contractive.

3.2 Union Types

Unions are the dual of intersections and correspond to processes that satisfy one or the other property, and are written $A\mathrel{\sqcup}B$ . We add unions because they are a natural extension to a type system with intersections. We will also see how $n$ -ary internal choice can be interpreted as the union of singleton choices. Without them, our interpretation would only be half-complete since we could interpret external choice (with intersections) but not internal choice.

Being dual to intersections, the typing rules for unions mirror the typing rules for intersections: we have two right rules and one left rule, and this time the right rules are derivable from subtyping. The rules are given below:

[TABLE]

The right rules state the process has to offer either the left type or the right type respectively. The left rule says we need to be prepared to handle either type. It is interesting to observe that the usual problems with unions in functional languages do not arise in our setting. The natural left rule we give here (natural since it is dual to the right rule for intersection) has been shown to be unsound in functional languages [4]. One somewhat heavy solution limits the left rule to expressions in evaluation position [12]. The straightforward left rule turns out to be already sound here, essentially due to linearity and the use of the sequent calculus.

The usual subtyping rules are given below. The $\mathrel{\sqcup}\texttt{R}$ rules are derivable by general subtyping, so they don’t need to be explicitly added to the system.

[TABLE]

For an example where unions are the most natural way to express a property, consider moving to a binary representation of natural numbers. We define the type of binary string where the least significant bit is sent first and the string of bits is terminated with $\mathsf{eps}$ :

[TABLE]

We can define bit strings in standard form (no leading zeros) as follows:

[TABLE]

We are able to naturally express standard bit strings as either an empty bit string or a positive one; expressing such types without unions would be cumbersome at the very least.111The acute reader might notice that $\mathsf{Std}$ actually fails our simple contractiveness criteria. This does not lead to unsoundness, however, since its one level unfolding is contractive (i.e. inlining $\mathsf{Empty}$ and $\mathsf{StdPos}$ makes it contractive). We write it in closed form here for better readability, but one can consider this simple syntactic sugar. It is not too hard to formulate a sound contractiveness condition that allows such definitions, but we decided to err on the side of simplicity for this paper. Now we can write an increment function that preserves bit strings in standard form:

[TABLE]

This example also demonstrates that for a recursively defined type we may need to specify more information than we ultimately care about, since checking this definition just against the type $\mathsf{Std}\multimap\mathsf{Std}$ will fail, and we need to assign the more specific type for the type checking to go through. This is because of the nature of our system which essentially requires the type checker to verify a fixed point rather than infer the least one. This has proven highly beneficial for providing good error messages even in the simpler case of pure subtyping, without intersections and unions [17].

3.3 Subtyping Revisited

In line with our propositional interpretation of intersections and unions, one would naturally expect the usual properties of these to hold in our system. For example, unions should distribute over intersections and vice versa, that is, the following equalities should be admissible:

[TABLE]

Going from right to left turns out to be easy, but we quickly run into a problem if we try to do the other direction: whether we break down the union on the right or the intersection on the left, we always lose half the information we need to carry out the rest of the proof.222This issue does not come up in the other direction since intersection right and union left rules are invertible, that is, they preserve all information.

Our solution is doing the obvious: if the problem is losing half the information, well, we should just keep it around. This suggests a system where the single type on the left and the type on the right are replaced with (multi)sets of types. That is, instead of the judgment $A\leq B$ , we use a judgment of the form $A_{1},\ldots,A_{n}\Rightarrow B_{1},\ldots,B_{n}$ , where the left of $\Rightarrow$ is interpreted as a conjunction (intersection) and the right is interpreted as a disjunction (union).333We use multisets rather than sets since types have nontrivial equality, so it is not obvious when we should combine them into one.

This results in a system reminiscent of [15, 16]. However, we take a slightly different approach since we are working with coinductive rules.

The rules are given in fig. 2. We use $\alpha$ and $\beta$ to denote multisets of types. The intersection left rules are combined into one rule that keeps both branches around. The same is done with union right rules. Intersection right and union left rules split into two derivations, one for each branch, but keep the rest of the types unchanged. We can unfold a recursive type on the left or on the right. When we choose to apply a structural rule, we have to pick exactly one type on the left and one on the right with the same structure. We conjecture that matching multiple types might give us distributivity of intersection and union over structural types, although a naive extension along these lines fails to satisfy type safety.

3.4 Reinterpreting Choice

In this section, we show that that intersections and unions are useful beyond their refinement interpretation, and help us understand external and internal choices better. Take external choice, for instance. A comparison between the typing rules for intersections and external choice reveal striking similarities. The only difference, in fact, is that internal choice has process-level constructs whereas intersections are implicit.

Consider the special case of binary external choice: $\&\{\mathsf{inl}:A,\mathsf{inr}:B\}$ . This type says: I will act as $A$ if you send me $\mathsf{inl}$ and I will act as $B$ if you send me $\mathsf{inr}$ . We know the and can be interpreted as an intersection, and either side can be thought of as a singleton internal choice. A similar argument can be given for internal choice and unions. This gives us the following redefinitions of $n$ -ary external and internal choices:

[TABLE]

It is a straightforward calculation that these definitions satisfy the typing and subtyping rules for external and internal choices.

4 Algorithmic System

In this section, we show that subtyping and type-checking are decidable by designing an algorithm that takes in a (sub)typing judgment and produces true if and only if there is a derivation. Note that everything in the judgment is considered an input.

4.1 Algorithmic Subtyping

The subtyping judgment we gave is already mostly algorithmic (a necessity of working with coinductive rules), so we only have to tie up a few loose ends. The first is deciding which rule to pick when multiple are applicable. We apply $\Rightarrow{\mathrel{\sqcap}\texttt{R}}$ , $\Rightarrow{\mathrel{\sqcap}\texttt{L}}$ , $\Rightarrow{\mathrel{\sqcup}\texttt{R}}$ , $\Rightarrow{\mathrel{\sqcup}\texttt{L}}$ , $\Rightarrow{\mathsf{Def}\texttt{R}}$ , $\Rightarrow{\mathsf{Def}\texttt{L}}$ eagerly since these are invertible. At some point, all types must be structural (since definitions are restricted to be contractive), at which point we non-deterministically pick a structural rule and continue. In the implementation, we backtrack over these choices.

Second, the coinductive nature of subtyping means we can (and often will) have infinite derivations. We combat this by using a cyclicity check (similar to the one in [14]): we maintain a context of previously seen subtyping comparisons and immediately terminate with success if we ever compare the same pair of sets of types again. Every recursive step corresponds to a rule, which ensures a productive derivation. We know there cannot be an infinite chain of new types due to the contractiveness restriction which implies an upper-bound on the size of the previously-seen set. A more formal treatment can be found in [22].

4.2 Algorithmic Type-checking

Designing a type checking algorithm is quite simple for the base system where we only have structural types (no recursive types or subtyping), since the form of the process determines a unique applicable typing rule. The cut rule causes a small problem since we do not have a type for the new channel. This is solved by requiring a type annotation when necessary such that the new term becomes ${c}:{A}\leftarrow{P_{c}}\,;\,{Q_{c}}$ . The overwhelmingly common case where it is not necessary is when $P_{c}$ is a defined process name $X$ because we simply fall back on its given type.

In the extended system with subtyping and property types, type-checking is trickier for two reasons: (1) subsumption can be applied anytime where one of the types in $A\leq B$ can be anything (the other will be fixed due to typing rules, but one causes enough damage), and (2) intersection left and union right rules lose information which means they have to be applied non-deterministically. The latter issue is resolved by switching to a judgment where each channel (whether on the left or the right) is assigned a multiset of types. These multisets are interpreted conjunctively for channels used (on the left) and disjunctively for the channel provided (on the right). This makes intersection left and union right rules invertible, so they can be applied eagerly.

The former problem is solved by checking subtyping only at the identity rule (forwarding). This relies on the subformula property for the sequent calculus, excepting only the cut rule which is annotated. The new judgment is written ${\Psi}\Vdash_{\eta}P::(c:\alpha)$ , where $\Psi$ and $\alpha$ are multisets. Typing rules are given in fig. 3. Note the explicit $\mathrel{\sqcap}\texttt{L}$ , $\mathrel{\sqcup}\texttt{R}$ , $\mathsf{Def}\texttt{L}$ , and $\mathsf{Def}\texttt{R}$ . These rules were derivable in the declarative system using subsumption, which is no longer possible since application of subsumption is restricted to forwarding processes.

4.3 Equivalence to the Declarative System

Next, we show that the algorithmic system is sound and complete with respect to the declarative system (modulo erasure of type annotations, which we denote by $\left\llbracket{P}\right\rrbracket$ ). Due to space limitations, we can only give very brief proof sketches here. Interested readers are referred to the first author’s thesis [2]. We define $\operatorname{\bigsqcup}\alpha$ as the union of all the types in $\alpha$ , and similarly for $\operatorname{\bigsqcap}\alpha$ . For contexts we define $\operatorname{\bigsqcap}(c_{1}{:}\alpha_{1},\ldots,c_{n}{:}\alpha_{n})=c_{1}{:}\operatorname{\bigsqcap}\alpha_{1},\ldots,c_{n}{:}\operatorname{\bigsqcap}\alpha_{n}$ .

Theorem 4.1 (Soundness of Algorithmic Typing).

If ${\Psi}\Vdash_{\eta}P::(c:\alpha)$ , then ${\operatorname{\bigsqcap}\Psi}\vdash_{\eta}\left\llbracket{P}\right\rrbracket::(c:\operatorname{\bigsqcup}\alpha)$ .

Proof.

By induction on the typing derivation. The only non-straightforward cases are $\mathrel{\sqcap}\texttt{R}$ and $\mathrel{\sqcup}\texttt{L}$ , which depend on the distributivity of intersection and union over each other (which is one of the reasons why we insisted such be the case while designing the subtyping relation). ∎

Lemma 4.2 (Completeness of Delayed Subtyping).

The following are admissible:

•

If ${\Psi}\Vdash_{\eta}P::(c:\alpha)$ and $\operatorname{\bigsqcup}\alpha\Rightarrow\beta$ then ${\Psi}\Vdash_{\eta}P::(c:\beta)$ .

•

If ${\Psi,d:\alpha}\Vdash_{\eta}P::(c:\beta)$ and $\alpha^{\prime}\Rightarrow\operatorname{\bigsqcap}\alpha$ then ${\Psi,d:\alpha^{\prime}}\Vdash_{\eta}P::(c:\beta)$ .

Note that the type annotations in $P$ stay the same.

Proof.

By lexicographic induction, first on the structure of $P$ , then on the combined sizes of involved types. ∎

Theorem 4.3 (Completeness of Algorithmic Typing).

If ${\Psi}\vdash_{\eta}P::(c:A)$ , then there exists $P^{\prime}$ such that $\left\llbracket{P^{\prime}}\right\rrbracket=P$ and ${\Psi}\Vdash_{\eta}P^{\prime}::(c:A)$ .

Proof.

By induction on the typing derivation, using lemma 4.2 for SubR and SubL. ∎

5 Metatheory

Our main contribution is proving type safety for the system with intersections and unions, which we do so by showing the standard progress and preservation theorems, renamed to deadlock freedom and session fidelity, respectively, within this context. Since the algorithmic system is more well behaved (no subsumption), we use the algorithmic judgment in the statements and proofs of these results. Type safety for the declarative system follows from its equivalence to the algorithmic system. We only state the theorems here. Full proofs can be found in [2].

In a functional setting, progress states a well-typed expression either takes a step or is a value. The corresponding notion of a value is a poised configuration. A configuration is poised if every process in it is, and a process is poised if it is waiting to communicate with its client. With this definition, we can state the progress theorem:

Theorem 5.1 (Progress).

If $\models{\Omega}::{\Psi}$ then either

$\Omega\longrightarrow\Omega^{\prime}$ * for some $\Omega^{\prime}$ , or* 2. 2.

$\Omega$ * is poised.*

Proof.

By induction on $\models{\Omega}::{\Psi}$ followed by a nested induction on the typing of the root process for the $\texttt{config}_{1}$ case. When two processes are involved, we also need inversion on client’s typing. ∎

Theorem 5.2 (Preservation).

If $\models{\Omega}::{\Psi}$ and $\Omega\longrightarrow\Omega^{\prime}$ then $\models{\Omega^{\prime}}::{\Psi}$ .

Proof.

By inversion on $\Omega\longrightarrow\Omega^{\prime}$ , followed by induction on the typing judgments of the involved processes. ∎

6 Related Work and Conclusion

Padovani describes a calculus similar to ours [19] where he interprets internal and external choices as union and intersection, respectively. This resembles what we did in section 3.4 except we keep singleton choices at the type and term levels to maintain the connection to linear logic, whereas Padovani is able to remove them completely since his calculus is based on CSS [9]. While we give axiomatic rules for (sub)typing, he takes a semantic approach, which we believe is complementary to our work. However, semantic definitions make deriving algorithmic rules harder and he leaves this as future work. More significantly, Padovani does not consider higher-order types and processes, which means it is not possible to communicate channels along channels. Moreover, his calculus only deals with the interaction between two processes that are required to have matching (or dual) types and behaviors (for example, if one sends, the other must receive etc.). We consider a tree of processes where each process can use many providers (as long as it respect the behavior along their channels) and even spawn new ones. For example, a client using two providers could communicate with one of them while the other is idle, or ignore both altogether and only communicate with its client.

Castagna et al. describe a generic framework [7] that make use of set operations (intersection, union, and negation) for sessions and take a semantic approach as well. Their framework has the advantage that it is agnostic to the underlying functional language. There are descriptions of our base calculus that take a similar approach [23] and it should not be too hard to extend them to cover our contributions. Contrary to Padovani, Castagna et al. have higher order sessions and give algorithms to decide all semantic relations they describe. However, their system and presentation are significantly different from ours because of their semantic emphasis, inclusion of negation (which makes their session language Boolean), and treatment of process composition (which is closer to Padovani’s). In particular, they do not have a general primitive for spawning new processes or forwarding.

We introduced intersections and unions to a simple system of session types, and demonstrated how they can be used to refine behavioral specifications of processes. Some aspects that would be important in a full accounting of the system are omitted for the sake of brevity or are left as future work. For example, integrating an underlying functional language [23], adding shared channels [6, 20], or considering asynchronous communication [10, 20, 17] are straightforward extensions based on prior work. In addition, it would be very useful to have behavioral polymorphism [5] and abstract types. Their interaction with subtyping, intersections, and unions is an interesting avenue for future work.

Acknowledgments.

This work was funded in part by NSF grant CNS1423168 and by the FCT (Portuguese Foundation for Science and Technology) through the Carnegie Mellon Portugal Program. We would like to thank the anonymous referees for their many helpful suggestions.

Bibliography23

The reference list from the paper itself. Each links out to its DOI / PubMed record.

1[1]
2[2] Coşku Acay (2016): Refinements for Session Typed Concurrency . Undergraduate honors thesis, Carnegie Mellon University. Available at http://www.coskuacay.com/papers/senior-thesis.pdf .
3[3] Roberto M. Amadio & Luca Cardelli (1991): Subtyping Recursive Types . In: POPL , ACM Press, pp. 104–118, 10.1145/99583.99600 . · doi ↗
4[4] Franco Barbanera, Mariangiola Dezani-Ciancaglini & Ugo de’Liguoro (1995): Intersection and Union Types: Syntax and Semantics . Inf. Comput. 119(2), pp. 202–230, 10.1006/inco.1995.1086 . · doi ↗
5[5] Luís Caires, Jorge A. Pérez, Frank Pfenning & Bernardo Toninho (2013): Behavioral Polymorphism and Parametricity in Session-Based Communication . In: ESOP , Lecture Notes in Computer Science 7792, Springer, pp. 330–349, 10.1007/978-3-642-37036-6_19 . · doi ↗
6[6] Luís Caires & Frank Pfenning (2010): Session Types as Intuitionistic Linear Propositions . In: CONCUR , Lecture Notes in Computer Science 6269, Springer, pp. 222–236, 10.1007/978-3-642-15375-4_16 . · doi ↗
7[7] Giuseppe Castagna, Mariangiola Dezani-Ciancaglini, Elena Giachino & Luca Padovani (2009): Foundations of session types . In: PPDP , ACM, pp. 219–230, 10.1145/1599410.1599437 . · doi ↗
8[8] Iliano Cervesato & Andre Scedrov (2009): Relating state-based and process-based concurrency through linear logic (full-version) . Inf. Comput. 207(10), pp. 1044–1077, 10.1016/j.ic.2008.11.006 . · doi ↗

TL;DR

Contribution

Findings

Abstract

Peer Reviews

Videos

Intersections and Unions of Session Types

Abstract

1 Introduction

2 From Linear Logic to Session Types

2.1 Process Expressions

2.2 Recursively Defined Types and Processes

2.3 Type Assignment for Processes

2.4 Subtyping

2.5 Process Configurations

2.6 Operational Semantics

3 Intersections and Unions

3.1 Intersection Types

3.2 Union Types

3.3 Subtyping Revisited

3.4 Reinterpreting Choice

4 Algorithmic System

4.1 Algorithmic Subtyping

4.2 Algorithmic Type-checking

4.3 Equivalence to the Declarative System

Theorem 4.1** (Soundness of Algorithmic Typing).**

Proof.

Lemma 4.2** (Completeness of Delayed Subtyping).**

Proof.

Theorem 4.3** (Completeness of Algorithmic Typing).**

Proof.

5 Metatheory

Theorem 5.1** (Progress).**

Proof.

Theorem 5.2** (Preservation).**

Proof.

6 Related Work and Conclusion

Acknowledgments.

Theorem 4.1 (Soundness of Algorithmic Typing).

Lemma 4.2 (Completeness of Delayed Subtyping).

Theorem 4.3 (Completeness of Algorithmic Typing).

Theorem 5.1 (Progress).

Theorem 5.2 (Preservation).