sforman/Thun
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
340 Commits 2 Branches 0 Tags
712dd24e887454b09c4bf58ae3188e9489517ed6
Commit Graph
340 Commits
This Branch
This Branch
All Branches
Author SHA1 Message Date
Simon Forman 712dd24e88 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.
 2020-01-28 12:24:04 -08:00
Simon Forman 768c7f6599 Sort of compile '+'. 2020-01-28 11:01:28 -08:00
Simon Forman bc7b471daf Move immediate to register for int literal. 2020-01-28 10:46:38 -08:00
Simon Forman 6888c71b69 blep. 2020-01-28 10:37:13 -08:00
Simon Forman 5b6bd42ebe A start on machine code generation. 
Just the initial messing around...
 2020-01-28 10:21:37 -08:00
Simon Forman b323402c9b Fix a bug in step. 
You think it would be easy to find all the places where the type tags are needed.
 2020-01-27 12:56:26 -08:00
Simon Forman 6e8151a0b2 docs, formatter 2020-01-27 11:54:24 -08:00
Simon Forman 714aa59c43 Fix a bug in rest. 
It didn't tag the tail list as a list.

Also, spell out bool for true cases.
 2020-01-26 17:06:21 -08:00
Simon Forman ab0a378b56 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.)
 2020-01-26 16:50:49 -08:00
Simon Forman 76de590d27 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.
 2020-01-26 13:21:47 -08:00
Simon Forman ef6d271c85 Partial reduction of thun/3 in the thun/4 relation. 
It mostly works.
 2020-01-26 12:48:38 -08:00
Simon Forman 0af0fb7e8e Map combinator works with types. 2020-01-26 10:15:32 -08:00
Simon Forman e0a36eab8b 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.
 2020-01-26 09:48:30 -08:00
Simon Forman ed41395560 Definition for 'not' in terms of 'branch'. 2020-01-26 08:44:57 -08:00
Simon Forman 2aa1765b89 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.
 2020-01-26 08:43:52 -08:00
Simon Forman 6e6e52d206 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.
 2020-01-25 16:13:06 -08:00
Simon Forman 1ecb5be278 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!)
 2020-01-25 15:50:50 -08:00
Simon Forman 36ec93e46b Docs and minor cleanup to the grammar. 2020-01-25 14:35:44 -08:00
Simon Forman 0588496ca5 Minor cleanup. 2019-12-03 08:41:42 -08:00
Simon Forman fdf0339e16 Make parser REs into module-level "constants". 2019-12-02 14:26:07 -08:00
Simon Forman 39a0e73fac Some helper scripts for windows. 2019-12-02 14:14:38 -08:00
Simon Forman 57446a1179 Minor docs update. 2019-12-02 14:13:50 -08:00
Simon Forman eb591d27e0 Debugging this sucks. 
Even with the RISC emu GUI.

Redesign vm?  Add more tooling?  Use MetaII?

Happy Thanksgiving!
 2019-11-28 07:58:42 -08:00
Simon Forman ff69046a4c Emit a sort of symbol table. 2019-11-13 21:15:33 -08:00
Simon Forman 4a1770b1cc 4 is already an offset 2019-11-13 15:07:27 -08:00
Simon Forman 93caa2ed66 Definitions. 2019-11-13 11:41:41 -08:00
Simon Forman 851f212fb2 "swap" word. 2019-11-12 16:09:13 -08:00
Simon Forman 4faebb4551 "new" word. 2019-11-12 15:47:33 -08:00
Simon Forman 4cba943355 Refactor sub_base_merge_and_store. 2019-11-12 11:42:24 -08:00
Simon Forman 89c58d4f5a dup cons i 2019-11-12 09:23:31 -08:00
Simon Forman e72fa2585f Forgot to "return" from i combinator. 2019-11-12 09:18:58 -08:00
Simon Forman 9cfb06c736 Even "nicer". 2019-11-12 09:06:22 -08:00
Simon Forman 54fe7cbab7 Charming. 2019-11-12 09:03:54 -08:00
Simon Forman f201cd6bb3 dexpr//1 2019-11-12 09:02:19 -08:00
Simon Forman afea54bf08 The i combinator. 2019-11-12 08:37:20 -08:00
Simon Forman 80d127788e head_addr 2019-11-11 07:51:58 -08:00
Simon Forman c3e44e2bf8 Simple push of empty list. 2019-11-11 07:45:22 -08:00
Simon Forman 3126dce307 Dup. 
ANd portray_clause to stablize output logical variable names.
 2019-11-10 14:35:57 -08:00
Simon Forman 0b210d7754 halt. 2019-11-10 10:58:47 -08:00
Simon Forman 2e301fa6c3 word works with negative numbers now. 
symbols moved to head of machine code.
 2019-11-10 10:53:55 -08:00
Simon Forman 4a39d82c75 merge_and_store, chain_link 2019-11-09 21:55:01 -08:00
Simon Forman cde066eb86 Minor refactor. 
It doesn't save space (but if I reuse it once it will.)
 2019-11-09 21:20:31 -08:00
Simon Forman 2b9034f6d5 Pass through label. 2019-11-09 20:19:15 -08:00
Simon Forman 8405d3f863 if_literal and lookup 2019-11-09 18:39:39 -08:00
Simon Forman 7a821a4eaf incr stack 
Really decr, but I'm abstracting.
 2019-11-09 18:28:01 -08:00
Simon Forman 67583716f2 Refactoring and cleanup. 2019-11-09 18:15:56 -08:00
Simon Forman 04b021846a load 2019-11-09 18:02:07 -08:00
Simon Forman 8ee9a05780 Bleah. 2019-11-09 15:20:06 -08:00
Simon Forman e4c17f8c24 Base address in unpack_pair. 2019-11-09 15:12:44 -08:00
Simon Forman bcadc95aa3 unpack_pair 2019-11-09 15:03:17 -08:00