TIL

아이템 24 제네릭 타입과 variance 한정자를 활용하라

class Cup<T>

• 위 코드에서 T는 variance 한정자(out 또는 in)이 없기에 invariant(불공변성)이다.
  • 불공변이라는 것은 제네릭 타입 간 서로 관련성이 없다는 의미이다.
  • Cup<Int>와 Cup<Number>, Cup<Any>는 서로 관련이 없다.
• 관련성이 필요하다면 variance 한정자를 붙여야 하는데 서브타입만 제네릭 타입으로 허용하려면 out 한정자가 필요하다.
  • A가 B의 서브타입일 때 Cup<A>가 Cup<B>이 서브타입이 된다.
  • 이는 convariant(공변성)이라 말한다.

open class Dog
class Puppy: Dog()

class Cup<out T>

val b: Cup<Dog> = Cup<Puppy> // OK
val a: Cup<Puppy> = Cup<Dog>() // error

• in 한정자는 반대 의미로 constravariant(반변성)으로 만든다.
  • A가 B의 서브타입일 때 Cup<A>가 Cup<B>의 슈퍼타입이 된다.

class Cup<in T>

val b: Cup<Dog> = Cup<Puppy> // error
val a: Cup<Puppy> = Cup<Dog>() // ok

함수 타입

• 코틀린 타입 시스템에선 파라미터 타입은 더 높은 타입으로, 리턴 타입은 더 낮은 타입으로 이동한다.
  • 코틀린 함수 타입의 모든 파라미터 타입은 contravariant
  • 코틀린의 모든 리턴 타입은 convariant이다.
  • Int → Number → Any 타입 순으로 더 상위 타입인 걸 염두하고 (Int) → Any 타입의 함수를 생각해보자.

fun printProcessedNumber(transaction: (Int) -> Any) {
	print(transaction(42))
}

val intToDouble: (Int) -> Number = { it.toDouble() }
val numberAsText: (Number) -> Any = { it.toShort() }
val identity: (Number) -> Number = { it }

printProcessedNumber(intToDouble)
printProcessedNumber(numberAsText)
printProcessedNumber(identity)

variance 한정자의 안정성

자바 배열과 코틀린 배열

• 자바 배열은 convariant인데 이는 자바의 명백한 결함이다.

Integer[] numbers = {1, 4, 2, 1};
Object[] objects = numbers; // convariant이기에 서브타입 취급하여 할당 가능
objects[2] = "B"; // 런타임 오류: ArrayStoreException

• 코틀린은 이를 해결하기 위해 Array를 invariant로 만들었다.
  • Array<Int>를 Array<Any> 등으로 바꿀 수 없다.

convariant(out) 타입 파라미터와 public in 위치

• out 한정자가 붙은 타입 파라미터를 in 위치(함수 파라미터 등)에 쓸 수 있다면, 업캐스팅을 통해 타입 안정성이 깨질 수 있기 때문에 에러가 발생한다.

class Box<out T> {
	private var value: T? = null
	
	fun set(value: T) { // 코틀린에서 컴파일 오류 발생!
		this.value = value
	}
}

• 만약 이를 가능하게 하면 아래 상황이 발생한다.

val dogHouse = Box<Dog>()
val box: Box<Any> = dogHouse // Puppy는 Any의 서브 타입이기에 할당 가능 (convariant)
box.set("Some string") // ?
box.set(42) // ?

• 캐스팅 후에 실질적인 객체가 그대로 유지되고, 타이핑 시스템에서만 다르게 처리되기 때문
  • Int나 String을 설정하려고 하지만 해당 위치는 Dog만을 위한 자리다.
• 다만 가시성을 private으로 제한하면 오류가 발생하지 않는다.
  • 객체 내부에선 업캐스트 객체에 convariant 한정자를 사용할 수 없기 때문

class Box<out T> {
	private var value: T? = null
	
	private fun set(value: T) {
		this.value = value
	}
}

