HMinCaml

Copperbox revision 2729.

Initial work on closure conversion.

directory-diff

Copperbox revision 2728.

I've changed the report to print the previous names of moved files and directories.

directory-diff

Copperbox revision 2727.

I've added a two continuation, two input stream parser. This lets me (fairly) easily encode rules to check wither an old path matches a new one - modulo inserts or deletes to one of the paths. Probably I should have implemented this with a finite state automata (making it closer to lexing than parsing), but I know how to easily implement parsers.

Testing that an old directory has the same path as the new one, with a directory "Current" removed somewhere along the path is:

    test = prefix >> symbolL "Current" >> suffix

Note - no doubt I will change the combinator names.

HMinCaml

Copperbox revision 2726.

I've implemented constant folding and useless let elimination.

I've encoded these two with a direct environment (no Reader monad) and pattern guards. This seems like a big improvement - once I've implemented closure conversion, I'll change the previous passes to use direct environment passing pattern guards.

directory-diff

Copperbox revision 2725.

I've added some specific checks for the project I'm working on. Maybe at some point these should be generalized to encode arbitrary checkers for file system "patterns".

directory-diff

Copperbox revision 2724.

I've added timestamps to the report output for the toplevel directories. Plus I've moved Main to the top of the src folder. Seemingly GHC / Cabal doesn't recognize Main as Main if it is not at the root of the directory tree.

HMinCaml

Copperbox revision 2723.

I've added some optimization passes - alpha renaming, beta conversion and inline expansion. I've also renovated the HMonad so it is only run once, the monads built on top of it are run as local effects (which was a design pattern in one of Strafunski papers).

directory-diff

Copperbox revision 2722.

Reworking of directory-metrics to diff two dir listings. Output from the Windows / DOS dir command is too noisy to diff, so this utility does a "semantic" comparison.

Note - it has some hard-coded special behaviour for my use-case - i.e. it recognizes a certain pattern of delete and new as a move. It doesn't investigate files to look for "genuine" moves as it works off-line on dir listings.

ochre

Copperbox revision 2721.

New project - ochre.

This is a reworking of orchsyn with a simpler expression type - as Csound supports if-then-else I think I can avoid lambdas in the expression language, this makes Ochre quite a bit simpler than Orchsyn.

I've implemented the same expression language optimizations as Orchsyn, which means I'm up to converting the expression language into Csound, the big step...

directory-metrics

Copperbox revision 2720.

Initial work on pretty printing / metrics reporting.

directory-metrics

Copperbox revision 2719.

Fixed a severe bug in tree building that was generating wrongly-shaped trees.

Added first sets of metrics.

directory-metrics

Copperbox revision 2718.

I've implemented tree building, so now directories are represented recursively. The code isn't efficient as it doesn't account for the fact that Windows directory listings are usefully ordered (erm, preorder? I can never remember without making a drawing on paper).

directory-metrics

Copperbox revision 2717.

Work towards tree building (and forest building). As I think I have a forest rather than a tree I think I can build the forest lazily. At the moment I'm struggling to build even a tree though...

directory-metrics

Copperbox revision 2716.

New (small) project to extract directory metrics.

It is intended that metrics are derived from listings made at the command line, rather than run directly on the file system. To this end I've written a parser for Windows dir listings. The parser uses a new implementation of parser combinators that should stream and thus can be used for very large files.

HMinCaml

Copperbox revision 2715.

I've restarted work on HMinCaml - actually I restarted work last week but this is the first time it feels like it merits a commit.

I've decided to work in regular Haskell rather than UUAG. So far I have up to k-normalization "working" - some of the code is of pretty dubious quality hence the scare quotes. Type annotation works for simple types though fails for the example Ackerman function. Hopefully I can find a satisfactory reference for type directed translation, I'm a bit out of my depth at the moment.

I don't intend generating SPARC code as I have no SPARC machine to run it on, I'll stop at MinCaml's idealized assembler. My interest is really to get up to closure conversion, anyway.