Something like

foo('+')

foo(';')

foo('++')

which can be compiled to something like:

let a_0(s1, s2) = s1 + s2
in foo(a_0)
end

note that this is related to lambda strategies. It might look weird now, but it is actually quite natural as soon as we have lambda abstractions.

If we have lambda abstractions, it can be compiled to:

foo( lambda (s1, s2) = s1 + s2 end)

Not sure if this is really a good idea, but it might be useful and attractive.

Submitted on 21 May 2004 at 11:54

STR-95, martin:
Oh, this idea is inspired by:

global choice over static Foo rules

Foo : a -> b
Foo : c -> d
Foo(++)

global choice over dynamic Foo rules

rules(Foo :+ a -> b)
rules(Foo :+ c -> d)
Foo(++)

bagof(Foo(++)) returns all possible applications. We also need a combinator for scopes (bigbagof and bagof).