Simple terms work. Problem is with sub-lists.

Parsing isn't this hard?

Um, don't do that.

I wonder where the data was winding up?

Minor cleanup.

Remove separate parser code.

Print true, false, and lists.

Print ints.

Print list.

Text to expr coming along.

Need to be able to store a string.

Minor cleanup.

Minor cleanup.

Don't pass NULL to strpbrk().

Handle stretches of blanks.

Don't create zero-length strings.

Nice skeleton of parser.

Almost there on parsing.

trim_leading_blanks

Let's parse.

Don't version the binary.

I think I'm doing this right?

minor style glitch

Minor cleanup.

Some notebooks.

Messing around with C.

Readline support would be nice.

This and that.

Cleanup and refactoring.

Bug when subtracting identical numbers.  It gives

    [false 0]

When it should be

    [false]

or better yet

    [true]

eh?

That seems to work: addition and subtraction.

Mostly done with addition and subtraction.

Not quite as smooth as I'd hoped.

Subtraction seems to work now.

Progress.

Adding like-sign bigints in Joy.

Misc stuff.

Minor cleanup.

Add two lists of digits.

I think I got it.

Whew!  Think slow and steady FTW.  Don't get ahead of yourself.  Put the
non-recursive parts in the non-recursive branch, duh.

Dang it...

Minor cleanup.

Just for me...

(That's how you look all clever, but it's a dick move removing the
commentary like that.)

Bisect for the win!

find_greatest()

I think it's ready to use...

Finish lil_divmod.

One more lil bug squash.

Subsidiary functions...

Fuzz FTW.

Div Mod of same sign ints.

That seems to be that.

Flush out and squash some bugs.

I think I figured something out...

Kinda sorta not really working,

as in broken.

This is getting out of hand.

Almost got it...

Divmod, yeah?

Minor cleanup.

I almost can't believe I did it.  I guess I thought it would be harder
or more involved.  Maybe divmod will be a pill?

Kinda relaxing after wasting the weekend nerd-sniped by curses.

Copyright and executable bit

Minor cleanup.

Minor cleanup; multiplication.

I forgot to commit after cleanup but before implementing multiplication
so this commit is kind of a mess.

Anyway, it works.  :D

test_Subtraction_large_from_small

I guess subtraction works!?

Adding two negative numbers.

That was easy!  Add BigInts of the same sign.

Red... (Green, Refactor)

TDD FTW!

Not using ctypes; test_twice_min

Minor cleanup.

Fix import.

BitInt start; unittest.

That was easy...

but it breaks associativity or is it commutivity?

Anyway you can't add THREE or more things in one expression (yet)
because adding OberonInt objects returns a two-tuple.

I could adjust the semantics of ObInt to accept such two-tuples and do
add_with_carry() but that's probably more trouble than it's worth.

Just gotta be careful with math expressions, eh?

Switch to double-underscore method names.

Worry about type conversions later.

Subtraction.

BigInts in terms of Oberon Ints

Oberon RISC has Two's Complement 32-bit ints with carry.

So far so good.

Minor cleanup.

Minor cleanup.

Functional Programming FTW!

Apparently this is redundant.

Discovered by running `nim doc joy.nim`, compiling doesn't flag it.

Clear out old docs; update defs.txt.

I had to model it in Python

before writing it in OCaml.

Improve compiling of step combinator.

Initial outline for a talk on Joy.

coms, swap

Comparison operations.

branch, dip, i, loop

The core combinators (except fork).

Minor cleanup.

Simple REPL.

Still very crude, and exceptions are not caught, but it works.

Minor cleanup.

concat

Ocaml's match is very powerful, respect, but if I want more precise
error messages (that conform to the joytest suite) then the extra
utility functions must be implemented and employed.

After that it's definition loading and the main REPL loop and I think
that's it, eh?

autoformat

clear

Autoformat.

Evaluation is working.

It's all downhill from here, like in skiing!

Eval symbols...

Working towards interpretation.

Nice and clean.

I wonder what Ocaml programmers would think of this code?

Parser.

Mighty battle.

Order is preserved.

A couple of little comments.

Parse tokens into joy_list.

That seemed a lot harder than it should have been...

A start of parsing tokens.

Formatting.

I think I got the tokenizer right.

So that's mutual recursion in Ocaml?

I like it.  Just change "let" to "and" and you're good-to-go.

Ignoring _build.

Ignore _build dirs.

autoformat

Ocaml FTW!

At this point...

...I'm just relearning C semantics.  (And they are garbage, as is widely
known.)

I don't think there's much point to this (at the moment) because I don't
want to relearn C (at the moment) and Nim is available (at the moment.)

Really, I'm trying to do away with the entire relationship of C et. al.
to the underlying machine.  (For instance, Nim gives you a much nicer
relationship, without the vast distance that, say, Python imposes.)  I
should really look at other compiled languages, like Ocaml or Julia.