topic: Generics

class Box<T>(t: T) {
    var value = t
}

val box: Box<Int> = Box<Int>(1)

val box = Box(1) // 1 has type Int, so the compiler figures out that we are talking about Box<Int>

// Java
List < String > strs = new ArrayList < String >();
List < Object > objs = strs; // !!! The cause of the upcoming problem sits here. Java prohibits this!
objs.add(1); // Here we put an Integer into a list of Strings
String s = strs.get(0); // !!! ClassCastException: Cannot cast Integer to String

// Java
interface Collection<E> ... {
  void addAll(Collection<E> items);
}

// Java
void copyAll(Collection<Object> to, Collection<String> from) {
  to.addAll(from);
  // !!! Would not compile with the naive declaration of addAll:
  // Collection<String> is not a subtype of Collection<Object>
}

// Java
interface Collection<E> ... {
  void addAll(Collection<? extends E> items);
}

List<? super String> a supertype of List<Object>.

List<? super String> 

List<? extends Foo>

// Java
interface Source<T> {
  T nextT();
}

// Java
void demo(Source<String> strs) {
  Source<Object> objects = strs; // !!! Not allowed in Java
  // ...
}

Source<? extends Object>

interface Source<out T> {
    fun nextT(): T
}
​
fun demo(strs: Source<String>) {
    val objects: Source<Any> = strs // This is OK, since T is an out-parameter
    // ...
}

interface Comparable<in T> {
    operator fun compareTo(other: T): Int
}
​
fun demo(x: Comparable<Number>) {
    x.compareTo(1.0) // 1.0 has type Double, which is a subtype of Number
    // Thus, we can assign x to a variable of type Comparable<Double>
    val y: Comparable<Double> = x // OK!
}

class Array<T>(val size: Int) {
    fun get(index: Int): T { ... }
    fun set(index: Int, value: T) { ... }
}

fun copy(from: Array<Any>, to: Array<Any>) {
    assert(from.size == to.size)
    for (i in from.indices)
        to[i] = from[i]
}

val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3) { "" } 
copy(ints, any)
//   ^ type is Array<Int> but Array<Any> was expected

fun copy(from: Array<out Any>, to: Array<Any>) { ... }

fun fill(dest: Array<in String>, value: String) { ... }

interface Function<in T, out U> 

- Function<*, String> means Function<in Nothing, String>;
- Function<Int, *> means Function<Int, out Any?>;
- Function<*, *> means Function<in Nothing, out Any?>.

fun <T> singletonList(item: T): List<T> {
    // ...
}
​
fun <T> T.basicToString(): String {  // extension function
    // ...
}

val l = singletonList<Int>(1)

val l = singletonList(1)

fun <T : Comparable<T>> sort(list: List<T>) {  ... }

sort(listOf(1, 2, 3)) // OK. Int is a subtype of Comparable<Int>
sort(listOf(HashMap<Int, String>())) // Error: HashMap<Int, String> is not a subtype of Comparable<HashMap<Int, String>>

fun <T> copyWhenGreater(list: List<T>, threshold: T): List<String>
    where T : CharSequence,
          T : Comparable<T> {
    return list.filter { it > threshold }.map { it.toString() }
}

inline fun <reified T> doSomethingWithType(obj: T) {
    val typeName = T::class.java
    println(typeName)
}

fun main(args: Array<String>) {
    doSomethingWithType(String())
}

private static final void doSomethingWithType(Object obj) {
  Intrinsics.reifiedOperationMarker(4, "T");
  Class typeName = Object.class;
  System.out.println(typeName);
}

public static final void main(@NotNull String[] args) {
  Intrinsics.checkParameterIsNotNull(args, "args");
  new String();
  Class typeName$iv = String.class;
  System.out.println(typeName$iv);
}