The Future is Comonadic!
(May Day-Convoluted Weekend)
There are many techniques for the declarative specification of user interfaces, but it is not clear how to study their similarities and differences. The category-theoretic notion of a comonad captures some essential aspects of these specification techniques. The approach presented here generalizes several known techniques, but perhaps more interestingly, it also generates several new comonads as we search for ways to represent existing user interfaces.
An Overview of the PureScript Type System
(Los Angeles Haskell Group)
PureScript's type system has grown gradually over the past four years, driven by the need for solutions to real-world problems and also experimentation. This talk is an overview of the implementation of some of the type system features which were inspired by Haskell, and also some novel features such as row polymorphism.
Stack Safety for Free
(Code Mesh 2016)
Recursion can run afoul of stack overflow errors if we are not careful to make our functions tail-recursive. But tail recursion is not enough if we want to use monadic recursion, or abstractions like free monads and free monad transformers. In this talk, I show how we are able to make these techniques safe in PureScript, a strict Haskell-like language that compiles to JavaScript.
Fun with Profunctors
(Los Angeles Haskell Group)
The Profunctor type class provides an alternative presentation of lenses and prisms. In this talk, I gave an introduction to profunctor optics and examples.
Principal Type Schemes for Functional Programs
(Papers We Love)
The Damas-Hindley-Milner type system is a classical system for the first-order polymorphic lambda calculus, and the ML family of programming languages. This paper introduces Algorithm W, a simple algorithm for type reconstruction in the DHM type system. I'll walk through the main results of the paper, and compare the DHM type system with other more modern systems.
Embedded DSLs in Haskell
(Los Angeles Haskell Group)
Haskell is a great tool for prototyping languages and building compilers, with high-level abstractions that make parsing, type-checking, transformations and code generation very simple. However, we can avoid a lot of that work by creating an embedded language, inside Haskell. This talk shows some techniques that you might use for doing writing simple embedded domain-specific languages in Haskell.