A modern programming language that makes developers happier.

kotlinlang

```
abstract class A {
    abstract val value: String
    abstract fun &lt;T: A&gt; test(): T
}

data class B(
    override val value: String,
    val value2: String
): A() {
    override fun test() 
        = this.copy(value = "HelloWorld")
}
```
How can I achieve something like this?

```
abstract class A&lt;T : A&lt;T&gt;&gt; {
    abstract val value: String
    abstract fun test(): T
}

data class B(
    override val value: String,
    val value2: String
): A&lt;B&gt;() {
    override fun test()
            = this.copy(value = "HelloWorld")
}
```

Recursive templates are about the only way you can approximate self types on the JVM unfortunately

I tried this way, this results in getting A back.
I have some other function that takes B in, so I want to be able to call `funTakesB(b.test())`, but this fails as b.test() returns `A&lt;*&gt;` instead of `B`

I'll just cast it, I know it will always be the right one

I can't reproduce what you're reporting:
```
abstract class A&lt;T : A&lt;T&gt;&gt; {
    abstract val value: String
    abstract fun test(): T
}

data class B(
    override val value: String,
    val value2: String
): A&lt;B&gt;() {
    override fun test()
            = this.copy(value = "HelloWorld")
}

fun funTakesB(b: B) {

}

fun foo() {
    val b = B("foo", "bar")
    funTakesB(b.test())
}
```

If it's an instance of `B` it will work fine. Are you sure it's not inferred as an instance of `A`?

probably, I will write a better example. Wait a min

I don't find any easy way of showing the use case for this, as I'm working in a bigger project.
But this is it: <https://pl.kotl.in/B1SSwdiF4>

I just used `as T` there, which works fine. Was just wondering if I somehow can get rid of it

```
abstract class Service&lt;T: A&lt;T&gt;&gt; {
    abstract fun extra(any: T)
    fun someWork(any: T) {
        extra(any.test())
    }
}
```