develooper Front page | perl.perl6.language | Postings from September 2005

Regarding Roles and $?ROLE

Thread Next
From:
Stevan Little
Date:
September 10, 2005 17:48
Subject:
Regarding Roles and $?ROLE
Message ID:
9A445932-490D-4F7F-8865-5DA3A5ABEF57@iinteractive.com
Hello all.

I have some questions about how Roles will behave in certain  
instances, and when/where/what $?ROLE should be bound too.

1) Given this example, where 'bar' is a method stub (no implementation)

role Foo {
     method bar { ... }
}

Should the eventually implemented method still have a binding for $? 
ROLE?

2) When a Role itself has subroles, which are composed together and  
consumed by the parent Role, how is $?ROLE bound? is it the top-most  
Role which it is bound too? or is it bound to the Role it originally  
came from? Here is an example:

role Foo {
     method foo { $?ROLE }
}

role Bar {
     method bar { $?ROLE }
}

role FooBar does Foo does Bar {}

Given this code, does FooBar::foo return FooBar? or Foo? And what  
about FooBar::bar?

This also brings up another question.

3) Using the Roles above, what will this code do?

class MyClass does FooBar {
     method foo {
         $?SELF.FooBar::foo();
     }
}

Since Roles are flattened, I would think it is reasonable to assume  
that FooBar::foo exists. However, it does not exists in the concrete  
in-the-namespace-stash sense. Should fully qualified access to Role  
methods be mediated by some kind of proxy? Should it actually query a  
composite Role of some kind?

The easy way I think, is to say the above code will fail since  
FooBar::foo does not exist. However consider for a moment how Role  
composition works, and how flattening sort of "equalizes" all the  
methods and makes ordering unimportant. These qualities are what give  
Roles such great compositional power, and reduce the complexities/ 
issues usually associated with mix-ins and multiple inheritance. If  
you force the user to see the entire Role hierarchy, and not just the  
topmost Role, are you loosing some of that compositional power?

And lastly ...

4) If a Role has a method stub, you are in effect creating a contract  
with any class which consumes that Role. The class must implement  
that method. However, what happens if the class consumes another Role  
which implements that method. Do they still conflict? or does the  
second Role's version fufill the first Role's contract?

Here is a quick code example:

role Foo {
     method foo { ... }
}

role Bar {
     method foo { "Hello World".say }
}

class FooBar does Foo does Bar {}

Does this work? Does Bar fufill Foo's implied contract? Or is an  
exception thrown here?

Thanks,

Stevan


Thread Next


nntp.perl.org: Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at ask@perl.org | Group listing | About