Implement abstract class with constrained generic in Kotlin

Question

Working on Kotlin 1.3.61

Having this code:

abstract class ResourceObserver<T> : Observer<T> where T : Resource<T> {
    override fun onChanged(t: T) {
        when (t.status) {
            Status.LOADING -> { ... }
            Status.ERROR -> { ... }
            Status.SUCCESS -> { onSuccess(t.data) }
        }
    }

    abstract fun onSuccess(data: T?)
}

and trying to implement it

private val foo = object : ResourceObserver<Resource<Bar>> {
    override fun onSuccess(data: Bar?) {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }
}

Compiler (Android Studio in this case) gives me this error:

Type argument is not within its bounds.
Expected: Resource<Resource<Bar>>
Found: Resource<Bar>

What is wrong with my obviously erroneous code?

Keep giving me the error, this time is: Type argument is not within its bounds. Expected: Resource<Bar> Found: Bar — Valerio
– Valerio, Commented Nov 28, 2019 at 11:45

hotkey · Accepted Answer · 2019-11-28 19:46:46Z

2

The constraint where T : Resource<T> indeed requires that whatever type argument you use for T must also be Resource<T> (with T substituted by the type itself).

According to this constraint, the type argument that you provide for the implementation T := Resource<Bar> is checked for being Resource<T> ≡ Resource<Resource<Bar>> and fails this check.

For this constraint and the subtype to work, Bar would need to be a subtype (implementation) of Resource<Bar>.

Do you really need T to be a Reosurce<T> with the same T? Will it solve your problem if you use an upper bound with a star-projection T : Resource<*> or add another type parameter, as shown below?

abstract class ResourceObserver<T, R> : Observer<T> where T : Resource<R> { ... }

private val foo = object : ResourceObserver<Resource<Bar>, Bar> { ... }

edited Nov 28, 2019 at 19:46

answered Nov 28, 2019 at 12:23

hotkey

149k43 gold badges392 silver badges333 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Alexey Romanov · Accepted Answer · 2019-11-28 13:30:08Z

1

This looks like an attempt to use F-bounded polymorphism. For it to work you need to

make Bar extend Resource<Bar>;
make private val foo = object : ResourceObserver<Bar> { ... } instead of <Resource<Bar>>.

Usually Resource itself will be declared with the similar constraint

class Resource<T : Resource<T>>

so if you forget to do 1 Bar won't compile.

answered Nov 28, 2019 at 13:30

Alexey Romanov

172k38 gold badges330 silver badges509 bronze badges

Collectives™ on Stack Overflow

Implement abstract class with constrained generic in Kotlin

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related