Why does this work:

fun bar(): Single<List<Number>> {
    return Single.just(listOf<Int>())
}

But this doesn't (

type mismatch

):

fun bar(): Single<List<Number>> {
    val foo = Single.just(listOf<Int>())
    return foo
}

Removing

Single

or changing to:

fun bar(): Single<List<Number>> {
    val foo = Single.just<List<Number>>(listOf<Int>())
    return foo
}

solves the issue 🤔

Variance.

Single

is defined as *in*variant:

public abstract class Single<T> ...

That means that in your 2nd example, this line

val foo = Single.just(listOf<Int>())

reads like

val foo: Single<List<Int>> = Single.just(listOf<Int>())

and since Single’s generic-param is invariant, a

Single<List<Int>>

is not a subclass of

Single<List<Number>>

If Single was defined as

class Single<out E> ...

your 2nd example would compile. E.g. replace

Single

with `Single2`:

class Single2<out E> {
    companion object {
        fun <E> just(value: E) : Single2<E> {
            TODO()
        }
    }
}

changing to

fun bar(): Single<out List<Number>>() { .. }

also solves the issue, so seems you are right