I am a research associate in the Laboratory for Foundations of Computer Science, one institute of the School of Informatics at the University of Edinburgh. My research centers on type systems for functional programming languages; in particular:

- How type system features, like substructural and session types, strengthen type safety guarantees;
- How class system features, like instances chains and functional dependencies, provide more expressive abstractions; and,
- How overloading mechanisms contribute to writing simple, correct code.

I work with Phil Wadler and Sam Lindley on the ABCD project, which studies the role of session types in safe concurrent and distributed programming. I have contributed to the design and implementation of session types for the Links programming language. I received my Ph.D. from the computer science department at Portland State University, advised by Mark P. Jones. As part of the High Assurance Systems Programming project, I contributed to the design of the Habit programming language, particularly its class system, and to the development of the Habit compiler, particularly its typechecking and desugaring components.

*Instances Chains and Type Classes: A Relational Approach.*
[PDF]

▷
▽
J. Garrett Morris. "The Best of Both Worlds: Linear Functional Programming Without Compromise".
In *Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming
(ICFP 2016)*, Nara, Japan, 2016.

We present a linear functional calculus with both the safety guarantees expressible with linear types and the rich language of combinators and composition provided by functional programming. Unlike previous combinations of linear typing and functional programming, we compromise neither the linear side (for example, our linear values are first-class citizens of the language) nor the functional side (for example, we do not require duplicate definitions of compositions for linear and unrestricted functions). To do so, we must generalize abstraction and application to encompass both linear and unrestricted functions. We capture the typing of the generalized constructs with a novel use of qualified types. Our system maintains the metatheoretic properties of the theory of qualified types, including principal types and decidable type inference. Finally, we give a formal basis for our claims of expressiveness, by showing that evaluation respects linearity, and that our language is a conservative extension of existing functional calculi.

The extended edition is available in PDF. Note that this version fixes several inadvertent omissions and typographical errors, and so should be preferred to the conference version. The conference version is available from the ACM DL.

▷
▽
Sam Lindley and J. Garrett Morris. "Talking Bananas: Structural Recursion for Session Types".
In *Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming
(ICFP 2016)*, Nara, Japan, 2016.

Session types provide static guarantees that concurrent programs respect communication protocols. We give a novel account of recursive session types in the context of GV, a small concurrent extension of the linear λ-calculus. We extend GV with recursive types and catamorphisms, following the initial algebra semantics of recursion, and show that doing so naturally gives rise to recursive session types. We show that this principled approach to recursion resolves long-standing problems in the treatment of duality for recursive session types.

We characterize the expressiveness of GV concurrency by giving a CPS translation to (non-concurrent) λ-calculus and proving that reduction in GV is simulated by full reduction in λ-calculus. This shows that GV remains terminating in the presence of positive recursive types, and that such arguments extend to other extensions of GV, such as polymorphism or non-linear types, by appeal to normalization results for sequential λ-calculi. We also show that GV remains deadlock free and deterministic in the presence of recursive types.

Finally, we extend CP, a session-typed process calculus based on linear logic, with recursive types, and show that doing so preserves the connection between reduction in GV and cut elimination in CP.

▷
▽
Sam Lindley and J. Garrett Morris. "Embedding Session Types in Haskell". In *Proceedings of
the 9th International Symposium on Haskell (Haskell 2016)*, Nara, Japan, 2016.

We present a novel embedding of session-typed concurrency in Haskell. We extend an existing HOAS embedding of \llc with a set of core session-typed primitives, using indexed type families to express the constraints of the session typing discipline. We give two interpretations of our embedding, one in terms of GHC's built-in concurrency and another in terms of purely functional continuations. Our safety guarantees, including deadlock freedom, are assured statically and introduce no additional runtime overhead.

Paper available in PDF or from the ACM DL. See the source code on Github.

▷
▽
Robert Atkey, Sam Lindley, and J. Garrett Morris. "Conflation Confers Concurrency". In *A
List of Successes That Can Change the World: Essays Dedicated to Philip Wadler on the Occasion
of His 60th Birthday*. LNCS
9600.

Session types provide a static guarantee that concurrent programs respect communication protocols. Recent work has explored a correspondence between proof rules and cut reduction in linear logic and typing and evaluation of process calculi. This paper considers two approaches to extend logically-founded process calculi. First, we consider extensions of the process calculus to more closely resemble π-calculus. Second, inspired by denotational models of process calculi, we consider conflating dual types. Most interestingly, we observe that these approaches coincide: conflating the multiplicatives (⊗ and ⅋) allows processes to share multiple channels; conflating the additives (⊕ and &) provides nondeterminism; and conflating the exponentials (! and ?) yields access points, a rendezvous mechanism for initiating session typed communication. Access points are particularly expressive: for example, they are sufficient to encode concurrent state and general recursion.

▷
▽
J. Garrett Morris. "Variations on Variants". In *Proceedings of the 2015 ACM SIGPLAN
Symposium on Haskell*, Vancouver, BC.

Extensible variants improve the modularity and expressiveness of programming languages: they allow program functionality to be decomposed into independent blocks, and allow seamless extension of existing code with both new cases of existing data types and new operations over those data types.

