Caching type checker output via interface files

[buggymcbugfix]

Instead of rechecking the whole dependency tree of a Granule program at every type checker run, we can cache (transitively) unchanged code and only check new/changed code. This reduces some unnecessary re-computation, thereby speeding up the development/type-check cycle.

This patch brings

caching granularity at the module level. (Modules currently map one-to-one to Granule source files, so bear with me if I sloppily conflate the two.)

We write the checker output of checking a module Foo (from file Foo.gr) to disk in an interface file Foo.gri.

The type checker can then skip re-checking Foo if Foo.gri is newer than Foo.gr.

When checking the module Bar, that depends on Foo, the checker simply loads the interface file for Foo into the context.

Module dependencies

are relevant for cache invalidation. When determining whether we can skip re-checking module Foo, it is actually not enough to consider whether the interface file is newer than the source file. We also need to verify that the module signatures of the dependencies of Foo have not changed.

Therefore, we need to do a dependency analysis of the module hierarchy of a Granule program. (Incidentally this will make it easy for us to avoid hanging in an infinite loop when chasing circular imports, which is what happens with the current module... sitch.)

But there is more in this patch

such as adding gr, a nice quasi quoter for embedding Granule ASTs in your Haskell source files:

[gr| --your granule code here! |]

There are also bugfixes like the already mentioned cyclical imports (which we simply disallow), as well as allowing dependencies to be literate files.

Naming things is difficult.

This patch adds something similar to header files in C. ML uses the term interface file for a related concept, which is, more generally, a module signature. We could have a discussion about what we call this concept in Granule.