Cammy

Fork

Allow pairing of domains.

I'm so pissed that I couldn't do this in a nice generic fashion. This
works, but it's ugly and verbose.

Convert to final encoding.

This means the end of cammylib.arrows, which only existed for the
dispatch of the type-checking and CAM-compilation domains together in a
tuple. For now, we can just parse twice.

Final encoding is shorter than initial encoding! The Arrow class
hierarchy took up a lot of room and insisted on immutability; it turns
out that at least some arrows, injections and projections, have less
runtime data than type-checking data.

The compiler thankfully can use the same pending-arrow logic as before,
except that we no longer care at all about equality of arrows. If we
want to deduplicate bytecode, then we'll do it by comparing bytecode!

This was a little bit of a pain to debug. If a method verb is typo'd,
RPython offers little recourse. It will silently compile an
always-crashing method instead.

bk: With a flag, allow updating refs.

I was able to use this to programmatically update all of the demo
animation refs to use the new API.

bk: Parse S-expressions.

Obviously cribbed from cammylib. Same parser.

Also I implemented substitution. It works; I can use `apply anim-tuple
demo/anim/...` to upgrade any of the old animations to the new API.

bk: Correctly extract templates.

I don't know why the cognitive weight of JSON vs S-expressions is so
heavy, but it really does seem to suck part of my attention at all
times, and I'd like for it to be better.

bk: Hack together a basic insertion command.

It works, I suppose?

cammylib/pixel: Make RGB sampling work again.

bk: Spit out a big list of names.

Save inputs for AFL.

Further harden the parser.

This is enough to cause afl-fuzz to find nothing after 10 cycles.

Use afl to harden the parser and disassembler.

The first rounds of fuzzing mostly just showed that our exception
handling isn't very clean.

Use regexes to parse inject/project/nats/ords.

Implement ordinal points.

I need to figure out how to designate the ordinal-to-sum-of-points and
ordinal-to-nat functions to make this useful.

Implement injections and weak sums.

I'm not using the exact bytecode names from traditional CAM papers
because, just like with gotoRight, we're creating a new gotoTag bytecode
that better fits our memory layout. The way this works is via inspection
of the tag value, as before, but now the tag can be any nat
(practically, any machine-sized unsigned int) instead of a bool. Since
we can't encode a nat as control flow without exploding the size of the
code, we instead do something like classic CAM untagging instructions
along with a jump table. Our gotoTag instruction untags the term op and
uses the tag to do a computed goto from the jump table; each instance of
the instruction is associated with its own jump table. These are the
`tagTables` of the compiler.

cammy: Weaken products.

This could be a little iffy. I think I got it right, though. Existing
hive expressions will have to be explicitly re-nested, but the
transformation can be done mechanically, like with weakening
composition.

cammylib: Weaken composition.

Fairly easy compared to what's next.

Unhaunt git's pager.

The core of the problem was that busybox's implementation of `less` is
fucky, and that was fairly easy to fix!

cammylib: Add new syntax for nat constants.

Go all-in on RPython.

We're going to do as much stuff in RPython as possible. To that end,
we're not just going to think of this codebase as a sampler; it also
contains a full implementation of the type system and an extensible
parser.

Save some old stuff.

Also, remove jelly. Sorry but it's too expensive and doesn't get enough
done. I need a proper proof language instead.

Put documentation on the sampler REPL's commands.

Use rpypkgs.

Remove v2 hive and movelist.

Gotta cut down on old stuff that I can't move forward. In the case of
the v2 hive, there's now a v3 hive instead. When it comes to movelist,
all of the functionality is either elsewhere or too slow to be useful.
Like, djinn and fibre are cool toys, but they're not sufficiently quick
or property-driven for real applications.

Try to evict some ghosts from the repo.

For some reason, the pager is still wonky. I might have to globally
configure a decent pager.

Add a sort of Maxwell's-laws presentation.

I don't personally put much stock in this sort of thing, but Alan Kay
and Douglas Crockford think it's essential.

Clarify some notes.

jelly: Fix the problematic rule.

Add jets, resolve type-occurs issue.

I think that we're finally done with the discovery phase of the issue.

Remove a couple old scripts.

bk: Polish extraction and jet listing.

As a result, shared code is emerging.