Tue Sep 16 12:43:06 CEST 2008

non-orthogonal part

There's one thing that always gets in the way while explaining the
quasiquotation and pattern matching facilities central to Staapl's
metaprogramming model:

The fake algebraic type constructors perform the same role as
quasiquotation of macros.  Can the late detection of this pattern
somehow be bent into an asset?

It is an essential part, because without it, it is impossible to
create primitive code generators.

So, there are 3 important parts:

  code = (fake) algebraic data types

    * code deconstruction (pattern matching)
    * code construction

  composition: concatenative + quasiquotation
  evaluation: turn abstract (macro) code into concrete code.

The main problem is that I have no clear idea of stages.  Basically,
there are only two ``real'' stages:

   1.  The creation and composition of code generators.  Mostly based
       on higher order programming.

   2.  Execution of these.

Maybe the real idea is:

   There is no need for multi-stage programming if your metalanguage
   has higher order functions.  (Then, in a HOPL, macros can be useful
   yielding again a mult-stage language.)