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

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

> 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

> 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.


Reply via email to