Simon Peyton Jones

So my story would be static typing should expand to carry as much as possible.

And where you absolutely cannot do it, sorry, then use dynamic typing and we provide facilities to support that.

So GHC takes a string like any other compiler, the source code of the program, parses it, and then it type checks it, figures out is this a type correct program.

Then it converts it to lambda calculus.

Now, Haskell, the Haskell AST, the original source tree, has 50 different data types, 50 different kinds of nodes, some of which have 30 or 40 different variants.

So it's a really big, diverse, complicated data structure, the AST.

Lambda calculus has, this variant of the Lambda calculus has eight.

Wonder data, that may be two or three data types with eight constructors.

So it's like taking a gigantic language and squeezing it down into a tiny one.

And that tiny one we can then optimize, right?

That's the optimizer works on that.

So the front end does parse, rename, type check, de-sugar into lambda calculus.

That's the front end.

The lambda calculus particular language is called GHC's core language.

I'm quite proud of it because it's been very, very stable.

It's 35 years old, and it has barely changed since birth.

That's amazing, right?

Because Haskell has changed a lot, a lot, right?

So almost all of the innovation in Haskell has been in the front end, very little in core.

Now, the back end, the core optimizer has changed a lot too, but all of the changes that were useful there would have been useful 30 years ago, right?