sforman/Thun
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
428 Commits 2 Branches 0 Tags
56da4690d025635bc08a95c6587c75835005205b
Commit Graph
73 Commits
Author SHA1 Message Date
Simon Forman ea356a539a primrec combinator in Prolog 
Ticket #40375
 2020-05-05 15:52:40 -07:00
Simon Forman 8a898e0292 Some comments. 2020-04-23 15:14:36 -07:00
Simon Forman 72388787de Minor edits. 2020-01-31 12:06:31 -08:00
Simon Forman cfab1cf3c8 Minor edits. 2020-01-31 12:01:13 -08:00
Simon Forman a14a55defb Remove unused predicates appears_only_once/2 and reg_used_once/2. 2020-01-31 08:30:10 -08:00
Simon Forman 3d1c9bab95 Freeing registers before using them is simpler. 
https://todo.sr.ht/~sforman/thun-der/3
 2020-01-31 08:26:10 -08:00
Simon Forman 400cc7dcde Partial reduction for combinator rule works after all. 
It just looked weird to me and I didn't think it through.
Once I checked it I realized it was okay.
 2020-01-30 10:25:12 -08:00
Simon Forman 8d1797c1b6 Uncovered and fixed a subtle bug in free_reg//3. 
non_alloc/1 for words that don't change the ref count of registers and can be delegated to their semantic relation.
 2020-01-29 11:04:22 -08:00
Simon Forman 95df1fda8c Cons. I should research Lisp compilers... 
I think I should emit high-level code and reduce it to actual
machine code later under whatever model (cons cell heap, etc.)
 2020-01-29 09:48:08 -08:00
Simon Forman 26c92e9a48 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?
 2020-01-28 18:04:51 -08:00
Simon Forman ca7c23b1ac swap, pop, and + 
compiling is tricky
 2020-01-28 17:16:17 -08:00
Simon Forman bf8cc63c70 dup, add_ref/3. 2020-01-28 12:44:19 -08:00
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 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 3751107a09 Modify error reporting a lil; words word. 2019-11-07 07:54:04 -08:00
Simon Forman aae0e91c44 assert_defs/1 got upset about not finding combo/5 2019-08-12 21:08:17 -07:00
Simon Forman 10a23c5c68 Also don't shadow combinators. 
(I realized that the way defs are parsed now means that each def
(but the last) is first asserted with the wrong definition expression
(it includes the symbol of the following definition at the end) and
then the parser figures out that there's another defintion following
and re-asserts the correct expression.  It would be nice to fix that
but it's kind of a PITA.  I used to build a list of definitions and
then assert them all at the end.  For now there aren't enough defs to
justify the extra work.
 2019-08-09 16:58:34 -07:00
Simon Forman cbf2af18e5 Prevent definitions from shadowing functions. 2019-08-09 16:53:40 -07:00
Simon Forman 49491bceef Demo grow/shrink. 2019-08-09 16:37:33 -07:00
Simon Forman b9ae00cecb A few more functions. 
reverse, shift, shunt, take, split_at
 2019-08-09 07:26:37 -07:00
Simon Forman 712f0a0267 merge 2019-08-07 23:36:38 -07:00
Simon Forman 976b8302be grow/shrink as DCGs. 2019-08-07 23:28:28 -07:00
Simon Forman 4ea77cf1be Integer DCGs that work in both directions. 2019-08-07 11:40:49 -07:00
Simon Forman 0048ee212d loop combinator handles ambiguity. 
remove some old notes.
 2019-08-04 09:28:01 -07:00
Simon Forman 3b1a89d1c4 Minor refactor. 
crbo/4 to to_fixed_point/3
 2019-08-03 19:01:00 -07:00
Simon Forman cb0078f3bc Gnarly fun with metaprogramming. 2019-08-03 17:56:25 -07:00
Simon Forman 2ba9242b76 Comparisions are literals too. 
Also a bunch of reformatting.

Maybe I can modify the term_expansion/2 to also write the literal/1 clauses for math and comps?
 2019-07-22 10:25:34 -07:00
Simon Forman df94c8feed Minor cleanup. 2019-07-21 18:48:11 -07:00
Simon Forman c1442945a6 Assert definitions as they are read. 
Instead of building a list then asserting them all after parsing.
 2019-07-21 14:13:48 -07:00
Simon Forman 32d5953f29 Implement map combinator. 2019-07-21 08:28:56 -07:00
Simon Forman 1b5d1c0b82 Remove cuts from branch combinator. 2019-07-20 19:34:56 -07:00
Simon Forman 206f49598e Add mod, gcd, and hypot; term_expansion for math ops. 2019-07-20 19:26:11 -07:00
Simon Forman ae769d2341 Fold try_both_branches/4 into branch combo. 2019-07-20 17:36:58 -07:00
Simon Forman 230288c02c Replace ? with plain ol' def/2. 
As much fun as it was using ? as an operator, now that all the defs live in a text file you don't see it in the Prolog code anymore.

This way I get to use sweet sweet ASCII (except for the ? symbol in the copyright notice.)
 2019-07-20 17:32:03 -07:00
Simon Forman 7354911d05 WTF error handler. 
Made it check that the unknown term really isn't a literal, definition, function, or combinator.
 2019-07-20 17:19:35 -07:00