CINXE.COM

<!DOCTYPE html> <html lang="en"> <head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta name="color-scheme" content="light dark"> <title>PEP 3133 – Introducing Roles | peps.python.org</title> <link rel="shortcut icon" href="../_static/py.png"> <link rel="canonical" href="https://peps.python.org/pep-3133/"> <link rel="stylesheet" href="../_static/style.css" type="text/css"> <link rel="stylesheet" href="../_static/mq.css" type="text/css"> <link rel="stylesheet" href="../_static/pygments.css" type="text/css" media="(prefers-color-scheme: light)" id="pyg-light"> <link rel="stylesheet" href="../_static/pygments_dark.css" type="text/css" media="(prefers-color-scheme: dark)" id="pyg-dark"> <link rel="alternate" type="application/rss+xml" title="Latest PEPs" href="https://peps.python.org/peps.rss"> <meta property="og:title" content='PEP 3133 – Introducing Roles | peps.python.org'> <meta property="og:description" content="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 ..."> <meta property="og:type" content="website"> <meta property="og:url" content="https://peps.python.org/pep-3133/"> <meta property="og:site_name" content="Python Enhancement Proposals (PEPs)"> <meta property="og:image" content="https://peps.python.org/_static/og-image.png"> <meta property="og:image:alt" content="Python PEPs"> <meta property="og:image:width" content="200"> <meta property="og:image:height" content="200"> <meta name="description" content="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 ..."> <meta name="theme-color" content="#3776ab"> </head> <body> <svg xmlns="http://www.w3.org/2000/svg" style="display: none;"> <symbol id="svg-sun-half" viewBox="0 0 24 24" pointer-events="all"> <title>Following system colour scheme</title> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"> <circle cx="12" cy="12" r="9"></circle> <path d="M12 3v18m0-12l4.65-4.65M12 14.3l7.37-7.37M12 19.6l8.85-8.85"></path> </svg> </symbol> <symbol id="svg-moon" viewBox="0 0 24 24" pointer-events="all"> <title>Selected dark colour scheme</title> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"> <path stroke="none" d="M0 0h24v24H0z" fill="none"></path> <path d="M12 3c.132 0 .263 0 .393 0a7.5 7.5 0 0 0 7.92 12.446a9 9 0 1 1 -8.313 -12.454z"></path> </svg> </symbol> <symbol id="svg-sun" viewBox="0 0 24 24" pointer-events="all"> <title>Selected light colour scheme</title> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"> <circle cx="12" cy="12" r="5"></circle> <line x1="12" y1="1" x2="12" y2="3"></line> <line x1="12" y1="21" x2="12" y2="23"></line> <line x1="4.22" y1="4.22" x2="5.64" y2="5.64"></line> <line x1="18.36" y1="18.36" x2="19.78" y2="19.78"></line> <line x1="1" y1="12" x2="3" y2="12"></line> <line x1="21" y1="12" x2="23" y2="12"></line> <line x1="4.22" y1="19.78" x2="5.64" y2="18.36"></line> <line x1="18.36" y1="5.64" x2="19.78" y2="4.22"></line> </svg> </symbol> </svg> <script> document.documentElement.dataset.colour_scheme = localStorage.getItem("colour_scheme") || "auto" </script> <section id="pep-page-section"> <header> <h1>Python Enhancement Proposals</h1> <ul class="breadcrumbs"> <li><a href="https://www.python.org/" title="The Python Programming Language">Python</a> » </li> <li><a href="../pep-0000/">PEP Index</a> » </li> <li>PEP 3133</li> </ul> <button id="colour-scheme-cycler" onClick="setColourScheme(nextColourScheme())"> <svg aria-hidden="true" class="colour-scheme-icon-when-auto"><use href="#svg-sun-half"></use></svg> <svg aria-hidden="true" class="colour-scheme-icon-when-dark"><use href="#svg-moon"></use></svg> <svg aria-hidden="true" class="colour-scheme-icon-when-light"><use href="#svg-sun"></use></svg> Toggle light / dark / auto colour theme </button> </header> <article> <section id="pep-content"> <h1 class="page-title">PEP 3133 – Introducing Roles</h1> <dl class="rfc2822 field-list simple"> <dt class="field-odd">Author:</dt> <dd class="field-odd">Collin Winter <collinwinter at google.com></dd> <dt class="field-even">Status:</dt> <dd class="field-even"><abbr title="Formally declined and will not be accepted">Rejected</abbr></dd> <dt class="field-odd">Type:</dt> <dd class="field-odd"><abbr title="Normative PEP with a new feature for Python, implementation change for CPython or interoperability standard for the ecosystem">Standards Track</abbr></dd> <dt class="field-even">Requires:</dt> <dd class="field-even"><a class="reference external" href="../pep-3115/">3115</a>, <a class="reference external" href="../pep-3129/">3129</a></dd> <dt class="field-odd">Created:</dt> <dd class="field-odd">01-May-2007</dd> <dt class="field-even">Python-Version:</dt> <dd class="field-even">3.0</dd> <dt class="field-odd">Post-History:</dt> <dd class="field-odd">13-May-2007</dd> </dl> <hr class="docutils" /> <section id="contents"> <details><summary>Table of Contents</summary><ul class="simple"> <li><a class="reference internal" href="#rejection-notice">Rejection Notice</a></li> <li><a class="reference internal" href="#abstract">Abstract</a></li> <li><a class="reference internal" href="#rationale">Rationale</a><ul> <li><a class="reference internal" href="#a-note-on-syntax">A Note on Syntax</a></li> </ul> </li> <li><a class="reference internal" href="#performing-your-role">Performing Your Role</a><ul> <li><a class="reference internal" href="#static-role-assignment">Static Role Assignment</a></li> <li><a class="reference internal" href="#assigning-roles-at-runtime">Assigning Roles at Runtime</a></li> <li><a class="reference internal" href="#asking-questions-about-roles">Asking Questions About Roles</a></li> </ul> </li> <li><a class="reference internal" href="#defining-new-roles">Defining New Roles</a><ul> <li><a class="reference internal" href="#empty-roles">Empty Roles</a></li> <li><a class="reference internal" href="#composing-roles-via-inheritance">Composing Roles via Inheritance</a></li> <li><a class="reference internal" href="#requiring-concrete-methods">Requiring Concrete Methods</a></li> </ul> </li> <li><a class="reference internal" href="#mechanism">Mechanism</a></li> <li><a class="reference internal" href="#relationship-to-abstract-base-classes">Relationship to Abstract Base Classes</a></li> <li><a class="reference internal" href="#open-issues">Open Issues</a><ul> <li><a class="reference internal" href="#allowing-instances-to-perform-different-roles-than-their-class">Allowing Instances to Perform Different Roles Than Their Class</a></li> <li><a class="reference internal" href="#requiring-attributes">Requiring Attributes</a></li> <li><a class="reference internal" href="#roles-of-roles">Roles of Roles</a></li> <li><a class="reference internal" href="#class-performs">class_performs()</a></li> <li><a class="reference internal" href="#prettier-dynamic-role-assignment">Prettier Dynamic Role Assignment</a></li> <li><a class="reference internal" href="#syntax-support">Syntax Support</a></li> </ul> </li> <li><a class="reference internal" href="#implementation">Implementation</a></li> <li><a class="reference internal" href="#acknowledgements">Acknowledgements</a></li> <li><a class="reference internal" href="#references">References</a></li> <li><a class="reference internal" href="#copyright">Copyright</a></li> </ul> </details></section> <section id="rejection-notice"> <h2><a class="toc-backref" href="#rejection-notice" role="doc-backlink">Rejection Notice</a></h2> This PEP has helped push <a class="pep reference internal" href="../pep-3119/" title="PEP 3119 – Introducing Abstract Base Classes">PEP 3119</a> towards a saner, more minimalistic approach. But given the latest version of <a class="pep reference internal" href="../pep-3119/" title="PEP 3119 – Introducing Abstract Base Classes">PEP 3119</a> I much prefer that. GvR. </section> <section id="abstract"> <h2><a class="toc-backref" href="#abstract" role="doc-backlink">Abstract</a></h2> 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. </section> <section id="rationale"> <h2><a class="toc-backref" href="#rationale" role="doc-backlink">Rationale</a></h2> 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 <a class="footnote-reference brackets" href="#traits-paper" id="id1">[4]</a>. It has since been adapted for use in Perl 6 <a class="footnote-reference brackets" href="#perl6-s12" id="id2">[3]</a> 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.) <section id="a-note-on-syntax"> <h3><a class="toc-backref" href="#a-note-on-syntax" role="doc-backlink">A Note on Syntax</a></h3> A syntax proposals in this PEP are tentative and should be considered to be strawmen. The necessary bits that this PEP depends on – namely <a class="pep reference internal" href="../pep-3115/" title="PEP 3115 – Metaclasses in Python 3000">PEP 3115</a>’s class definition syntax and <a class="pep reference internal" href="../pep-3129/" title="PEP 3129 – Class Decorators">PEP 3129</a>’s class decorators – are still being formalized and may change. Function names will, of course, be subject to lengthy bikeshedding debates. </section> </section> <section id="performing-your-role"> <h2><a class="toc-backref" href="#performing-your-role" role="doc-backlink">Performing Your Role</a></h2> <section id="static-role-assignment"> <h3><a class="toc-backref" href="#static-role-assignment" role="doc-backlink">Static Role Assignment</a></h3> Let’s start out by defining <code class="docutils literal notranslate">Tree</code> and <code class="docutils literal notranslate">Dog</code> classes <div class="highlight-default notranslate"><div class="highlight"><pre>class Tree(Vegetable): def bark(self): return self.is_rough() class Dog(Animal): def bark(self): return self.goes_ruff() </pre></div> </div> While both implement a <code class="docutils literal notranslate">bark()</code> method with the same signature, they do wildly different things. We need some way of differentiating what we’re expecting. Relying on inheritance and a simple <code class="docutils literal notranslate">isinstance()</code> test will limit code reuse and/or force any dog-like classes to inherit from <code class="docutils literal notranslate">Dog</code>, whether or not that makes sense. Let’s see if roles can help. <div class="highlight-default notranslate"><div class="highlight"><pre>@perform_role(Doglike) class Dog(Animal): ... @perform_role(Treelike) class Tree(Vegetable): ... @perform_role(SitThere) class Rock(Mineral): ... </pre></div> </div> We use class decorators from <a class="pep reference internal" href="../pep-3129/" title="PEP 3129 – Class Decorators">PEP 3129</a> to associate a particular role or roles with a class. Client code can now verify that an incoming object performs the <code class="docutils literal notranslate">Doglike</code> role, allowing it to handle <code class="docutils literal notranslate">Wolf</code>, <code class="docutils literal notranslate">LaughingHyena</code> and <code class="docutils literal notranslate">Aibo</code> <a class="footnote-reference brackets" href="#aibo" id="id3">[1]</a> instances, too. Roles can be composed via normal inheritance: <div class="highlight-default notranslate"><div class="highlight"><pre>@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() </pre></div> </div> Here, <code class="docutils literal notranslate">GermanShepherd</code> instances perform three roles: <code class="docutils literal notranslate">Guard</code> and <code class="docutils literal notranslate">MummysLittleDarling</code> are applied directly, whereas <code class="docutils literal notranslate">Doglike</code> is inherited from <code class="docutils literal notranslate">Dog</code>. </section> <section id="assigning-roles-at-runtime"> <h3><a class="toc-backref" href="#assigning-roles-at-runtime" role="doc-backlink">Assigning Roles at Runtime</a></h3> Roles can be assigned at runtime, too, by unpacking the syntactic sugar provided by decorators. Say we import a <code class="docutils literal notranslate">Robot</code> class from another module, and since we know that <code class="docutils literal notranslate">Robot</code> already implements our <code class="docutils literal notranslate">Guard</code> interface, we’d like it to play nicely with guard-related code, too. <div class="highlight-default notranslate"><div class="highlight"><pre>>>> perform(Guard)(Robot) </pre></div> </div> This takes effect immediately and impacts all instances of <code class="docutils literal notranslate">Robot</code>. </section> <section id="asking-questions-about-roles"> <h3><a class="toc-backref" href="#asking-questions-about-roles" role="doc-backlink">Asking Questions About Roles</a></h3> Just because we’ve told our robot army that they’re guards, we’d like to check in on them occasionally and make sure they’re still at their task. <div class="highlight-default notranslate"><div class="highlight"><pre>>>> performs(our_robot, Guard) True </pre></div> </div> What about that one robot over there? <div class="highlight-default notranslate"><div class="highlight"><pre>>>> performs(that_robot_over_there, Guard) True </pre></div> </div> The <code class="docutils literal notranslate">performs()</code> function is used to ask if a given object fulfills a given role. It cannot be used, however, to ask a class if its instances fulfill a role: <div class="highlight-default notranslate"><div class="highlight"><pre>>>> performs(Robot, Guard) False </pre></div> </div> This is because the <code class="docutils literal notranslate">Robot</code> class is not interchangeable with a <code class="docutils literal notranslate">Robot</code> instance. </section> </section> <section id="defining-new-roles"> <h2><a class="toc-backref" href="#defining-new-roles" role="doc-backlink">Defining New Roles</a></h2> <section id="empty-roles"> <h3><a class="toc-backref" href="#empty-roles" role="doc-backlink">Empty Roles</a></h3> Roles are defined like a normal class, but use the <code class="docutils literal notranslate">Role</code> metaclass. <div class="highlight-default notranslate"><div class="highlight"><pre>class Doglike(metaclass=Role): ... </pre></div> </div> Metaclasses are used to indicate that <code class="docutils literal notranslate">Doglike</code> is a <code class="docutils literal notranslate">Role</code> in the same way 5 is an <code class="docutils literal notranslate">int</code> and <code class="docutils literal notranslate">tuple</code> is a <code class="docutils literal notranslate">type</code>. </section> <section id="composing-roles-via-inheritance"> <h3><a class="toc-backref" href="#composing-roles-via-inheritance" role="doc-backlink">Composing Roles via Inheritance</a></h3> Roles may inherit from other roles; this has the effect of composing them. Here, instances of <code class="docutils literal notranslate">Dog</code> will perform both the <code class="docutils literal notranslate">Doglike</code> and <code class="docutils literal notranslate">FourLegs</code> roles. <div class="highlight-default notranslate"><div class="highlight"><pre>class FourLegs(metaclass=Role): pass class Doglike(FourLegs, Carnivor): pass @perform_role(Doglike) class Dog(Mammal): pass </pre></div> </div> </section> <section id="requiring-concrete-methods"> <h3><a class="toc-backref" href="#requiring-concrete-methods" role="doc-backlink">Requiring Concrete Methods</a></h3> So far we’ve only defined empty roles – not very useful things. Let’s now require that all classes that claim to fulfill the <code class="docutils literal notranslate">Doglike</code> role define a <code class="docutils literal notranslate">bark()</code> method: <div class="highlight-default notranslate"><div class="highlight"><pre>class Doglike(FourLegs): def bark(self): pass </pre></div> </div> No decorators are required to flag the method as “abstract”, and the method will never be called, meaning whatever code it contains (if any) is irrelevant. Roles provide only abstract methods; concrete default implementations are left to other, better-suited mechanisms like mixins. Once you have defined a role, and a class has claimed to perform that role, it is essential that that claim be verified. Here, the programmer has misspelled one of the methods required by the role. <div class="highlight-default notranslate"><div class="highlight"><pre>@perform_role(FourLegs) class Horse(Mammal): def run_like_teh_wind(self) ... </pre></div> </div> This will cause the role system to raise an exception, complaining that you’re missing a <code class="docutils literal notranslate">run_like_the_wind()</code> method. The role system carries out these checks as soon as a class is flagged as performing a given role. Concrete methods are required to match exactly the signature demanded by the role. Here, we’ve attempted to fulfill our role by defining a concrete version of <code class="docutils literal notranslate">bark()</code>, but we’ve missed the mark a bit. <div class="highlight-default notranslate"><div class="highlight"><pre>@perform_role(Doglike) class Coyote(Mammal): def bark(self, target=moon): pass </pre></div> </div> This method’s signature doesn’t match exactly with what the <code class="docutils literal notranslate">Doglike</code> role was expecting, so the role system will throw a bit of a tantrum. </section> </section> <section id="mechanism"> <h2><a class="toc-backref" href="#mechanism" role="doc-backlink">Mechanism</a></h2> 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 <a class="footnote-reference brackets" href="#roles-examples" id="id4">[2]</a>.) <ol class="arabic"> <li>Static class role assignment<div class="highlight-default notranslate"><div class="highlight"><pre>@perform_role(Thieving) class Elf(Character): ... </pre></div> </div> <code class="docutils literal notranslate">perform_role()</code> accepts multiple arguments, such that this is also legal: <div class="highlight-default notranslate"><div class="highlight"><pre>@perform_role(Thieving, Spying, Archer) class Elf(Character): ... </pre></div> </div> The <code class="docutils literal notranslate">Elf</code> class now performs both the <code class="docutils literal notranslate">Thieving</code>, <code class="docutils literal notranslate">Spying</code>, and <code class="docutils literal notranslate">Archer</code> roles. </li> <li>Querying instances<div class="highlight-default notranslate"><div class="highlight"><pre>if performs(my_elf, Thieving): ... </pre></div> </div> The second argument to <code class="docutils literal notranslate">performs()</code> may also be anything with a <code class="docutils literal notranslate">__contains__()</code> method, meaning the following is legal: <div class="highlight-default notranslate"><div class="highlight"><pre>if performs(my_elf, set([Thieving, Spying, BoyScout])): ... </pre></div> </div> Like <code class="docutils literal notranslate">isinstance()</code>, the object needs only to perform a single role out of the set in order for the expression to be true. </li> </ol> </section> <section id="relationship-to-abstract-base-classes"> <h2><a class="toc-backref" href="#relationship-to-abstract-base-classes" role="doc-backlink">Relationship to Abstract Base Classes</a></h2> Early drafts of this PEP <a class="footnote-reference brackets" href="#proposal" id="id5">[5]</a> envisioned roles as competing with the abstract base classes proposed in <a class="pep reference internal" href="../pep-3119/" title="PEP 3119 – Introducing Abstract Base Classes">PEP 3119</a>. After further discussion and deliberation, a compromise and a delegation of responsibilities and use-cases has been worked out as follows: <ul> <li>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 <code class="docutils literal notranslate">Ordering</code> role might require that some set of ordering operators be defined.<div class="highlight-default notranslate"><div class="highlight"><pre>class Ordering(metaclass=Role): def __ge__(self, other): pass def __le__(self, other): pass def __ne__(self, other): pass # ...and so on </pre></div> </div> 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. </li> <li>Abstract base classes, by contrast, are a way of reusing common, discrete units of implementation. For example, one might define an <code class="docutils literal notranslate">OrderingMixin</code> that implements several ordering operators in terms of other operators.<div class="highlight-default notranslate"><div class="highlight"><pre>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 </pre></div> </div> 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. </li> </ul> 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 <code class="docutils literal notranslate">OrderingMixin</code> class above satisfies the interface and semantics expressed in the <code class="docutils literal notranslate">Ordering</code> role, we say the mixin performs the role: <div class="highlight-default notranslate"><div class="highlight"><pre>@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 </pre></div> </div> Now, any class that uses the mixin will automatically – that is, without further programmer effort – be tagged as performing the <code class="docutils literal notranslate">Ordering</code> 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 <code class="docutils literal notranslate">RecursiveHash</code> role that indicates a container takes its contents into account when determining its hash value. Since Python’s built-in <code class="docutils literal notranslate">tuple</code> and <code class="docutils literal notranslate">frozenset</code> classes follow this semantic, the <code class="docutils literal notranslate">RecursiveHash</code> role can be applied to them. <div class="highlight-default notranslate"><div class="highlight"><pre>>>> perform_role(RecursiveHash)(tuple) >>> perform_role(RecursiveHash)(frozenset) </pre></div> </div> Now, any code that consumes <code class="docutils literal notranslate">RecursiveHash</code> objects will now be able to consume tuples and frozensets. </section> <section id="open-issues"> <h2><a class="toc-backref" href="#open-issues" role="doc-backlink">Open Issues</a></h2> <section id="allowing-instances-to-perform-different-roles-than-their-class"> <h3><a class="toc-backref" href="#allowing-instances-to-perform-different-roles-than-their-class" role="doc-backlink">Allowing Instances to Perform Different Roles Than Their Class</a></h3> Perl 6 allows instances to perform different roles than their class. These changes are local to the single instance and do not affect other instances of the class. For example: <div class="highlight-default notranslate"><div class="highlight"><pre>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"]) </pre></div> </div> In Perl 6, this is done by creating an anonymous class that inherits from the instance’s original parent and performs the additional role(s). This is possible in Python 3, though whether it is desirable is still is another matter. Inclusion of this feature would, of course, make it much easier to express the works of Charles Dickens in Python: <div class="highlight-default notranslate"><div class="highlight"><pre>>>> 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) </pre></div> </div> </section> <section id="requiring-attributes"> <h3><a class="toc-backref" href="#requiring-attributes" role="doc-backlink">Requiring Attributes</a></h3> Neal Norwitz has requested the ability to make assertions about the presence of attributes using the same mechanism used to require methods. Since roles take effect at class definition-time, and since the vast majority of attributes are defined at runtime by a class’s <code class="docutils literal notranslate">__init__()</code> method, there doesn’t seem to be a good way to check for attributes at the same time as methods. It may still be desirable to include non-enforced attributes in the role definition, if only for documentation purposes. </section> <section id="roles-of-roles"> <h3><a class="toc-backref" href="#roles-of-roles" role="doc-backlink">Roles of Roles</a></h3> Under the proposed semantics, it is possible for roles to have roles of their own. <div class="highlight-default notranslate"><div class="highlight"><pre>@perform_role(Y) class X(metaclass=Role): ... </pre></div> </div> While this is possible, it is meaningless, since roles are generally not instantiated. There has been some off-line discussion about giving meaning to this expression, but so far no good ideas have emerged. </section> <section id="class-performs"> <h3><a class="toc-backref" href="#class-performs" role="doc-backlink">class_performs()</a></h3> It is currently not possible to ask a class if its instances perform a given role. It may be desirable to provide an analogue to <code class="docutils literal notranslate">performs()</code> such that <div class="highlight-default notranslate"><div class="highlight"><pre>>>> isinstance(my_dwarf, Dwarf) True >>> performs(my_dwarf, Surly) True >>> performs(Dwarf, Surly) False >>> class_performs(Dwarf, Surly) True </pre></div> </div> </section> <section id="prettier-dynamic-role-assignment"> <h3><a class="toc-backref" href="#prettier-dynamic-role-assignment" role="doc-backlink">Prettier Dynamic Role Assignment</a></h3> An early draft of this PEP included a separate mechanism for dynamically assigning a role to a class. This was spelled <div class="highlight-default notranslate"><div class="highlight"><pre>>>> now_perform(Dwarf, GoldMiner) </pre></div> </div> This same functionality already exists by unpacking the syntactic sugar provided by decorators: <div class="highlight-default notranslate"><div class="highlight"><pre>>>> perform_role(GoldMiner)(Dwarf) </pre></div> </div> At issue is whether dynamic role assignment is sufficiently important to warrant a dedicated spelling. </section> <section id="syntax-support"> <h3><a class="toc-backref" href="#syntax-support" role="doc-backlink">Syntax Support</a></h3> Though the phrasings laid out in this PEP are designed so that the roles system could be shipped as a stand-alone package, it may be desirable to add special syntax for defining, assigning and querying roles. One example might be a role keyword, which would translate <div class="highlight-default notranslate"><div class="highlight"><pre>class MyRole(metaclass=Role): ... </pre></div> </div> into <div class="highlight-default notranslate"><div class="highlight"><pre>role MyRole: ... </pre></div> </div> Assigning a role could take advantage of the class definition arguments proposed in <a class="pep reference internal" href="../pep-3115/" title="PEP 3115 – Metaclasses in Python 3000">PEP 3115</a>: <div class="highlight-default notranslate"><div class="highlight"><pre>class MyClass(performs=MyRole): ... </pre></div> </div> </section> </section> <section id="implementation"> <h2><a class="toc-backref" href="#implementation" role="doc-backlink">Implementation</a></h2> A reference implementation is forthcoming. </section> <section id="acknowledgements"> <h2><a class="toc-backref" href="#acknowledgements" role="doc-backlink">Acknowledgements</a></h2> 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. </section> <section id="references"> <h2><a class="toc-backref" href="#references" role="doc-backlink">References</a></h2> <aside class="footnote-list brackets"> <aside class="footnote brackets" id="aibo" role="doc-footnote"> <dt class="label" id="aibo">[<a href="#id3">1</a>]</dt> <dd><a class="reference external" href="http://en.wikipedia.org/wiki/AIBO">http://en.wikipedia.org/wiki/AIBO</a></aside> <aside class="footnote brackets" id="roles-examples" role="doc-footnote"> <dt class="label" id="roles-examples">[<a href="#id4">2</a>]</dt> <dd><a class="reference external" href="http://www.perlmonks.org/?node_id=384858">http://www.perlmonks.org/?node_id=384858</a></aside> <aside class="footnote brackets" id="perl6-s12" role="doc-footnote"> <dt class="label" id="perl6-s12">[<a href="#id2">3</a>]</dt> <dd><a class="reference external" href="http://dev.perl.org/perl6/doc/design/syn/S12.html">http://dev.perl.org/perl6/doc/design/syn/S12.html</a></aside> <aside class="footnote brackets" id="traits-paper" role="doc-footnote"> <dt class="label" id="traits-paper">[<a href="#id1">4</a>]</dt> <dd><a class="reference external" href="http://www.iam.unibe.ch/~scg/Archive/Papers/Scha03aTraits.pdf">http://www.iam.unibe.ch/~scg/Archive/Papers/Scha03aTraits.pdf</a></aside> <aside class="footnote brackets" id="proposal" role="doc-footnote"> <dt class="label" id="proposal">[<a href="#id5">5</a>]</dt> <dd><a class="reference external" href="https://mail.python.org/pipermail/python-3000/2007-April/007026.html">https://mail.python.org/pipermail/python-3000/2007-April/007026.html</a></aside> </aside> </section> <section id="copyright"> <h2><a class="toc-backref" href="#copyright" role="doc-backlink">Copyright</a></h2> This document has been placed in the public domain. </section> </section> <hr class="docutils" /> Source: <a class="reference external" href="https://github.com/python/peps/blob/main/peps/pep-3133.rst">https://github.com/python/peps/blob/main/peps/pep-3133.rst</a> Last modified: <a class="reference external" href="https://github.com/python/peps/commits/main/peps/pep-3133.rst">2023-09-09 17:39:29 GMT</a> </article> <nav id="pep-sidebar"> <h2>Contents</h2> <ul> <li><a class="reference internal" href="#rejection-notice">Rejection Notice</a></li> <li><a class="reference internal" href="#abstract">Abstract</a></li> <li><a class="reference internal" href="#rationale">Rationale</a><ul> <li><a class="reference internal" href="#a-note-on-syntax">A Note on Syntax</a></li> </ul> </li> <li><a class="reference internal" href="#performing-your-role">Performing Your Role</a><ul> <li><a class="reference internal" href="#static-role-assignment">Static Role Assignment</a></li> <li><a class="reference internal" href="#assigning-roles-at-runtime">Assigning Roles at Runtime</a></li> <li><a class="reference internal" href="#asking-questions-about-roles">Asking Questions About Roles</a></li> </ul> </li> <li><a class="reference internal" href="#defining-new-roles">Defining New Roles</a><ul> <li><a class="reference internal" href="#empty-roles">Empty Roles</a></li> <li><a class="reference internal" href="#composing-roles-via-inheritance">Composing Roles via Inheritance</a></li> <li><a class="reference internal" href="#requiring-concrete-methods">Requiring Concrete Methods</a></li> </ul> </li> <li><a class="reference internal" href="#mechanism">Mechanism</a></li> <li><a class="reference internal" href="#relationship-to-abstract-base-classes">Relationship to Abstract Base Classes</a></li> <li><a class="reference internal" href="#open-issues">Open Issues</a><ul> <li><a class="reference internal" href="#allowing-instances-to-perform-different-roles-than-their-class">Allowing Instances to Perform Different Roles Than Their Class</a></li> <li><a class="reference internal" href="#requiring-attributes">Requiring Attributes</a></li> <li><a class="reference internal" href="#roles-of-roles">Roles of Roles</a></li> <li><a class="reference internal" href="#class-performs">class_performs()</a></li> <li><a class="reference internal" href="#prettier-dynamic-role-assignment">Prettier Dynamic Role Assignment</a></li> <li><a class="reference internal" href="#syntax-support">Syntax Support</a></li> </ul> </li> <li><a class="reference internal" href="#implementation">Implementation</a></li> <li><a class="reference internal" href="#acknowledgements">Acknowledgements</a></li> <li><a class="reference internal" href="#references">References</a></li> <li><a class="reference internal" href="#copyright">Copyright</a></li> </ul> <a id="source" href="https://github.com/python/peps/blob/main/peps/pep-3133.rst">Page Source (GitHub)</a> </nav> </section> <script src="../_static/colour_scheme.js"></script> <script src="../_static/wrap_tables.js"></script> <script src="../_static/sticky_banner.js"></script> </body> </html>