when I declare a class

MyClass

and an interface

MyInterface

and have several classes extending and implementing them, Kotlin infers both the class and the interface in generic types. For example

val list = listOf(ImplemA(), implemB())

contains objects that are

MyClass

and comply with

MyInterface

. IDEA describes the bound as

<{MyClass & MyInterface}>

in that case. Can I specify a type like that explicitly, without creating a new class? What's the catch?

Like where?

If the same type parameter needs more than one upper bound, you need a separate where -clause:

fun <T> copyWhenGreater(list: List<T>, threshold: T): List<String>

where T : CharSequence,

T : Comparable<T> {

return list.filter { it > threshold }.map { it.toString() }

}

The passed type must satisfy all conditions of the where clause simultaneously. In the above example, the T type must implement both CharSequence and Comparable.

No, I know that. I'm talking about this case:

open class MyClass(val value: Int)
interface MyInterface {
    fun someMethod()
}

class ImplA : MyClass(2), MyInterface {
    override fun someMethod() {
        println("I am A")
    }
}

class ImplB : MyClass(5), MyInterface {
    override fun someMethod() {
        println("I am B")
    }
}

fun main() {
    val impls = listOf(ImplA(), ImplB()) // this a List<{MyClass & MyInterface}>

    for (ele in impls) {
        ele.someMethod()
        println("Its value is ${ele.value}")
    }
}

You can not declare intersection type explicitly. It is not-denotable type (e.g. like

String!

from java) and such types can be produced only by type inference https://youtrack.jetbrains.com/issue/KT-13108