Add assoc to kinda sorta track the values in the registers.

But it doesn't update e.g. if you add two numbers, the value int(N) stays the same.

It could be modified to track the value as it computes?  But then why keep them in registers at all? Sometimes a value must arrive at runtime, eh?

swap, pop, and +

compiling is tricky

dup, add_ref/3.

THread through a context to track registers.

It seems to work to allocate and free registers with a kind of reference counting
by membership in an auxilliary list.

Sort of compile '+'.

Move immediate to register for int literal.

blep.

A start on machine code generation.

Just the initial messing around...

Fix a bug in step.

You think it would be easy to find all the places where the type tags are needed.

docs, formatter

Fix a bug in rest.

It didn't tag the tail list as a list.

Also, spell out bool for true cases.

Minor cleanup.

I feel like I should keep the un-partially-reduced thun/4 but
you can still read it, and the reduced forms are more efficient.
(And not too much more wordy.)

Experiments with partial reduction are very promising.

Functions become clauses like these:

    thun(symbol(rolldown), [], [C, A, B|D], [A, B, C|D]).
    thun(symbol(rolldown), [A|B], [E, C, D|F], G) :-
        thun(A, B, [C, D, E|F], G).
    thun(symbol(dupd), [], [A, B|C], [A, B, B|C]).
    thun(symbol(dupd), [A|B], [C, D|E], F) :-
        thun(A, B, [C, D, D|E], F).
    thun(symbol(over), [], [B, A|C], [A, B, A|C]).7
    thun(symbol(over), [A|B], [D, C|E], F) :-
        thun(A, B, [C, D, C|E], F).

Definitions become

    thun(symbol(of), A, D, E) :-
        append([symbol(swap), symbol(at)], A, [B|C]),
        thun(B, C, D, E).
    thun(symbol(pam), A, D, E) :-
        append([list([symbol(i)]), symbol(map)], A, [B|C]),
        thun(B, C, D, E).
    thun(symbol(popd), A, D, E) :-
        append([list([symbol(pop)]), symbol(dip)], A, [B|C]),
        thun(B, C, D, E).

These are tail-recursive and allow for better indexing so I would expect
them to be more efficient than the originals.

Notice the difference between the original thun/4 rule for definitions
and this other one that actually works.

    thun(symbol(Def),   E, Si, So) :- def(Def, Body), append(Body, E,    E o),    thun(Eo, Si, So).
    thun(symbol(Def),   E, Si, So) :- def(Def, Body), append(Body, E, [T|Eo]), thun(T, Eo, Si, So)

The latter reduces to:

    thun(symbol(A), C, F, G) :-
        def(A, B),
        append(B, C, [D|E]),
        thun(D, E, F, G).

We want something like...

    thun(symbol(B), [], A, D) :- def(B, [H|C]), thun(H, C, A, D).
    thun(symbol(A), [H|E0], Si, So) :-
        def(A, [DH|DE]),
        append(DE, [H|E0], E),
        thun(DH, E, Si, So).

But it's good enough.  The earlier version doesn't transform into
correct code:

    thun(symbol(B), D, A, A) :- def(B, C), append(C, D, []).
    thun(symbol(A), C, F, G) :- def(A, B), append(B, C, [D|E]), thun(D, E, F, G).

It would probably be good to investigate what goes wrong there.)

It doesn't seem to work right for thun/4 combinator rules either.  Dunno what's
up there.

Partial reduction of thun/3 in the thun/4 relation.

It mostly works.

Map combinator works with types.

Remove '==' from definitions.  (Bools)

I decided that the conceptual simplicity of omitting '==' is more useful
than the cosmetic value of keeping it.  The defs.txt file is now just one
definition per line with the first symbol giving the name.

Also, bools are literals.

Definition for 'not' in terms of 'branch'.

Proper types, checking, inference.

When I first translated Joy into Prolog I was so blown away by the Prolog
unification over list structures and Triska's CLP(FD) semantics for math
(both in the sense that he wrote CLP(FD) for SWI Prolog and he suggested
it for Joy-in-Prolog specifically) that I didn't realize that it wasn't
quite type inference.

It's kind of like type inference, in that lists are handled correctly and
the CLP(FD) library creates and maintains a kind of context for
constraints, which are sort-of like "dependent types" if you squint a
little.  But you can still do things like 'cons' a number to a number and
get (a Prolog term) like [2|3] which is almost certainly a bug.

