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.

Fix bugs

Type checking e.g. sum or product.
Any type accepts complex numbers.
Lots of the math functions now just use Number rather than more specific
poly-types.

That "fix" wasn't a fix.

It broke other stuff.  What I really wanted to do was change the stack
effect of 'clear'.

Fix up stacks for type checking.

Sometimes (e.g. 'clear') the () at the end of the stack was tripping up
the unify() function.

Some integration with Type Checking.

Now the UI highlights commands and numbers as you move the mouse, numbers
are blue, commands that type-check are green, commands that fail to
type-check are orange and will not be interpreted, and if there is no
stack effect information available for a command it is grey but you can
still attempt to execute it.

You can still evaluate whole expressions by selceting them and
right-inter-clicking before you release the left button, or by putting
the cursor on a line and typing ctrl-enter, which will run the whole
line.  These expressions are NOT (yet) type-checked.

Much globals. Wow.

Minor cleanup.

Move load_stack() to StackDisplayWorld.

Move StackDisplayWorld into world.py

Move reset() to text method.

Rearrange some other stuff.

Correct some typo

I accidentally pasted or something.

Move init_text() to Text method.

Split some code into a utils.py module.

Minor cleanup.

Improve the behavior of the World.

Partial harmonize key commands.

Fix bug cut instead of copy.

Updated manifest file.

It's time to bring in the GUI.

Minimalist (not to say Brutalist) UI based on text windows and mouse
chords.  Experimental.

Temporarily ignore the test dir.

It's mostly just notes and crap so far.

Module dependency graphs.

Made with Snakefood and Dot.  I'm going to have to come through and clean
these up eventually.

A little more bit o' docs.

A bit more docs.

A little more documentation.

Ah, Symbols.

Unicode in docstring.

ifte as definition; "fork" combinator.

Clean up.

Adding support for type checking.

Another definition for while.

Minor cleanup.

Renamed update() to reify() and reinstated recursive substitution.

Extra logging and another lil test.

Hmm.

I think update() should be done better...

Type inference of Joy expressions.

More remains to be done but it seems to work.

Gotta update() expression too.

If type vars get into the espression you have to keep them in sync with
the unification or you can lose information.

Some combinators can put symbols on the expression, you have to convert
those to type checkers or, as a hack, just look them up and run them.
This lets definitions work(-ish), ...

Minor cleanup.

Minor edits.

don't compose lits

It forces the identities of lits to change during relabel().

I think we still have to update() the expression to track changes in the
F function stack effect or we risk losing assoviations between type
variables in the stack effects and type variables in the pending
expression.  Hrmmm.

Trying to add a guard to combinators.

So they can notice if they're given a stack that doesn't match what
they're expecting.

This seems to work, but I realized that type variables in the pending
expression need to be update()'d too.  hmm...

Minor edits.

Dropped some HTML docs somehow.

Type checking, initial work.

Fix a couple of bug in Kleene Stars.

...and some minor cleanup.

A bit more text in the Types notebook.

It's still pretty drafty.  I'm working on the code and then I'll write up
the last bit of docs.

Some more tests.

Damn thing seems to be working.

Change name of kav() to infer().