Re: Injecting names & method chaining (was Re: [ANN] Penlight Libraries, First release)
David Manura <dm.lua <at> math2.org>
2009-05-02 03:31:48 GMT
On Fri, May 1, 2009 at 12:48 PM, Mark Hamburg wrote:
> With regard to injection, it's interesting to look at Michael Franz's paper
> on Protocol Extension.
> Essentially, he uses the module system in Oberon to avoid name conflicts on
> In the context of something like the method chaining wrapper,
> one could write:
> local stringx = require "stringx"
> S " test " : [ stringx.trim ] () ()
> (This assumes a Lua extension to support calling methods identified by
Such a patch does not in itself allow us to write the expression how
we might really want to:
(" test "):[stringx.trim]()
But we can achieve it if we allow an adjustment to the string metatable:
debug.getmetatable"".__index = function(self, k) return k end
or even without patching,
debug.getmetatable"".__index = function(self, k)
return string[k] or function(...) return k(self, ...) end
return (" test ")[stringx.trim]()
This does, however, lead to the curious behavior that s[v] ~= nil for
all values v and strings s, unless we add further conditionals. In
Lua, unlike some other languages, calling a method on an object is not
an atomic operation (passing a message) but is defined in terms of an
index and a function call. s:v(...) is syntactic sugar for s["v"](s,
...). This imposes restrictions on what we can do with the index
operator (e.g. method s:v exists implies that s["v"] ~= nil).
I also thought it was convenient in the MethodChainingWrapper that the
namespace for operations was held by the wrapper. Instead of the
above, where stringx.trim is a variable defined outside of the
expression, the operation names are localized to the call chain
expression by the wrapper:
-S(" test "):trim() -- "trim" is a method in the namespace "S"
There may be uses for both approaches.
Maybe the better solution to all this, in a Lua context, is to use
something other than method calls to do the operation chaining.
Execution-wise, we simply want to do
m.h(m.g(m.f(x, p...), q...), r...)
-- for argument lists p, q, r, and operations f, g, h in module m.
Syntax-wise, we'd like a less awkward form of expression, including
one that perhaps defines some automatic namespace lookup for the
Patching the parser or applying Metalua would allow an equivalent syntax like
x chain m : f(p...) : g(q...) : h(r...)
(" test ") chain stringx : trim() : repeatchars(5) : upper()
Or in standard Lua, we could write a helper function like
chain(stringx, trim, 1,repeatchars,5, " test ")
where a number before an operation name (e.g. 1 before repeatchars)
indicates that the operation takes that many number of arguments.