So I went through and added type "tags" as Prolog terms: int/1, list/1,
and symbol/1.  The parser assigns them and all the primitive functions
and combinators use them (and so all the definitions do too.)  With this
information Prolog can e.g. prevent attempts to add numbers and lists, and
so on.

This also allows for the thun/3 relation to be implemented a little more
efficiently (without much loss of beauty) by looking ahead one term in
the pending expression and dispatching on structural "type" in a thun/4
relation.  I miss the elegance of the previous version, but this lets
Prolog index on the structural type tags that the parser produces.

(This might mess up tail recursion because now we have a loop between
thun/3 and thun/4 but we can eliminate that problem by partial reduction
on thun/3.  TODO.)

Now that literals are tagged by the parser there's no need for literal/1.

Don't assert defs twice.

Each definition is getting parsed with the name of the next one as part
of its body, then the next one fails to parse and the thing backtracks.
So each definition (but the last) gets asserted twice.

    def(--,[1,-,?])
    def(--,[1,-])
    def(?,[dup,bool,++])
    def(?,[dup,bool])
    def(++,[1,+,anamorphism])
    def(++,[1,+])
    def(anamorphism,[[pop,[]],swap,[dip,swons],genrec,app1])
    def(anamorphism,[[pop,[]],swap,[dip,swons],genrec])
    def(app1,[grba,infrst,app2])
    def(app1,[grba,infrst])
    def(app2,[[grba,swap,grba,swap],dip,[infrst],cons,ii,app3])
    def(app2,[[grba,swap,grba,swap],dip,[infrst],cons,ii])

...and so on.

Change back to CLP(FD) semantics.

Minor changes to parser to make it less logical but a little firmer.
(E.g. ints can't be backtracked into becoming symbols!)

Docs and minor cleanup to the grammar.

Minor cleanup.

Make parser REs into module-level "constants".

Some helper scripts for windows.

Minor docs update.

Debugging this sucks.

Even with the RISC emu GUI.

Redesign vm?  Add more tooling?  Use MetaII?

Happy Thanksgiving!

Emit a sort of symbol table.

4 is already an offset

Definitions.

"swap" word.

"new" word.

Refactor sub_base_merge_and_store.

dup cons i

Forgot to "return" from i combinator.

Even "nicer".

Charming.

dexpr//1

The i combinator.

head_addr

Simple push of empty list.

Dup.

ANd portray_clause to stablize output logical variable names.

halt.

word works with negative numbers now.

symbols moved to head of machine code.

merge_and_store, chain_link

Minor refactor.

It doesn't save space (but if I reuse it once it will.)

Pass through label.

if_literal and lookup

incr stack

Really decr, but I'm abstracting.

Refactoring and cleanup.

load

Bleah.

Base address in unpack_pair.

unpack_pair

Minor refactor.

Refactoring, with oddball quoting "symbols".

That works nicely, again.

Convert to ? DCG and it's macro-time!

I think that does it for cons.

Offsets in pair records can be negative.

That's the mainloop converted to permit negative offsets.

Minor cleanup, bug fixes.

Minor bugfix.

asr not ror.

Cons

Just do it in asm.

hmm...

WIth push2 finished that's the mainloop converted.

lookup

if_literal

A start on converting the mainloop.

Take two on the compiler.

Minor cleanup.

Modify error reporting a lil; words word.

Definition of ii combinator.

    ii == [dip] dupdip i

         a [F] ii
      --------------
          F a F

Call for_serial/2

Using partial deduction to inline literals, functions, and combinators.

minor cleanup

small func recognizes [] and [X].

Rename bar to korf and some docs.

minor cleanup

reintroduce definition of fork; it doesn't shadow func(fork, ...).

read child output after local thun/3

truly fork, sort of

minor cleanup

Minor cleanup.

Move DCG stuff to own file.

Parse ints; move line/{1,2} to main.pl.

Parse floating point numbers.

minor cleanup

minor cleanup

Numbers can be followed by space or [.

Parse negative numbers.

swapd function

assert_defs/1 got upset about not finding combo/5

Minor cleanup of the parser.

rework parser DCGs

Oops! Regression.

minor cleanup

swoncat and fiddling with parser.

Experiment with putting logic vars on the stack.

Remove a cut that sucked.

unstack, least_fraction