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 .

Clear out CLP(FD) functions.

I like them but then you are constrained (pun intended) to only using integers.  I'll probably bring them back at some point, either as an alternate implementation or their own commands.

Opps! Here's the implementation of bool.

Add bool function to mimic Python semantics.

Change comparison ops to not use CLP(FD).

Implement genrec combinator.

Minor cleanup of defs.

Move all definitions to defs.txt.

Retract previous definitions before asserting new ones.

Load definitions from a file.

This paves the way to regularize the defs between Python and Prolog (and and future other) implementations.

Very minor docs change.

Parse joy definitions from text.

This way a definitions file can be shared between Python Joy and Prolog Joy.

New combinator infrst == infra first

Three uses means it's time for a refactor.

nullary combinator as definition.

That eliminates all the recursive calls to thun/3 (outside of thun itself, which is tail recursive.)  That means that this Joy interpreter is now fully CPS.

All state is contained in the stack and expression, nothing is hidden in the Prolog "call stack".

Infra as definition.

Reimplement app1 and app2 as definitions.

This eliminates three recursive calls to thun/3.

Got enough definitions, sort them.

Switch to symbolic math (from CLP(FD).)

A wee bit of error reporting of unknown terms.

New functions: pm plus-or-minus and neg negate; new combinator dupdip.

Docs on Start Up Sequence

Stop hg ignoring the build dir.

I want to include the HTML output of sphinx so you can view it without having to install sphinx.

More docs...

A bit more on the docs.

Move VUI package/module graph.

screenshot

A start on docs for VUI.

It's hella crude yet.

Welcome to the Sphinx 1.8.5 quickstart utility.

Rebuilt MANIFEST file.

Use ~/.thun instead of ~/.joypy as default JOY_HOME.

And some copyright notices I missed.

Well, that seems to work.

    python -m joy.vui

With PyGame installed that starts the "VUI" on my system.  Neat.

The initial joy home (~/.joypy) is not quite compatible with the one set up by the GUI code.  One simple way to fix that would be to e,g, make this use ~/.thun instead.

Update initial joy home dir contents BLOB.

Update imports, copyright notices.

Some images generated by pyreverse or whatever.

Initial bring over of VUI code. (Won't work yet.)

See https://www.metalevel.at/acomip/

Minor cleanup.

Change name from alpha to tmi.

A Tracing Meta-Interpreter for Thun

Some docs, and a thing to print out the dictionary after compilation.

Minor cleanup and comments.

linker//1 works on ASM not IR. (rename variable)

Add some comments, minor rearrangement.

Make get//1 handle lists of pairs which it passes off to get//2.

(I could remove more punctuation by making the (key, value) pairs implicit.)

Move compile_program//2 to just under do//0.

Minor cleanup.

Remove the pass0//2 DCG rule and unfold it in compile_program//2 rule.  Move init//0 to be with the rest of the state DCG code.

Minor cleanup.

It turns out that the binary_number relation is used in such a way that it needs to be able to backtrack to preprend leading zeros to the list of bits it constructs to automatically build bitfields of a given width (with the collect//2 DCG.)

binary_number/2 is more efficient if you strip off 0's first.

Bring in the (sort of) compiler.

Very minor cleanup.

Treat defs in thun/3 relation.

Allow for "compilation" of new func/3 rules.

Add comment of crude grammar for Joy syntax.

Minor rearrangements.

show_joy_compile uses portray_clause/1.

I just want to publish this right quick.

The Prolog version of Joy.

A bunch of docs.

Things have kind of run away with me.  I've been working in Prolog for
the last month or so.  I'm not yet sure how to bring it together with the
Python code.

The version of Python with Anaconda is lightly newer.

Add binary functions.

In progress..

Working on compiler.

I have a simple dataflow thingy for some Yin and Yang functions.

Minor UI bugs.

I should nail this down better.  Command selections like ' []' were
failing to evaluate.

Oh python, oh unicode.

Load JOY_HOME/definitions.txt

You still can't edit other text files from within the UI, but at least
now you have a place to persist your own definitions over restarts.

I thought about having a [definitions] section in the config INI file,
but for some reason I prefer a separate definitions.txt file.  I dunno.
Might change it in future.

TEXT_BINDINGS stay in textwidget.py.

Rework the default JOY_HOME contents.

Config file and CLI arg parser.

Loop and while combinators.

Futzing with types.

Getting back to parity after jumble.

Polytypes module folded into types module, with all the actual type
information done when you load the library module.  Some definitions can
be inferred from their body expression, others need to be
CombinatorJoyType wrapped.  Still to do: loop.

Working to get types right.

Fix TextJoyType inheritance.

Log types at startup.

Add some logging.

Cache the results of type checking.

Removing polytypes; some pylint hints.

Definitions infer stack effects.

At start-up defs that DON'T type check are permitted (so you can use e.g.
loop, map, etc.) in the definitions "source", but then the user-facing
inscribe command only allows you to define new commands that DO
type-check.  The ideal solution here is to get inference working for the
loopy words.  (In the meantime you can select and execute their
definition text directly.  That's not (yet!) type-checked.)

Nearly there maybe, maybe not.

Moving right along.

A little clunky but it seems to work so far.

So fra, so good...

i got used to it, but Jupyter likes 4

in the middle, just want to 2ify my indents...

TextJoyType and inscribe command.

I took the plunge and added the meta-command "inscribe" to the library.
This is, of course, a very dangerous and powerful command.  Use it
wisely.

A few more stack effects.

expectations_of_definition() and some helper infer funcs.

More stack effects, and modify the key bindings.

Update docs.

Make sure we've got all the docs, etc.