Add definition for xor.

Working on the notebooks.

Updating notebooks

to not use Jupyter because I can't figure out how to use the Joy kernel.

Working on the website for Thun.

I'm going to eventually update the old Sphinx-generated site on OSDN.

cleanup

Put this over there.

Minor edits.

Messing around with type inference.

What if we insist that both branches of a branch have compatible types?

For one thing `[+] [* +] branch` leads to a circular term which, when
printed, goes into a loop: "int,int,int,...".  Hmm...

for-each

A crude main loop.

I know there are better ways to do this, but I don't know what they are
yet.  Maybe a "do" loop?  Anyway, this works, although it doesn't catch
errors yet.

Minor edit.

Little updates to the spec doc.

Minor edits.

Update defs.scm

Merge in the test suite.

Why not?

(I have a slow tide, expand into pieces, contract into units, and back
again.  This is part of a contract and unify phase.)

Math ops, definitions for left- and right-shift.

mul div mod add sub in Nim

first rest

concat cons comparison

loop

branch and refactor simple functions.

The refactor should be a macro but I don't know how to write those yet
(apparently there are different macros systems...  ooo la la!)

dip

i

swap

pop

stack, swaack

Add copyleft notice.

Load defs at compile time.

I don't really know the proper way to do this, but I managed to whump
something up.

Evaluate definitions.

Convert defs.txt to defs.scm.

Gonna need a makefile.

Load defs from defs.txt.

They are loaded at runtime though :(  shouldn't be too hard to fix that?

A start on dictionaries using srfi-69 hash tables.

Use '->' in names of functions that convert values.

dup

minor edit

It's more efficient to concat the empty list

than to concate a non-empty list onto the empty list.

A start on simple functions.

I'm sure there's a cooler way to do this, but it works.  (This is my
first Scheme code.)

Parser emits errors; joy

joy-expression-to-string

text-to-expression

It's Joy.

Or will be soon.

Parser.

Scheme, eh?

SWIProlog can't not emit '.'.

I would like the GNU Prolog and SWI Prolog versions to be compatible, if
possible.

SWI has bigints, GNU doesn't, so that's a wrinkle...

Thread the dict through the interaction loop.

Like a total newbie I put the call to the interpreter in the view
function instead of the update function!  I thought it was weird having
to specify the HTML twice, but I figured I was just doing it wrong.  I
was, but not in the way I suspected.

In any event, I like how this make it clear that errors can't affect the
dictionary.

Checked old defs.

I forgot `over`!

Talk about symbols on the stack.

A spec doc for Thun.

It's not very good yet, or formal, "but it's mine and I love it."

_isnt_bool _isnt_two_bools

These probably won't last?

minor edits

Elm README.

And minor edits.

minor edits

minor edits

minor edits

Oops, that is not a definition of `first`.

Minor edits.

Minor edits.

I think I have got it.

egad

weird symbols in table

mdtableeeeee

MD TABLE!?

Sort out the and/or/... ops.

Crude type checking.

I forget why I was doing "not not" so I made it a little more clear.  In
practice this is regressive:  The built-in "isnt_bool" function should
be in the dictionary?  Or prohibit type checking and let the bugs flow?
Rely on inference to prevent bugs that would pass the non-checking
versions of the functions?  Hmm...

Name Boolean ops.

So they don't overshadow the defs for the short-circuiting combinators.

Error type (not just a string.)

This is mostly for fun, but I bet it comes in handy, eh?

At the very least, it's a nice catalog of the possible errors that the
basic Joy system might encounter.

type alias JoyFunction

Format.

inscribe, definitions.

Initialize dict with defs.

Just sqr for now, but it shows that it works.

I would like to return Results from add_def but it makes using foldl
slightly tricky,  not a lot, just slightly, and my brainpower is low at
the mo'.

Look up words in the dictionary.

If they are not built-in, which means you can't "shadow" built-ins with
"inscribe", which may or may not turn out to be what we want?

Thread the dictionary through the call stack.

Empty string is not an unknown word.

Gotta keep a Dict around.

Logical ops.

Left- and Right-shift.

Comparison ops.

loop

branch

dip

i

truthy

I have to check into this: the Python version has "bool" and no
"truthy".

swap

stack, swaack

pop

first, rest

dup

cons

clear, concat

Minor cleanup.

Type alias JList

Refactor pop_int.

I don't like passing the stack through isnt_int but that let's you chain
with andThen.

There's probably a clever or idiomatic way to not do that and couple the
stack to the result without passing it through the type checker function
but I don't know what it is right now, and this works.

Binary Math Ops

I don't think andThen helps here?

I can add integers!

Parsing working.

Modeled on the OCaml code.

A start on Joy types.

In Elm.

Use Python as SHELL in Makefile.

It's a simple task, but I'm not up on my CLI tools, so I went with
Python instead of sh.  The split command doesn't have '-p' switch on
Ubuntu.  (I'm using Ubuntu on this laptop because it can correctly
configure the WiFi and the laptop has no ethernet port.)

minor cleanup