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

Copyright notices.

The sqrt/1 predicate wasn't working.

Multifile func/3.

Build math & comparision functions.

Clean up REPL formatting.

Don't shadow funcs and combos.

Don't shadow funcs & combos.

Extract mainloop to own file.

Use double-quoted string for codes.

cleanup old files

Build defs.pl from defs.txt.

build defs.pl

build defs.pl

Move parser to own file.

map combo

Bring in funcs and combos.

Omit Prolog toplevel.

Do not need thses files.

Fold in parser, main loop, and support.

Rename foo to thun.

Make a version for GNU Prolog compiler.

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.

Prevent definitions from shadowing functions.

Demo grow/shrink.

Some trailing whitespace or something.

A few more functions.

reverse, shift, shunt, take, split_at

merge

grow/shrink as DCGs.

Integer DCGs that work in both directions.

loop combinator handles ambiguity.

remove some old notes.

Move is_numerical() to joy.gui.utils.

Experiment in formatting stacks for output.

Tracing, sort of...

Minor refactor.

crbo/4 to to_fixed_point/3

Gnarly fun with metaprogramming.

Get the path separator right on windows.

It used to use: C:\Users\sforman/.joypy

which worked, but ew.

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?

Bits of formatting.

Minor cleanup.

Remove write_state/5.

Build a list of the moves taken.

Refactor a bit.

Assert definitions as they are read.

Instead of building a list then asserting them all after parsing.

Messing with TLA+ in Prolog.

Implement map combinator.

Tiny edits.  Almost nothing.

Remove cuts from branch combinator.

Add mod, gcd, and hypot; term_expansion for math ops.

Fold try_both_branches/4 into branch combo.

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.)

WTF error handler.

Made it check that the unknown term really isn't a literal, definition, function, or combinator.

If I comment out the WTF handler...

...then the branch combinator works as intended.  (Although the constraint-based stuff was also cool, it would have captured information from the comparison.)

?- joy(`[32 >] [++] [--] ifte`, Si, So).
Si = [_6598|_6600],
So = [_6598+1|_6600] ;
Si = [_6598|_6600],
So = [_6598-1|_6600] ;
false.

?- sjc(hmm, `[32 >] [++] [--] ifte`).
func(hmm, [A|B], [A+1|B]).
true ;
func(hmm, [A|B], [A-1|B]).
true ;
false.

Try to handle expressions in branch combinator.

If the expression isn't 'true' or 'false' atoms then we assume it's a comparison expression and try to check its truth value.

If this fails then it will try both branches, to allow for e.g. compilation.  THis almost works, but there's a choice point or something that gets hit before it tries the false path,

?- joy(` [32 >] [++] [--] ifte`, Si, So).
Si = [_2076|_2078],
So = [_2076+1|_2078] ;
wtf? +
Si = [_2076|_2078],
So = [[+], 1, _2076|_2078] ;
Si = [_2076|_2078],
So = [_2076-1|_2078] ;
wtf? -
Si = [_2076|_2078],
So = [[-], 1, _2076|_2078] ;
wtf? branch
Si = [_2076|_2078],
So = [[branch], [++], [--], _2076>32, _2076|_2078] ;
wtf? swap
Si = [_2076|_2078],
So = [[swap, branch], [--], [++], _2076>32, _2076|_2078] ;
wtf? first
Si = [_2076|_2078],
So = [[first, [++], [--], swap, branch], [_2076>32|_2078], _2076|_2078]

etc...

Handle exceptions in comparison ops.

You can't compare logic vars, so just bunt.

More readable genrec.

Explicit quoting is slightly more overhead but worth it I think to show what's going on more clearly.

A little helper function to see compiled expressions.

Example from ordered binary tree notebook:

    ?- sjc(tree_add_Ee, `pop swap rolldown rrest ccons`).
    func(tree_add_Ee, [_, [_, _|C], A, B|D], [[A, B|C]|D]).
    true .