title: typing.Protocol class `__init__` method not called during explicit subtype construction
body: <p>Python's <a href="https://www.python.org/dev/peps/pep-0544/" rel="nofollow noreferrer">PEP 544</a> introduces <code>typing.Protocol</code> for structural subtyping, a.k.a. &quot;static duck typing&quot;.</p>
  <p>In this PEP's section on <a href="https://www.python.org/dev/peps/pep-0544/#merging-and-extending-protocols" rel="nofollow noreferrer">Merging and extending protocols</a>, it is stated that</p>
  <blockquote>
  <p>The general philosophy is that protocols are mostly like regular ABCs,
  but a static type checker will handle them specially.</p>
  </blockquote>
  <p>Thus, one would expect to inherit from a subclass of <code>typing.Protocol</code> in much the same way that one expects to inherit from a subclasses of <code>abc.ABC</code>:</p>
  <pre><code>from abc import ABC
  from typing import Protocol
  
  class AbstractBase(ABC):
      def method(self):
          print(&quot;AbstractBase.method called&quot;)
  
  class Concrete1(AbstractBase):
      ...
  
  c1 = Concrete1()
  c1.method()  # prints &quot;AbstractBase.method called&quot;
  
  class ProtocolBase(Protocol):
      def method(self):
          print(&quot;ProtocolBase.method called&quot;)
  
  class Concrete2(ProtocolBase):
      ...
  
  c2 = Concrete2()
  c2.method()  # prints &quot;ProtocolBase.method called&quot;
  </code></pre>
  <p>As expected, the concrete subclasses <code>Concrete1</code> and <code>Concrete2</code> inherit <code>method</code> from their respective superclasses. This behavior is documented in the <a href="https://www.python.org/dev/peps/pep-0544/#explicitly-declaring-implementation" rel="nofollow noreferrer">Explicitly declaring implementation</a> section of the PEP:</p>
  <blockquote>
  <p>To explicitly declare that a certain class implements a given
  protocol, it can be used as a regular base class. In this case a class
  could use default implementations of protocol members.</p>
  <p>...</p>
  <p>Note that there is little difference between explicit and implicit
  subtypes, the main benefit of explicit subclassing is to get some
  protocol methods &quot;for free&quot;.</p>
  </blockquote>
  <p>However, when the protocol class implements the <code>__init__</code> method, <code>__init__</code> is <em>not</em> inherited by explicit subclasses of the protocol class. This is in contrast to subclasses of an <code>ABC</code> class, which <em>do</em> inherit the <code>__init__</code> method:</p>
  <pre><code>from abc import ABC
  from typing import Protocol
  
  class AbstractBase(ABC):
      def __init__(self):
          print(&quot;AbstractBase.__init__ called&quot;)
  
  class Concrete1(AbstractBase):
      ...
  
  c1 = Concrete1()  # prints &quot;AbstractBase.__init__ called&quot;
  
  class ProtocolBase(Protocol):
      def __init__(self):
          print(&quot;ProtocolBase.__init__ called&quot;)
  
  class Concrete2(ProtocolBase):
      ...
  
  c2 = Concrete2()  # NOTHING GETS PRINTED
  </code></pre>
  <p>We see that, <code>Concrete1</code> inherits <code>__init__</code> from <code>AbstractBase</code>, but <code>Concrete2</code> does not inherit <code>__init__</code> from <code>ProtocolBase</code>. This is in contrast to the previous example, where <code>Concrete1</code> and <code>Concrete2</code> both inherit <code>method</code> from their respective superclasses.</p>
  <p>My questions are:</p>
  <ol>
  <li>What is the rationale behind not having <code>__init__</code> inherited by explicit subtypes of a protocol class? Is there some type-theoretic reason for protocol classes not being able to supply an <code>__init__</code> method &quot;for free&quot;?</li>
  <li>Is there any documentation concerning this discrepancy? Or is it a bug?</li>
  </ol>