Hi Martin:

I have been studying Scala based on the impact it has made. 
Congratulations to your successful language design!

I have a PhD student, Bryan Chadwick, who is interested in
functional object-oriented programming. He has developed a technology,
called AP-F, which supports functional programming with traversal
control and an implicit invocation style of programming.
Currently we have two implementations: one in Java (called DemeterF), the other in Scheme.

I think that AP-F extends your work on integrating functional and object-oriented
language in a direction that is utterly useful. That is why I bring AP-F
to your attention. I see a synergy between Scala and AP-F.

I will be in Switzerland from July 2 to August 19 and would like to visit 
you and give a talk if you are interested.
http://www.ccs.neu.edu/research/demeter/talks/abb/summer08/abstract

A small demo is attached.

Best wishes,
-- Karl

We found your blog where you use Scala to demonstrate expression simplification:
Here is the code for DemeterF. simplify(Term t) does one traversal through
the object doing deep (recursive) pattern matching. 
We use multi-methods instead of pattern matching.

Classes:
The complete example is here:
http://www.ccs.neu.edu/research/demeter/talks/eth-lausanne/odersky/

  Main = <term> Term.

  Term: Num | Var | Mul | Add.
  Num = <n> int.
  Var = <id> Ident.
  Mul = "(*" <l> Term <r> Term ")".
  Add = "(+" <l> Term <r> Term ")".

simplify method in Java:

     static Term simplify(Term t){
        return new Traversal(new Bc(){
           class Zero extends Term{}
           class One extends Term{}
           Term combine(Num t, int i){
               switch(i){
               case 0: return new Zero();
               case 1: return new One();
               default: return t; 
               }
           }
           Term combine(Mul t, One l, Term r){ return r; }
           Term combine(Mul t, Term l, One r){ return l; }
           Term combine(Mul t, Zero l, Term r){ return l; }
           Term combine(Mul t, Term l, Zero r){ return r; }
           Term combine(Add t, Zero l, Term r){ return r; }
           Term combine(Add t, Term l, Zero r){ return l; }
        }).<Term>traverse(t);
     }