The p6opaque Responder Interface is the default responder for all Perl 6 objects.
Composition
This is a hard topic in Perl 6, as compositions are mostly unpredictable (unless the class is closed). This way the composition is made with a "composition pile", where every composition operation is put in order, allowing correct method resolution. But the declarations in a class always override any composition declaration. That way, a prototype have:
- The composition pile (in order of composition)
- At compile time the order is:
- inheritance (reverse of the specified order)
- roles (in no particular order)
- At runtime the order is
- when composing with "is", it unshifts the pile
- when composing with "does", it pushes the pile
- The submethods
- The methods
- The attribute list (used during BUILD)
- Class storage
- each slot represents the class attributes' values
So the method lookup always:
- Looks for a member of the class
- goes bottom-up in the "composition pile" looking for the member
Private member lookup always:
- Look in the storage space for this class in the object
- Look in the class storage
An object, on the other hand, have
- Storage space for each participant of the composition (including the class itself), where each participant only sees its own space.
- each space contain slots for the attributes defined by that participant.
And an object that can autovivifies have:
- WHENCE closure to autovivify this object.
p6opaque Structure
Putting this all together, we get to the following structure that every object, defined or not (in which case it is a prototype), have:
- metadata
- package
- direct prototype = Foo
- composition pile
- is Foo
- does Bar
- class storage
- $!foo = 1
- $!bar = True
- class definitions
- class attributes
- my Int $.foo
- my Bool $!bar
- instance attributes
- has Int $.baz
- has Bool $!buz
- methods
- method foo() is rw as Int { ... }
- submethods
- BUILD { ... }
- WHENCE
- instance storage
- $!baz = 1
- $!buz = True
The "direct prototype" and the "composition pile" are mutually exclusive members of the object metadata. When an object have simply an "is" in its composition pile, it can be optimized to "direct prototype", which means that the return of WHAT will be that prototype, otherwise the return for WHAT is the object itself.
If an object have empty storage, it's a protoobject, if it have a WHENCE it can be autovivified. A normal object will have only a "direct prototype", on the other hand, it might also have other information, which makes it a self-contained object that is its own class.
Every object returns a different return to HOW. HOW modifies the object, not its prototype. $foo.^add_method(...) is not the same as $foo.WHAT.^add_method(...)
