Generics

A List can hold numbers, words or really anything. That’s why we call the List generic.

Generics are basically used to define which types a class can hold and which type an object currently holds.

Declaration-site variance

Declaration-site variance can be thought of as declaration of use-site variance once and for all the use-sites.

 class Consumer<in T> { fun consume(t: T) { ... } }

  fun charSequencesConsumer() : Consumer<CharSequence>() = ...

  val stringConsumer : Consumer<String> = charSequenceConsumer() // OK since in-projection
  val anyConsumer : Consumer<Any> = charSequenceConsumer() // Error, Any cannot be passed

  val outConsumer : Consumer<out CharSequence> = ... // Error, T is `in`-parameter

Widespread examples of declaration-site variance are List<out T>, which is immutable so that T only appears as the return value type, and Comparator<in T>, which only receives T as argument.

Use-site variance

Use-site variance is similar to Java wildcards:

Out-projection:

 val takeList : MutableList<out SomeType> = ... // Java: List<? extends SomeType>

  val takenValue : SomeType = takeList[0] // OK, since upper bound is SomeType

  takeList.add(takenValue) // Error, lower bound for generic is not specified

In-projection:

 val putList : MutableList<in SomeType> = ... // Java: List<? super SomeType>

  val valueToPut : SomeType = ...
  putList.add(valueToPut) // OK, since lower bound is SomeType

  putList[0] // This expression has type Any, since no upper bound is specified

Star-projection

 val starList : MutableList<*> = ... // Java: List<?>

  starList[0] // This expression has type Any, since no upper bound is specified
  starList.add(someValue) // Error, lower bound for generic is not specified

See also:

[Variant Generics](https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#variant-generics) interoperability when calling Kotlin from Java.

Syntax

• class ClassName<TypeName>
• class ClassName<*>
• ClassName<in UpperBound>
• ClassName<out LowerBound>
• class Name<TypeName:UpperBound>

Parameters

|Parameter|Details |---|---|---|---|---|---|---|---|---|--- |TypeName|Type Name of generic parameter |UpperBound|Covariant Type |LowerBound|Contravariant Type |ClassName|Name of the class

Remarks

Implied Upper Bound is Nullable

In Kotlin Generics, the upper bound of type parameter T would be Any?. Therefore for this class:

class Consumer<T>

The type parameter T is really T: Any?. To make a non-nullable upper bound, explicitly specific T: Any. For example:

class Consumer<T: Any>