The same idea - allowing a procedure to get either a reference to a value or syntactic description of the value coupled with the dynamic environment from the procedure call-site - is implemented in Io language.<p>Io is a purely OO language influenced by Smalltalk and Self the most; it has only objects and no classes, objects have named slots which reference other objects (some of which are "activatable" - callable, IOW - and they're then called methods) and all computation happens by sending messages between objects. If a message name corresponds to the slot name which holds a method, that message send (by default) results in the method being called.<p>Messages are just objects, which carry both dynamic environments from the place they were sent and the arguments, which are passed as message objects themselves. The method may then choose to evaluate some of the messages passed as arguments or not; but it can also change the messages before evaluating them, as the Message objects are mutable and respond to many of the same messages that Lists respond to, including `setAt(idx, val)` for example.<p>(One tricky part of all of this is getting the relation between Message objects and message-sends in Io. In short, Messages are objects which have target, name, and a list of arguments. These objects can be both serialized into, and read from a string, in which case they look like this:<p><pre><code> target msgName(arg1, arg2, ...)
</code></pre>
The place in program <i>text</i> and the <i>lexical</i> environment at that point is a <i>message-send</i>, while Message is a runtime representation of that message-send and it references <i>dynamic</i> environment at the point of call.<p>And BTW, in the syntax of message-send above, both `target` and `(arg1, ...)` are optional. In Io, code like this:<p><pre><code> 1
</code></pre>
is, in fact, a message send with `name` set to `"1"`; it's first sent to the current `this` object, and then bubbles up the inheritance chain to `Object`, which handles the message by returning a Number object with value of `1`.)<p>The effect is really interesting: the language is incredibly expressive, with metaprogramming support rivaling Lisp (Io is also homoiconic), but with a very different set of metaphors/concepts it's built on. It could be more approachable for normal devs (than Lisps), as its syntax is arguably closer to the mainstream, and the OO metaphor is widely known (although not really understood in a way Smalltalk, Self or Io understand it).<p>Anyway, being able to write functions which can decide whether they want, and how exactly, evaluate their arguments is a powerful technique. I think REBOL and Red are also able to do this, and I think TCL too. Factor would also count, probably. It's a shame it's not supported in more mainstream languages - may be hard to implement efficiently, or may not be that useful with non-homoiconic languages or something like that.