title: Type Parameter of Sub-Interface has "inconsistent values"
body: <p>So i have objects that can be compared in different ways. I have a class hierarchy where the base objects must define how to be compared in every possible way whereas there is a standard way for some of the sub-classes to be compared so these methods can be given defaults. </p>
  
  <p>This is hard to explain in words, so here is some code</p>
  
  <pre><code>// This is akin to how `Comparable&lt;in T&gt;` is defined
  interface AllComparisons&lt;in T&gt; {
      // this interface has all the possible comparison methods
      fun cmp1(other: T): Int
      fun cmp2(other: T): Int
  }
  
  interface SomeComparisons&lt;in T&gt;: AllComparisons&lt;T&gt; {
      // this interface has a default for some comparison methods
      override fun cmp2(other: T) = -this.cmp1(other)  // eg
  }
  
  
  // This is akin to how a comparable object `Obj: Comparable&lt;Obj&gt;` is defined
  abstract class BaseClass: AllComparisons&lt;BaseClass&gt;  // must define both cmp1 and cmp2
  
  abstract class SubClass: BaseClass(), SomeComparisons&lt;SubClass&gt;  // only must define cmp1
  </code></pre>
  
  <p>This throws a compiler error on the final line:</p>
  
  <pre><code>Type parameter T of 'AllComparisons' has inconsistent values: BaseClass, SubClass
  </code></pre>
  
  <p>My Questions are:</p>
  
  <ol>
  <li><p>Why is this disallowed? Is this a compiler limitation or is there actually a logical inconsistency?</p></li>
  <li><p>What can I do to fix it? I'd prefer to not move the defaulting logic (for <code>cmp2</code>) from <code>SomeComparisons</code> into <code>SubClass</code> because it's not the only time I need to use this pattern and it would result in a lot of re-used code.</p></li>
  </ol>