Kind Inference for the FreeST Programming Language

We present a kind inference algorithm for the FREEST programming language. The input to the algorithm is FREEST source code with (possibly part of) kind annotations replaced by kind variables. The algorithm infers concrete kinds for all kind variables. We ran the algorithm on the FREEST test suite by first replacing kind annotation on all type variables by fresh kind variables, and concluded that the algorithm correctly infers all kinds. Non surprisingly, we found out that programmers do not choose the most general kind in 20% of the cases.Comment: In Proceedings PLACES 2023, arXiv:2304.0543

Subtyping Context-Free Session Types

Context-free session types describe structured patterns of communication on heterogeneously-typed channels, allowing the specification of protocols unconstrained by tail recursion. The enhanced expressive power provided by non-regular recursion comes, however, at the cost of the decidability of subtyping, even if equivalence is still decidable. We present an approach to subtyping context-free session types based on a novel kind of observational preorder we call $\mathcal{XYZW}$-simulation, which generalizes $\mathcal{XY}$-simulation (also known as covariant-contravariant simulation) and therefore also bisimulation and plain simulation. We further propose a subtyping algorithm that we prove to be sound, and present an empirical evaluation in the context of a compiler for a programming language. Due to the general nature of the simulation relation upon which it is built, this algorithm may also find applications in other domains.Comment: 34 pages, 6 figures, technical report of a paper published in the conference proceedings of CONCUR 202

System FωμF^\mu_\omega with Context-free Session Types

We study increasingly expressive type systems, from $F^\mu$ -- an extension of the polymorphic lambda calculus with equirecursive types -- to $F^{\mu;}_\omega$ -- the higher-order polymorphic lambda calculus with equirecursive types and context-free session types. Type equivalence is given by a standard bisimulation defined over a novel labelled transition system for types. Our system subsumes the contractive fragment of $F^\mu_\omega$ as studied in the literature. Decidability results for type equivalence of the various type languages are obtained from the translation of types into objects of an appropriate computational model: finite-state automata, simple grammars and deterministic pushdown automata. We show that type equivalence is decidable for a significant fragment of the type language. We further propose a message-passing, concurrent functional language equipped with the expressive type language and show that it enjoys preservation and absence of runtime errors for typable processes.Comment: 38 pages, 13 figure

Polymorphic Context-free Session Types

Context-free session types provide a typing discipline for recursive structured communication protocols on bidirectional channels. They overcome the restriction of regular session type systems to tail recursive protocols. This extension enables us to implement serialisation and deserialisation of tree structures in a fully type-safe manner. We present the theory underlying the language FreeST 2, which features context-free session types in an extension of System F with linear types and a kind system to distinguish message types and channel types. The system presents some metatheoretical challenges, which we address, contractivity in the presence of polymorphism, a non-trivial equational theory on types, and decidability of type equivalence. We also establish standard results on type preservation, progress, and a characterisation of erroneous processes

Parametric Subtyping for Structural Parametric Polymorphism (Artifact)

# POPL 2024 Artifact Evaluation ## Paper Abstract We study the interaction of structural subtyping with parametric polymorphism and recursively defined type constructors. Although structural subtyping is undecidable in this setting, we describe a notion of parametricity for type constructors and then exploit it to define parametric subtyping, a conceptually simple, decidable, and expressive fragment of structural subtyping that strictly generalizes nominal subtyping. We present and prove correct an effective saturation-based decision procedure for parametric subtyping, demonstrating its applicability using a variety of examples. An implementation of this decision procedure is available in the supplementary materials. # Artifact Evaluation We would like to thank the reviewers for reviewing the artifact for the POPL 2024 submission 714 titled "Parametric Subtyping for Structural Parametric Polymorphism". ## VM Link You can download the VM image from [here](https://zenodo.org/record/8417982/files/ubuntu-popl24-aec-submission-714.ova?download=1). ### VM Login VM Username: popl24-aec VM Password: submission-714 ## VM Instructions The VM contains an image of Ubuntu 22.04.1 LTS with the implementation and dependencies already downloaded, installed, and compiled. The implementation is called `polyte` and exists in the home directory of the VM. The standard way of using this image is by downloading and installing VirtualBox and loading this image in VirtualBox. Open a terminal and navigate to the `polyte` implementation and compile (if files have changed). ``` $cd polyte/src$ git pull $make all$ ./polyte-test ../*/*.poly (regression testing) $./polyte ../examples/paper.poly (viewing output)$ make install (copy to bin/) $make clean (remove binaries and possible .cm/ dir)$ make test (run polyte-test on tests/examples, returning exit code) ``

Parametric Subtyping for Structural Parametric Polymorphism (Artifact)

# POPL 2024 Artifact Evaluation ## Paper Abstract We study the interaction of structural subtyping with parametric polymorphism and recursively defined type constructors. Although structural subtyping is undecidable in this setting, we describe a notion of parametricity for type constructors and then exploit it to define parametric subtyping, a conceptually simple, decidable, and expressive fragment of structural subtyping that strictly generalizes nominal subtyping. We present and prove correct an effective saturation-based decision procedure for parametric subtyping, demonstrating its applicability using a variety of examples. An implementation of this decision procedure is available in the supplementary materials. # Artifact Evaluation We would like to thank the reviewers for reviewing the artifact for the POPL 2024 submission 714 titled "Parametric Subtyping for Structural Parametric Polymorphism". ## VM Link You can download the VM image from [here](https://zenodo.org/record/8417982/files/ubuntu-popl24-aec-submission-714.ova?download=1). ### VM Login VM Username: popl24-aec VM Password: submission-714 ## VM Instructions The VM contains an image of Ubuntu 22.04.1 LTS with the implementation and dependencies already downloaded, installed, and compiled. The implementation is called `polyte` and exists in the home directory of the VM. The standard way of using this image is by downloading and installing VirtualBox and loading this image in VirtualBox. Open a terminal and navigate to the `polyte` implementation. ``` $cd ~/polyte$ ./bin/polyte-test ./examples/*.poly (run polyte-test on tests/examples, returning exit code) $./bin/polyte ./examples/paper.poly (viewing output) ``` If you would like to build the binaries again: ```$ cd ~/polyte $make all$ make install $ make clean ``` At this point, you can return to the instructions before this to run regression testing or run `polyte` on individual files. The VM image also has emacs already installed with syntax highlighting enabled, therefore you can open `.poly` files using emacs to edit those files with the benefit of syntax highlighting. You can find more details in the [README file](https://bitbucket.org/structural-types/polyte/src/popl24-artifact/README.md) that also exists at ~/polyte/README.md of the VM image