Recent discussions with Dominikus about Concatenative Languages

A _lot_ of topics have been covered. I think this counts as the most
exciting discussion I've ever had with anyone on the topic of
concatenative languages. Such intensive discussions tend to drive you
right to the center of your ignorance.
I'm going to try to list what I've learned, relative to my own
endeavors:
* It pays to distinguish 3 kinds of Joy machine variants: linear
with intensional quotations, nonlinear with extensional
quotations and a staged linear/nonlinear version with extensional
quotations and linear run-time code structures (continuations,
compositions, partial applications, ...)
* Continuations and tasks deserve to be treated as different things
in a concatenative stack language. The former doesn't include
the parameter stack (partial continuations are stack->stack
functions) and the latter does.
* Phase separation is important: intensional code quotation is
difficult to specify other than a VM with late binding. Static /
early binding helps here.
* The pattern matching approach in Staapl isn't so bad. It would
be nice to find a more elegant rewriting _syntax_ for it, but the
semantics seems to be just what I need to get the desired compile
time reductions. Generalizing the rewrite semantics seems to
open up a can of worms. However, it might be beneficial to do
this for _optimizations_ since the interesting ones they tend to
be non-confluent.
Then, about what I don't understand (warning: buzzwords):
* The link between stack languages and other state threading
mechanisms. The key ignorance seems to concentrate on Monads,
Monad transformers and Arrows.
* How to use the above pure functional description to build a lazy,
typed, partially evaluated system.