minor edits

A little BTree.

Persistent (immutable) datastructure.

A start on error reporting.

I outfitted `rest` with some error reporting and tried out exception
handling.  So far so good.

One issue is that the dictionary is not a persistent datastructure, so
if there was an "inscribe" command (it's not yet implemented for this
Scheme implementation) that might be slightly problematical.  (If an
error were to occur in an evaluation that had already entered new
definitions into the dict then those definitions would "survive" into
the rest of the REPL session (or whatever.))

I'll look into persistent dict for Scheme.

Use Scheme symbols for Thun symbols.

It seems more elegant that way, but I haven't tested it to find out if
it has better performance or memory usage (yet.)

Symbols for symbols.

This shouldn't work yet, because the parser makes Lisp symbols out of
the Thun symbols, but the match expr still has strings.  In the REPL
this fails, but in the compiled Joy binary it doesn't fail, the
interpreter interprets just fine.

add defs for select and small; cleaner joy-func.

A little more match.

Use match a little more.

Use match instead of cond.

Minor indentation change, a typo.

Remove global stack, dict.

Pass them through the recursive loop instead.

Put a bang on add-def.

Some edits.

min and max

Some edits to some notebooks.

Run MAKE.

Derive `zip`.

Nerd Sniped

Great progress!

More work on Ref doc, & stuff.

Implement `bool` and trace for Scheme.

Take the right number of things off of the stack.

Nerd sniped by a silly function.

Minor edits; rebuild docs.

Print out wobbly words.

That have definition but no ref doc, or ref docs but no defs.

Use slightly smaller font files.

Minor edits.

Tidy?

A little more work on the ref doc.

Mark combinators.

Build the ref doc.

Put interpreter on pages.

Give it it's own CSS file.

It's good enough for now.

remove the individual md ref files

Minor edits.

Div, mod handle zero.

Typo.

Elm reformatting and demo HTML page.

Change definition of uncons.

Use blob URL.

Add grammar image.

Made with https://jacquev6.github.io/DrawGrammar/

Elm version using BigNums.

This went pretty smoothly, I just followed the compiler errors after
substituting Integer for Int in the type definition.

The only tricky thing is that the div and mod functions for Integer
return Maybe Integer rather than just Integer, so I need to wrap those
or something?  (For now I just put in add to get it to compile.)

Oh, and "not equal" is not correct? The compiler didn't complain.

Let's use bignums.

Don't use andThen.

It's less clear than spelling it all out.

Chaining with andThen works but is ugly.

It's lees clear to me what's going on, and I wrote it.

I think Scheme?

Rebuilt C.

Compiling Thun to Python.

Not all of the words that compiled with the old defs.txt compiled with
the latest, so we're keeping the old one in here until I can trace down
the issues.

pow

Update Nim defs.txt.

Simple linear power function.

THe old compiler-to-Python.

Rename BigNums.

Add a README to the docs/ dir.

Test calling dip on non-quote.

I just realized these all refer to the old package organization.

Better exceptions.

Example of infra evaluation.

Note on Variations

Minor edits.

Rebuilt C interpreter.

Finished up Generator_Programs.md

README for Chicken Scheme.

sort

Some scratch source

from editing BigNums notebook.

Figlet headings.

Minor CSS changes.

Edits on BigNums notebook.

About 2/5ths done.

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?