Mon Aug 31 14:14:50 CEST 2009

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

   * 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.