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.

Create an int and add ints.

Try using GC_register_finalizer?

Maybe this is the right thing to do?

https://stackoverflow.com/questions/59489221/using-the-gmp-library-with-boehms-garbage-collector

What would a little C Joy look like?

Let's use GMP for ints and Boehm GC.

Wait for both results together.

If one causes an error before the other is finished SIGKILL the other
job.  (I do not know if this will kill the sub-tasks if any.  The Python
docs say that with terminate() "descendant processes of the process will
not be terminated – they will simply become orphaned." but it doesn't
say whether that's true with kill().

Capture and fwd exceptions in subforks.

(Should there be only one subtask?  Do the other quote in the main
proc?)

Let's play with more cores.

Basic system, incomplete.

Still needs the rest of the core functions and defs.
Could read defs from a file at compile-time?
Integer math?  Boolean ops?  Just type inference and maybe compiling?

Parse the tokens into a Joy expression.

Parser in GNU Prolog.

Wonky handling of UTF_8 blankspace.

The whole thing is kind of a mess.

Let simple joy be joy.

Still to do: clear away the rest of the old cruft.

Remove cruft.

Minor cleanup.

Add trace word back in.

Remove pretty_print module.

Still to do: update Nim implementation with a trace function. ;)

Fix typo in hyperlink in README.

Minor cleanup.

Add a flowchart for the interpreter.

Using PlantUML.

Fixed bug in appN

while updating some Jupyter notebooks with the Joypy kernel.

Remove old docs.

A bit more docs.

Got back the LI for lower-cased title notebooks.

Not sure what went wrong there.

Whence fun_with_scan and with_sympy?

Cleaning up docs.

Kinda...

The (crude) site.

It's funny that I'm using nbconvert, markdown, pandoc, tidy, and of
course python, all to make a simple static website...

"There's got to be a better way!"

Function Reference

 bits and pieces

Rework docs, simpler (no Sphinx.)

delete all the extra notebook conversions

Ignore the Nim joy binary.

Check for minus before converting to int.

BigInts converts "-" to 0.  This happens in the parser before you get to
the evaluator.

Minor cleanup, subtraction.

Testing with the joytest test suite revealed that I had forgotten to
implement subtraction.  This also unconvered a (maybe) bug in the
BigInts package where it converts "-" to zero.

https://git.sr.ht/~sforman/joytest

https://github.com/nim-lang/bigints/issues/116

Let simplejoy be joy.

Simple pleasures are the best.

Remove old code.

Read defs.txt at compile-time.

I'd like to build the dict datastructure at compile-time too but I'm not
going to figure that out tonight.  It's enough that the defs are
embedded in the executable.  (You can see them with the strings utility.)

basis complete

dup, first, i, loop

dip and cons

Rewrite expression to use list instead of list node.

Minor cleanup.

Reuse as_list().

Cleaning up the code.

Nimpretty reformat.  Two-space indentation.

Minor cleanup

Let's pile Nim code into one file too, why not?

divmod

We don't need floor if we have only ints.

Id is too easy as a definition.

divmod is cool.

step, times

dipd, dipdd, cmp

cond

updated defs via make

dunno what that was

Bringing over some of the "upgrades". 2

Bringing over some of the "upgrades".

id func

clearing out cruft

minor cleanup

Put definitions in the docstring.

Why not? ¯\_(ツ)_/¯

Model expr as stack-of-stacks, minor cleanup.

Don't bother to return the expression.

We mutate it instead of replacing it with new versions.

Cleaner iteration of expression.

It's a destructive operation.  It breaks functional purity (but it could
be made functional by using a stack instead of a list for the stack.)

There's no point to returning the expression object now because it's
being mutated by the prepend() method (rather than being replaced by new
forms.)

over

This slipped through the cracks, eh?  Should add a test to joytest.

No point in a separate _parse() function.

Simpler tokenizer.

Once the syntax was simple enough the re.Scanner became overkill.

From
http://norvig.com/lispy.html
by way of
https://github.com/ckkashyap/s2c

A bit more docs.

Move ParseError to parser section; add a few type guards.

Minor cleanup.

Expression objects.

This should be more efficient than concat().

blacken

move stack code up under interp & minor edits

make type checks into Joy functions