A modern programming language that makes developers happier.

kotlinlang

Question: is there a way to mark an interface as "can only be implemented by a certain type and its subclasses"?

Better yet, is there an alternate way to express the intent? I'm trying to wrap my hands around something like:
```interface Extender&lt;T&gt; {
  context(thisValue: T)
  fun doSomething()
}

class Foo : Extender&lt;Foo&gt; {
  context(thisValue: Foo)
  override fun doSomething() { ... }
  
  // So, Foo would need a context-free overload of doSomething() anyways
  // passing itself as context, in order for outsiders to use it?
  fun doSomething() = context(this) { doSomething() }
}```


Though, I'm a little confused by your example.  Context would probably help

```sealed interface CanOnlyBeImplementedInThisFile {}
open class CanBeSubclassed: CanOnlyBeImplementedInThisFile```

`sealed` wouldn't work in my use case, necessarily. For an academic example, consider this:
```interface InfixOp&lt;T&gt; {
  infix fun op(rhs: T): T
}

interface InfixOpTrait&lt;T&gt; {
  fun op(lhs: T, rhs: T): T
}

class MyType : InfixOp&lt;MyType&gt; {
  object InfixTrait : InfixOpTrait&lt;T&gt; { ... }
  
  override fun op(rhs: T) = InfixTrait.op(lhs, rhs)
}```
The intent is to make `InfixOp` implementable only by `T`, so that you can have a "this value" available with a default implementation of `InfixOp.op`, in the hope that some boilerplate could be removed. Something like
```interface InfixOp2&lt;T&gt; {
  context(thisVal: T)
  infix fun op(rhs: T): T
}```


I think I see - you're trying to jank your way into a 'self' type kind of thing?
This isn't real Kotlin, but expresses what you're actually trying to do roughly?
```interface InfixOp { infix fun op(rhs: Self): Self }```

If I'm understanding correctly, couldn't you just have an extension function on a generic type with a bound?
```fun &lt;T : CharSequence&gt; T.op() = TODO()```


It could be an interface with multiple functions, and I'm not sure how you can implement an interface using only extensions.

```interface InfixOp3&lt;T&gt; {
  infix fun T.op(rhs: T): T
}```
That doesn't look like it does what I think it does.

No, I don't think it would in practice. The example provided only really works for a single function, not if you want multiple function, or more "ad-hoc" trait implementations on types like in Rust.

Still confused as to what you're going for <@U08NGFXKH0F>.  Is it the self-typing thing I wrote above, kind of like how `Comparable&lt;T&gt;` would ideally work?

Similar to "implement `Comparable` backed by a `Comparator`" in that sense.

All right.  Yeah, I don't think there's anything you can really use for this.  `Comparable&lt;T&gt;`'s lack of something like this is a good hint that the designers of Kotlin don't have an intended answer.

Yeah, I was hoping for something like
```interface ContextedComparable&lt;T&gt; {
  context(thisVal: T, cmp: Comparator&lt;T&gt;)
  fun compareTo(rhs: T): Int = cmp.compare(thisVal, rhs)
}```
But that just creates more boilerplate, now that I think about it. I think that a context-free `Comparable` backed by a `Comparator` may be crossing a line somewhere, but a context-sensitive one (which might be useful for wrapper value classes) wouldn't require that many hoops.