I’ve been thinking recently about handling strings and names in compilers in a more principled way, and I think I’ve come up with a nice way of doing this.

Recently I’ve been wrapping up my work on a compiler for a subset of Haskell. While my subset doesn’t (yet) have any support for IO, I’ve been thinking about how to implement it.

This is the third post in the Haskell in Haskell series.

In this post, we’ll go over creating a parser for our subset of Haskell. This stage of the compiler is responsible for taking the tokens that our lexer produced in the previous part.

This is the second post in the Haskell in Haskell series.

In this post, we’ll go over creating a lexer for our subset of Haskell. This stage of the compiler goes from the raw characters in our a source file, to a more structured stream of tokens.

We’ll finally be digging into some serious code this time, so get your editor ready if you’re following along!

This is the first “real” post in the Haskell in Haskell series.

In this post we’ll go over setting up a basic project in Haskell. We’ll be building our compiler on top of this foundation in the next posts.

This is an introduction to a series I’m calling Haskell in Haskell. The goal of this series of posts is to go through the implementation of a subset of the Haskell language, from parsing, to typechecking, to code generation, using Haskell itself.

This is a series I’m writing about implementing a compiler for a subset of Haskell, using nothing else than Haskell itself! We’ll go through the whole process, going from a file containing Haskell code to generating C that we can compile into a functional executable. I’ve only just started working on the series, so stay tuned for new posts as they come along: I’ll update this page whenever they arrive.