I'm trying to write a seemingly simple function, but Kotlin doesn't play dice, what am I doing wrong? declaration:

fun <E> Collection<E>.myContains(item: E) : Boolean

usage:

val isItInside: Boolean = listOf(1, 2).myContains("1")

expectation: usage fails to compile, because it's a

List<Int>

vs. a

String

https://stackoverflow.com/q/57224118/253468

What are you even trying to do?

it's not a compile-time error because Collection is "out E"

@Shawn it says on SO "quite pointless", see the bottom for a full real life example

If you control the variance it works

Why not specify type of the collection explicitly, e.g.

listOf<Int>(1, 2)

doesn't make a difference: because Collection is covariant in E both of the following compile:

fun <E> Collection<E>.myContains(item: E): Boolean = contains(item)

fun <E> itContains(coll: Collection<E>, item: E): Boolean = coll.contains(item)

fun foo() {
    val q: List<Int> = listOf(1, 2, 3)
    q.myContains("1")
    itContains(q, "1")
}

Ah, I see

@Bob Glamm So in

fun <E, T : Collection<E>> Asserter<T>.contain(item: E)

, even though I control the variance of

class Asserter<T>

, the upper bound of

T

is still a covariant

Collection

?

You'd have to ask a type expert, but I think that reasoning is correct

You sounded like one 😉, do you know someone?

Best bet is to hope the JB devs pop in and comment. But no, I'm not a type expert; I just happened to click into

kotlin.Collection

and noticed the variance annotation

Cheers!

🙂

It's pretty simple: you can't enforce this, which is why

kotlin.collections.contains

uses an internal annotation for this:

@kotlin.internal.OnlyInputTypes

.

oh 😞, thank you, subscribed

That funny. This does compile:

fun <E> Collection<E>.myContains(item: E)
        = item in this

it's the usage that works unexpectedly

So I guess that's why it's not available, it violates a bunch of type stuff, it's just a trick.

but without it the language is weaker?

The point is that inlining this function to such a callsite doesn't compile anymore.

hmm

I'm talking about really inlining it,

Ctrl+Alt+N

style.

aaah 😄

I believe the compiler is flagging the error due to the fact that you are calling your extension function on a collection of ints and you are passing a parameter of type string.

fun <T> Collection<T>.myContains(element: T): T = TODO()

interface A
interface B

// interface Collection<out E>
fun foo(x: Collection<A>, b: B) {
    x.myContains(b)
}

In call

x.myContains(b)

compiler should determines type of type variable

T

there is following constraints in this call:

B <: T
Collection<A> <: Collection<T>

for that constraint system exists correct solution:

T == Any

it's correct since

Collection

has

out

variance, it's correct that

Collection<A> <: Collection<Any>

If you write similar example but instead

Collection

will use type invariant type parameter you will get correct type mismatch

@Glen you missed my point there (see OP), I would expect the compiler to flag it, but it doesn't. It compiles just fine and blows at runtime.

Unfortunately there is no good workaround, but we know about that problem and think about it https://youtrack.jetbrains.com/issue/KT-13198

OK @twisterrob. Thanks for clarifying.