Rejection Notice

This PEP has helped push PEP 3119 towards a saner, more minimalistic approach. But given the latest version of PEP 3119 I much prefer that. GvR.

Abstract

Python’s existing object model organizes objects according to their implementation. It is often desirable – especially in duck typing-based language like Python – to organize objects by the part they play in a larger system (their intent), rather than by how they fulfill that part (their implementation). This PEP introduces the concept of roles, a mechanism for organizing objects according to their intent rather than their implementation.

Rationale

In the beginning were objects. They allowed programmers to marry function and state, and to increase code reusability through concepts like polymorphism and inheritance, and lo, it was good. There came a time, however, when inheritance and polymorphism weren’t enough. With the invention of both dogs and trees, we were no longer able to be content with knowing merely, “Does it understand ‘bark’?” We now needed to know what a given object thought that “bark” meant.

One solution, the one detailed here, is that of roles, a mechanism orthogonal and complementary to the traditional class/instance system. Whereas classes concern themselves with state and implementation, the roles mechanism deals exclusively with the behaviours embodied in a given class.

This system was originally called “traits” and implemented for Squeak Smalltalk [4]. It has since been adapted for use in Perl 6 [3] where it is called “roles”, and it is primarily from there that the concept is now being interpreted for Python 3. Python 3 will preserve the name “roles”.

In a nutshell: roles tell you what an object does, classes tell you how an object does it.

In this PEP, I will outline a system for Python 3 that will make it possible to easily determine whether a given object’s understanding of “bark” is tree-like or dog-like. (There might also be more serious examples.)

Performing Your Role

class Tree(Vegetable):

  def bark(self):
    return self.is_rough()


class Dog(Animal):

  def bark(self):
    return self.goes_ruff()

@perform_role(Doglike)
class Dog(Animal):
  ...

@perform_role(Treelike)
class Tree(Vegetable):
  ...

@perform_role(SitThere)
class Rock(Mineral):
  ...

@perform_role(Guard, MummysLittleDarling)
class GermanShepherd(Dog):

  def guard(self, the_precious):
    while True:
      if intruder_near(the_precious):
        self.growl()

  def get_petted(self):
    self.swallow_pride()

>>> perform(Guard)(Robot)

>>> performs(our_robot, Guard)
True

>>> performs(that_robot_over_there, Guard)
True

>>> performs(Robot, Guard)
False

Defining New Roles

class Doglike(metaclass=Role):
  ...

class FourLegs(metaclass=Role):
  pass

class Doglike(FourLegs, Carnivor):
  pass

@perform_role(Doglike)
class Dog(Mammal):
  pass

class Doglike(FourLegs):

  def bark(self):
    pass

@perform_role(FourLegs)
class Horse(Mammal):

  def run_like_teh_wind(self)
    ...

@perform_role(Doglike)
class Coyote(Mammal):

  def bark(self, target=moon):
    pass

Mechanism

The following are strawman proposals for how roles might be expressed in Python. The examples here are phrased in a way that the roles mechanism may be implemented without changing the Python interpreter. (Examples adapted from an article on Perl 6 roles by Curtis Poe [2].)

1. Static class role assignment

   @perform_role(Thieving)
   class Elf(Character):
     ...
   

   perform_role() accepts multiple arguments, such that this is also legal:

   @perform_role(Thieving, Spying, Archer)
   class Elf(Character):
     ...
   

   The Elf class now performs both the Thieving, Spying, and Archer roles.

2. Querying instances

   if performs(my_elf, Thieving):
     ...
   

   The second argument to performs() may also be anything with a __contains__() method, meaning the following is legal:

   if performs(my_elf, set([Thieving, Spying, BoyScout])):
     ...
   

   Like isinstance(), the object needs only to perform a single role out of the set in order for the expression to be true.

Relationship to Abstract Base Classes

Early drafts of this PEP [5] envisioned roles as competing with the abstract base classes proposed in PEP 3119. After further discussion and deliberation, a compromise and a delegation of responsibilities and use-cases has been worked out as follows:

• Roles provide a way of indicating an object’s semantics and abstract capabilities. A role may define abstract methods, but only as a way of delineating an interface through which a particular set of semantics are accessed. An Ordering role might require that some set of ordering operators be defined.

  class Ordering(metaclass=Role):
    def __ge__(self, other):
      pass
  
    def __le__(self, other):
      pass
  
    def __ne__(self, other):
      pass
  
    # ...and so on
  

  In this way, we’re able to indicate an object’s role or function within a larger system without constraining or concerning ourselves with a particular implementation.

• Abstract base classes, by contrast, are a way of reusing common, discrete units of implementation. For example, one might define an OrderingMixin that implements several ordering operators in terms of other operators.

  class OrderingMixin:
    def __ge__(self, other):
      return self > other or self == other
  
    def __le__(self, other):
      return self < other or self == other
  
    def __ne__(self, other):
      return not self == other
  
    # ...and so on
  

  Using this abstract base class - more properly, a concrete mixin - allows a programmer to define a limited set of operators and let the mixin in effect “derive” the others.

By combining these two orthogonal systems, we’re able to both a) provide functionality, and b) alert consumer systems to the presence and availability of this functionality. For example, since the OrderingMixin class above satisfies the interface and semantics expressed in the Ordering role, we say the mixin performs the role:

@perform_role(Ordering)
class OrderingMixin:
  def __ge__(self, other):
    return self > other or self == other

  def __le__(self, other):
    return self < other or self == other

  def __ne__(self, other):
    return not self == other

  # ...and so on

Now, any class that uses the mixin will automatically – that is, without further programmer effort – be tagged as performing the Ordering role.

The separation of concerns into two distinct, orthogonal systems is desirable because it allows us to use each one separately. Take, for example, a third-party package providing a RecursiveHash role that indicates a container takes its contents into account when determining its hash value. Since Python’s built-in tuple and frozenset classes follow this semantic, the RecursiveHash role can be applied to them.

>>> perform_role(RecursiveHash)(tuple)
>>> perform_role(RecursiveHash)(frozenset)

Now, any code that consumes RecursiveHash objects will now be able to consume tuples and frozensets.

Open Issues

my_elf = Elf()
my_elf.goes_on_quest()
my_elf.becomes_evil()
now_performs(my_elf, Thieving) # Only this one elf is a thief
my_elf.steals(["purses", "candy", "kisses"])

>>> from literature import role, BildungsRoman
>>> from dickens import Urchin, Gentleman
>>>
>>> with BildungsRoman() as OliverTwist:
...   mr_brownlow = Gentleman()
...   oliver, artful_dodger = Urchin(), Urchin()
...   now_performs(artful_dodger, [role.Thief, role.Scoundrel])
...
...   oliver.has_adventures_with(ArtfulDodger)
...   mr_brownlow.adopt_orphan(oliver)
...   now_performs(oliver, role.RichWard)

@perform_role(Y)
class X(metaclass=Role):
  ...

>>> isinstance(my_dwarf, Dwarf)
True
>>> performs(my_dwarf, Surly)
True
>>> performs(Dwarf, Surly)
False
>>> class_performs(Dwarf, Surly)
True

>>> now_perform(Dwarf, GoldMiner)

>>> perform_role(GoldMiner)(Dwarf)

class MyRole(metaclass=Role):
  ...

role MyRole:
  ...

class MyClass(performs=MyRole):
  ...

Implementation

A reference implementation is forthcoming.

Acknowledgements

Thanks to Jeffery Yasskin, Talin and Guido van Rossum for several hours of in-person discussion to iron out the differences, overlap and finer points of roles and abstract base classes.

References

Copyright

This document has been placed in the public domain.