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

minor cleanup

Rename joy_to_ast to parser.

Working on the docs.

The nbconvert tool has different behaviour now, so the HTML versions of
the notebooks look different.

Minor work on the new site.

I'm moving away from OSDN, there have been a few technical issues
recently.

Bold.

Minor edits.

the BinInt zero vanished?

Minor edits.

Working on README, put defs in joy.py

I'm on an Ubuntu system right now and the split command doesn't have the
'-p' switch.  :(   I wasn't happy with that janky solution anyway.

minor edits

Minor edits.

Messing around with GNU Prolog.

I have it broken up into three stages: a parser that reads a string from
stdin and emits (Prolog) AST to stdout; an interpreter of sorts that
reads AST from stdin, evaluates it, and then emits the AST of the stack
on stdout; and a printer that reads AST on stdin and prints Joy-ish code
to stdout.

I say Joy-ish because currently math is not evaluated and results of
math appear as expressions, not values.

This is because GNU Prolog doesn't have unbounded integers (it's numbers
are machine integers) so literals that are larger than the machine word
are converted into atoms!  To keep things simple, I made all ints into
atoms, but then you can't evaluate them: '1'+'2' is not '3' (it might be
'12' though.)

So I print them out at expressions:

    $ echo "1 2 3 4 [+ sub /] i" | ./joy_to_ast | ./thun | ./printer

    (1 div (2-(4+3)))

You could almost feed that to, say, Python to evaluate, eh? Or dc with
proper formatting?  (man dc; "Desk Calculator".)

Anyway, it's a start.  The Prolog interpreter is more for things like
type checking and inference, optimizing, compiling, etc.  Symbolic stuff
that's a PITA to express in other languages.  (The old type inference
code in Python was pages long, in Prolog it's just the thun/3 & thun/4
predicates themselves.  At least so far.  There are things we will want
to do eventually that might be a PITA to express in Prolog, eh?

Compile on Ubuntu.

Make it compatible with Xerblin.

Minor edits.

Minor cleanup.

i combinator.

On a lark I implemented it in recursive style, but I'm not going to keep
it that way.  I have to implement next_term() first and then I'll
uncomment i_joy_combinator().

concat

cons

minor cleanup

first

rest

rest CANNOT_TAKE_REST_OF_EMPTY_LIST

swap

Check for error after cons'ing term.

pop_any()

dup

stack function.

pop()

Move pop_list().

No reason to pass expression to function.