Regiux

Fork

Update README.

parser: Use some sugar.

parser: Make string QLs left-recursive.

And, with this, there's no longer any good explanation for why we cannot
match formals and binds at the same top-level.

Get 2 + 2 working again.

The supercombinator preparation will be the hard part. Not tricky, just
a lot of work.

gmachine: Flesh out actual operations.

This is going to be a supercombinator machine, so I need to rethink the
current compilation scheme.

Break ground on a G-machine implementation.

I think that we have all the pieces in place. I'm not totally sure,
though; we might need to rearrange more.

parser: Add weird let-expression and rec-expression.

Fuck with the parser some more.

The `formals` productions weren't all left-recursive, and sadly that's
not the reason why `formals` is overriding `binds` during parses.

parser: Recognize let-expressions.

Set up a standalone repo.

I'm tightening up the license because I have had *zero* code
contributions from others. This wasn't supposed to be a solitary
mountain climb, but a hiking group. That didn't happen, so I'm removing
any possibility that any corporation can exploit this code.

regiux: Parse and compile quasiliteral strings.

Requires a RPLY fork, so currently broken.

regiux: Resolve ops during parsing.

regiux: Stub out binary ops.

The provided addition op works fine, first try. But I'm not going to be
worried about that. Why wouldn't it work? The curry is so very natural.
I was expecting an RPython error but the translator is generous today.

regiux: Add string literals.

There's some future work to be done here with quasiliterals.

regiux: Implement Booleans and if-expressions.

reguix: Wire up basic inherits.

reguix: Implement builtin attrset and application.

I had to figure out a fair amount of structure. We now compile on top of
a live scope, directly embedding our objects into the heap and
incorporating live references.

regiux: Sketch a loop-detecting heap.

The basic idea is borrowed from GHC, which does something similar.

regiux: Sketch out the construction of attrsets.

An attrset's names are statically known! So, we should probably compile
it to some sort of key-thunk structure.

regiux: Set up a basic division of responsibility.

The idea is that we need two workflows:

* REPL: given a top-level expr, repeatedly stir the heap
* Recursive Nix: From within a heap action, invoke the parser and
possibly the builder

We're punting on building for as long as possible, but even without
builders we may still have a situation where we import code from the Nix
store while mid-evaluation. To handle this, we want to slowly pivot
towards a single unified workflow:

* Given a heap object, reduce it to WHNF or NF (two methods)
* REPL: Compile to a heap object, reduce it to WHNF, print it
* Recursive Nix: While reducing a heap object, invoke the parser

Now, the *real* complexity will be in invoking the *builder* while
reducing the heap; that would require some sort of scheduler and
reactor, possibly using CPS techniques to add continuations as
callbacks. Mother of monads, event loops, etc. This is already
well-known to be a monadic structure, so we'll have to tackle it
eventually, but not today.

regiux: Split parser.

reguix: More of the parser.

The remaining parts have to do with lexing and parsing of quasiliteral
strings. Parsing these is always...involved. It seems rply doesn't
support the CppNix approach of stateful lexing, so instead we'll have
to carefully lex quasiliterals into pieces and parse the pieces.

regiux: Disentangle bad refs.

Now lambdas pretty-print. Let's figure out attrsets next!

regiux: More parsing.

regiux: Hack out about half of Nix's grammar.

Okay, maybe more like a third. There's a bunch of gnarly regexes that
probably can be ported directly for the lexer, a bunch of implicit
characters that have to be explicitly catalogued and named, and a lot of
boxes to be written for the parser.

I've used as much metaprogramming as I can here, but historically
RPython doesn't like autogeneration of box classes, so they are
handwritten. Yuck.

Set up scaffolding for a Nix parser.

The name is based on a suggestion from
https://fosstodon.org/@IslandUsurper/112322426945766066 and is a pun on
*Python regius*, or "royal python", the Latin name for ball pythons.