• convariant(out 한정자)는 public out 한정자 위치에선 안전하기에 제한되지 않는다.
• ex) List<T>
  • 코틀린의 List<T>는 interface List<out T>로 정의되어 있다.
  • 여기서 out T는 T가 반환 위치(out position)에만 쓰인다는 의미
  • 즉, 리스트에서 값을 꺼낼 수만 있고, 값을 넣을 수는 없다.
  • 따라서 List<Int>를 List<Number>로 안전하게 업캐스팅할 수 있다.
    • 예: val numbers: List<Number> = listOf(1, 2, 3)
• ex) MutableList<T>
  • MutableList<T>는 interface MutableList<T>로 정의되어 있고, out 또는 in 한정자가 없다.
  • T가 입력 위치(in position, 예: add/set 메서드의 파라미터)와 반환 위치(out position, 예: get 메서드의 반환값) 모두에 사용된다.
  • 만약 MutableList<Int>를 MutableList<Number>로 업캐스팅하면, MutableList<Number>에서 Float 값을 추가할 수 있게 되어 타입 안정성이 깨진다.
  • 그래서 MutableList<T>는 invariant으로 설계되어, 타입이 정확히 일치할 때만 대입이 가능하다.

contravariant(in) 타입 파라미터와 public out 위치

• in 한정자를 메서드 리턴 타입(out 위치)에도 쓸 수 없다.
  • 만약 반환 타입(out 위치)에 in 한정자 타입 파라미터를 사용하면, 실제로 어떤 타입이 반환될지 보장할 수 없으므로 타입 안정성이 깨진다.

class Box<in T> {
	val value: T // 에러
}

val noSpot: Box<Nothing> = Box<Car>(Car())
val boat: Nothing = noSpot.value // Car를 위한 공간이다

• 이 또한 private일 땐 문제가 되지 않는다.

class Box<in T> {
	private val value: T
}

variance 한정자의 위치

• variance 한정자는 크게 두 위치에서 사용할 수 있다.

선언 부분

• 클래스와 인터페이스 선언에 한정자가 적용된다.
• 클래스와 인터페이스가 사용되는 모든 곳에 영향을 준다.

// 선언 쪽
class Box<out T>(val value: T)

val boxStr: Box<String> Box("Str")
val boxAny: Box<Any> boxStr

클래스와 인터페이스를 활용하는 부분

• 특정 변수에만 variance 한정자가 적용된다.
• 모든 인스턴스가 아닌 특정 인스턴스에만 적용해야할 때 사용한다.

class Box<T>(val value: T)

val boxStr: Box<String> = Box("Str")

// 사용하는 쪽
val boxAny: Box<out Any> = boxStr

• 참고로 variance 한정자를 사용하면 위치가 제한될 수 있다.
  • 만약 MutableList<out T>라면 (원랜 불공변임) get하면 T 타입이 나오겠지만 set은 Nothing 타입 아규먼트도 전달 가능해지기에 사용할 수 없다.
  • 만약 MutableList<in T>라면 get과 set 모두 사용 가능하지만 get의 경우 Any? 타입이 반환되는데 이는 모든 타입의 슈퍼타입을 가진 리스트가 존재할 가능성이 있기 때문이다.

정리

코틀린은 타입 아규먼트 관계에 제약을 걸 수 있는 강력한 제네릭 타입을 제공한다.

• 타입 파라미터의 기본적인 variance 동작은 invariant
• out 한정자로 타입 파라미터를 convariant하게 만들고 convariant 타입은 out 위치에 사용 가능하다.
• in 한정자는 타입 파라미터를 contravariant하게 만들고 contravariant 타입은 in 위치에 사용 가능하다.

코틀린에서는

• List와 Set, Map 타입 파라미터는 convariant
• MutableList, MutableSet, MutableMap 타입 파라미터는 invariant
• 함수 타입의 파라미터 타입은 contravariant이고 리턴 타입은 convariant
• 리턴만 되는 타입에는 convariant(out 한정자)를 사용
• 허용만 되는 타입에는 contravariant(in 한정자)를 사용