Brent A. Yorgey

Giving Haskell a promotion

Static type systems strive to be richly expressive while still being simple enough for programmers to use. We describe an experiment that enriches Haskells kind system with two features promoted from its type system: data types and polymorphism. The new system has a very good power-to-weight ratio: it offers a significant improvement in expressiveness, but, by re-using concepts that programmers are already familiar with, the system is easy to understand and implement.

Monoids: theme and variations (functional pearl)

The monoid is a humble algebraic structure, at first glance even downright boring. However, theres much more to monoids than meets the eye. Using examples taken from the diagrams vector graphics framework as a case study, I demonstrate the power and beauty of monoids for library design. The paper begins with an extremely simple model of diagrams and proceeds through a series of incremental variations, all related somehow to the central theme of monoids. Along the way, I illustrate the power of compositional semantics; why you should also pay attention to the monoids even humbler cousin, the semigroup; monoid homomorphisms; and monoid actions.

Species and functors and types, oh my!

The theory of combinatorial species, although invented as a purely mathematical formalism to unify much of combinatorics, can also serve as a powerful and expressive language for talking about data types. With potential applications to automatic test generation, generic programming, and language design, the theory deserves to be much better known in the functional programming community. This paper aims to teach the basic theory of combinatorial species using motivation and examples from the world of functional programming. It also introduces the species library, available on Hackage, which is used to illustrate the concepts introduced and can serve as a platform for continued study and research.

How to twist pointers without breaking them

Using the theory of monoids and monoid actions, we give a unified framework that handles three common pointer manipulation tasks, namely, data serialisation, deserialisation, and memory allocation. Our main theoretical contribution is the formulation of the notion of a twisted functor, a generalisation of the semi-direct product construction for monoids. We show that semi-direct products and twisted functors are particularly well suited as an abstraction for many pointer manipulation tasks. We describe the implementation of these abstractions in the context of a cryptographic library for Haskell. Twisted functors allow us to abstract all pointer arithmetic and size calculations into a few lines of code, significantly reducing the opportunities for buffer overflows.

Polynomial Functors Constrained by Regular Expressions

We show that every regular language, via some DFA which accepts it, gives rise to a homomorphism from the semiring of polynomial functors to the semiring of \(n \times n\) matrices over polynomial functors. Given some polynomial functor and a regular language, this homomorphism can be used to automatically derive a functor whose values have the same shape as those of the original functor, but whose sequences of leaf types correspond to strings in the language.

Diagrams: a functional EDSL for vector graphics

diagrams is a domain-specific language for creating vector graphics. We will give a short diagrams tutorial/demo, particularly highlighting the power of a functional, embedded domain-specific language.

Making induction meaningful, recursively (abstract only)

Induction is a notoriously difficult topic for beginning computer science students to understand. Even if they can produce an inductive proof of some mathematical fact, many students never see the relevance of inductive reasoning outside of the classroom for anything beyond the natural numbers. This is unfortunate because inductive reasoning is closely intertwined with algorithm design and one of the cornerstones of reasoning about (recursive) programs. With the adoption of functional programming into the CS curricula core, it is a good time to revisit how we teach induction and try to make more explicit this fundamental connection between inductive reasoning and recursive programming. In this BoF session, we will discuss curriculum, strategies, and fun examples for teaching induction with an eye towards giving induction tangible and practical relevance for the computer science undergraduate.

FARM 2018 demo summary

This is a summary of the demonstrations presented at the 6th ACM SIGPLAN International Workshop on Functional Art, Music, Modeling and Design (FARM).