This paper considers three approaches to providing extensible variants in Haskell. Row typing is a long understood mechanism for typing extensible records and variants, but its adoption would require extension of Haskell's core type system. Alternatively, we might hope to encode extensible variants in terms of existing mechanisms, such as type classes. We describe an encoding of extensible variants using instance chains, a proposed extension of the class system. Unlike many previous encodings of extensible variants, ours does not require the definition of a new type class for each function that consumes variants. Finally, we translate our encoding to use closed type families, an existing feature of GHC. Doing so demonstrates the interpretation of instances chains and functional dependencies in closed type families.

One concern with encodings like ours is how completely they match the encoded system. We compare the expressiveness of our encodings with each other and with systems based on row types. We find that, while equivalent terms are typable in each system, both encodings require explicit type annotations to resolve ambiguities in typing not present in row type systems, and the type family implementation retains more constraints in principal types than does the instance chain implementation. We propose a general mechanism to guide the instantiation of ambiguous type variables, show that it eliminates the need for type annotations in our encodings, and discuss conditions under which it preserves coherence.

Paper available from the ACM DL or in PDF. Sample code available here.

▷ ▽ Sam Lindley and J. Garrett Morris. "A Semantics for Propositions as Sessions". ESOP 2015.

Session types provide a static guarantee that concurrent programs respect communication protocols. Recently, Caires, Pfenning, and Toninho, and Wadler, have developed a correspondence between propositions of linear logic and session typed π-calculus processes. We relate the cut-elimination semantics of this approach to an operational semantics for session-typed concurrency in a functional language. We begin by presenting a variant of Wadler's session-typed core functional language, GV. We give a small-step operational semantics for GV. We develop a suitable notion of deadlock, based on existing approaches for capturing deadlock in π-calculus, and show that all well-typed GV programs are deadlock-free, deterministic, and terminating. We relate GV to linear logic by giving translations between GV and CP, a process calculus with a type system and semantics based on classical linear logic. We prove that both directions of our translation preserve reduction; previous translations from GV to CP, in contrast, failed to preserve β-reduction. Furthermore, to demonstrate the modularity of our approach, we define two extensions of GV which preserve deadlock-freedom, determinism, and termination.

▷
▽
J. Garrett Morris. "A Simple Semantics of Haskell Overloading". In *Proceedings of the 2014
ACM SIGPLAN Symposium on Haskell*, Gothenburg, Sweden.

As originally proposed, type classes provide overloading and ad-hoc definition, but can still be understood (and implemented) in terms of strictly parametric calculi. This is not true of subsequent extensions of type classes. Functional dependencies and equality constraints allow the satisfiability of predicates to refine typing; this means that the interpretations of equivalent qualified types may not be interconvertible. Overlapping instances and instance chains allow predicates to be satisfied without determining the implementations of their associated class methods, introducing truly non-parametric behavior. We propose a new approach to the semantics of type classes, interpreting polymorphic expressions by the behavior of each of their ground instances, but without requiring that those behaviors be parametrically determined. We argue that this approach both matches the intuitive meanings of qualified types and accurately models the behavior of programs.

▷ ▽ Sam Lindley and J. Garrett Morris. "Sessions as Propositions". In PLACES 2014.

Recently, Wadler presented a continuation-passing translation from a session-typed functional language, GV, to a process calculus based on classical linear logic, CP. However, this translation is one-way: CP is more expressive than GV. We propose an extension of GV, called HGV, and give translations showing that it is as expressive as CP. The new translations shed light both on the original translation from GV to CP, and on the limitations in expressiveness of GV.

▷
▽
J. Garrett Morris and Mark P. Jones. "Instance Chains: Type Class Programming Without Overlapping Instances."
In *Proceedings of the 15th ACM SIGPLAN International Conference on Functional
Programming (ICFP '10)*, Baltimore, Maryland.
2010.

Type classes have found a wide variety of uses in Haskell programs, from simple overloading of operators (such as equality or ordering) to complex invariants used to implement type-safe heterogeneous lists or limited subtyping. Unfortunately, many of the richer uses of type classes require extensions to the class system that have been incompletely described in the research literature and are not universally accepted within the Haskell community.

This paper describes a new type class system, implemented in a prototype tool
called `ilab`, that simplifies and enhances Haskell-style type-class programming.
In `ilab`, we replace overlapping instances with a new feature, *instance chains*,
allowing explicit alternation and failure in instance declarations. We describe a technique
for ascribing semantics to type class systems, relating classes, instances, and class
constraints (such as kind signatures or functional dependencies) directly to a set-theoretic
model of relations on types. Finally, we give a semantics for `ilab` and describe its
implementation.

▷
▽
J. Garrett Morris. "Experience Report: Using Hackage to Inform Language Design."
In *Proceedings of the 3rd ACM Symposium on Haskell (Haskell '10)*,
Baltimore, Maryland.

Hackage, an online repository of Haskell applications and libraries, provides a hub for programmers to both release code to and use code from the larger Haskell community. We suggest that Hackage can also serve as a valuable resource for language designers: by providing a large collection of code written by different programmers and in different styles, it allows language designers to see not just how features could be used theoretically, but how they are (and are not) used in practice.

We were able to make such a use of Hackage during the design of the class system for a new Haskell-like programming language. In this paper, we sketch our language design problem, and how we used Hackage to help answer it. We describe our methodology in some detail, including both ways that it was and was not effective, and summarize our results.

Some of these papers are copyright ACM. These are the author's versions of the work. They are posted here by permission of ACM for your personal use. Not for redistribution. Please see each paper for the location of the definitive version.