Sun Sep 6 09:07:07 CEST 2009

Other abstract values

It looks like it's necessary to allow general purpose computations at
compile time (i.e. full elimination of rules).  This would allow the
introduction of `amb'.

Note that backtracking will probably need a state-threading approach
to the code generation problem: the current assignment-based approach
is probably a dead end.

Hmm.. this is definitely not going to be a simple example.  I guess
it's best to separate out the DFL implementation.

The useful directions seem to be:

  - eliminate implicit code threading (pure functional generator)
  - learn more about constraint propagation

It would probably also help to read Jacques Carette's paper[1] about
monadic generators.  Once the generator is purely functional,
backtracking can be added.

Instead of a synchronous networ approach, it might also be interesting
to directionalize equations from the pov of a single variable to its
dependencies.  The concept of finding abstractions that allow staged
control flow is apparently a bit more broad than I first thought.

In my first approximation of understanding, constraint propagation
seems to exploit the sparseness of systems to yield local inversion
which can then be chained.

OK. Pure functional generators.  Two kinds of effects need to be
eliminated:  value assignment and code `emit'.  The latter can simply
thread the state, while the former can use a node -> value finite
function to be passed around.

For backtracking purposes, it seems possible to combine parameters
with partial continuations as long as the parameter values are
saved/restored upon continuation capture/invokation.  The _values_
stored in the parameters however need to be sharable: the current
in-place update doesn't work, and needs to be replaced with something
purely functional.

Let's see..

[1] http://www.cas.mcmaster.ca/~carette/publications/scp_metamonads.pdf