Em Qua, 2010-04-21 às 00:16 -0700, Stefan O'Rear escreveu:
> Normally, when you write a method call, the definition of the method is
> entirely in the domain of the receiver's class:
> $object.make-me-a-sandwich; # $object gets to decide what this means
Actually, this is delegated to the dispatcher, which is composed in at
least three different parts:
1 - The general dispatching mechanism which iiuc, is lexically
defined and which, by default, implements something like:
@*current_invocation_candidates = $object.^can($capture);
@*current_invocation_candidates.shift.postcircumfix:<( )>($capture);
2 - The MRO resolver, which is implemented inside ^can, and is
completely internal to the class.
3 - The actual routine invocation, which is internal to the actual
method object.
> However, this is not always how things work.
> $object.WHAT; # Larry says that WHAT should return the protoobject
> WHAT, WHENCE, postcircumfix:<[ ]>, and similar operators have semantics
> (although not implementation) defined by the language itself.
Actually WHAT, WHENCE and the like are considered macros, not method
calls.
Postcircumfix:<[ ]> is actually an operator, not a method, so they are
always lexically dispatched.
> Currently, Perl 6 fakes this by having all values inherit from Any or
> Mu or Cool, which define the basic, overridable versions of these
> method-like operators.
Hmm... I never thought of it as a fake, it's a simple fact, every value
in Perl 6 should derive from Mu, every non-special type is derived from
Any.
> This cheat actually works pretty well in a homogeneous environment,
> but it fails if we have to consider objects from outside Perl 6.
> $parrot-array.WHAT; # Method WHAT not found for invocant of type ...
This is actually a rakudobug, a $parrot-array should be properly boxed
into a value that provides a protoobject... Again, .WHAT is not a
method.
> The problem here is that scopes are conflated - WHAT is defined by the
> language, which is approximately a lexical scope, while methods on an object
> are in some entirely different scope.
AFAIU, method dispatch is also lexically controlled - to some extent.
> A methodical is an operator which syntactically behaves as a method but is
> subject to scoping rules. Methodicals are defined using the ordinary method
> keyword, qualified with my or our. (TODO: This seems the most natural syntax
> to me, but it conflicts with existing usage. Which is more worth having on
> it?) Methodicals do not need to be declared in classes, but they should
> generally have declared receiver types.
> Thoughts?
Apparently you're trying to override the default dispatching mechanism
which, I think, is something already supported by Perl 6 (although not
yet fully spec.
daniel
