CodeGym /課程 /Kotlin SELF /Type projections:安全的 Array<out/in> 與 MutableList 的投影

Type projections:安全的 Array<out/in> 與 MutableList 的投影

Kotlin SELF
等級 36, 課堂 2
開放

1. 前言

如果把生活簡化到「編譯器別太聰明」的程度,那當然會想直接寫 as 然後繼續過日子。 但 Kotlin 正是在試著救我們,避免出現「程式能編譯,卻在執行期某個離案發地點很遠的地方崩潰」的情況——而且還一副「我其實早就警告過你」的表情。

問題在於:有些容器天生就是「既讀又寫」。 對這種容器,你無法在類別宣告上老實地標成 out 或 in——否則它會失去一半的意義。 經典例子就是 Array<T>:既能用索引讀取,也能用索引寫入。 Kotlin 會直接用這個例子來說明:為什麼 Array 是不變的,以及如何用投影來解決。

Type projections 是一種折衷:我們不改 Array 這個類別,但在某個特定函式中「縮減」它的能力,讓編譯器可以保證型別安全。

2. 為什麼 Array<T> 是不變的

對陣列很容易掉進「反正是容器,就應該像 List 一樣」的陷阱。 但 Kotlin 的 List 是「只讀」介面,而 Array 是真正的「可用索引存取的盒子」:既能看,也能塞回去東西。

簡化來看,可以把 Array<T> 想成有這些操作:

operator fun get(index: Int): T
operator fun set(index: Int, value: T)

正因如此,Kotlin 不能把 Array 做成協變(像 List 那樣),否則就可能寫入錯誤的型別。 這也是為什麼單純的「從 Array<Int> copy 到 Array<Any>」在沒有額外技巧時無法編譯。

來親身感受一下。

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

fun main() {
    val ints: Array<Int> = arrayOf(1, 2, 3)
    val any: Array<Any> = arrayOf("x", "y", "z")

    // copyNaive(ints, any) // 無法編譯:Array<Int> 不是 Array<Any>
}

而這其實是好事:如果編譯器允許了,理論上在 copyNaive 裡就可能做出 from[0] = "oops" (也就是把 String 寫進 Int 的陣列)。 Kotlin 會事先阻擋這類錯誤。

3. Array 的投影:out 與 in

投影 Array<out X>:來源陣列

當你在函式參數寫下 Array<out Any>,你是在告訴編譯器: 「我拿到的是一個保證包含至少是 Any 的元素的陣列,但我承諾:我不會往裡面寫入。」 也就是說,這個陣列透過此引用變成 producer 物件——值的來源。

重點在於其背後哲學: Array<out Any> 不是一種新的陣列型別。 它仍是同一個陣列,但透過這個引用你無法使用危險的寫入操作(或在型別上變得不可能)。

Kotlin 在官方對 type projections 的說明中,正是使用「從一個我們不應修改的陣列中複製」這個想法。

寫一個安全的 copyToAny

做一個謹慎的 copy,其中 from 只能讀取。

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

fun main() {
    val ints: Array<Int> = arrayOf(1, 2, 3)
    val dest: Array<Any> = Array(3) { "?" }

    copyToAny(ints, dest)

    println(dest.joinToString()) // 1, 2, 3
}

注意這個看起來不像魔法的「魔法」: 我們把 Array<Int> 傳到了需要 Array<out Any> 的地方。 這之所以可行,是因為 Kotlin 現在能確信:我們不會對 from 做寫入, 因此也不可能用 String 的寫入去「弄壞」Int 的陣列。 這正是 use-site variance / type projection 的意義。

在 Array<out X> 中哪些事情會被禁止

如果你很想測試編譯器的耐心,可以試試:

fun breakIt(from: Array<out Any>) {
    // from[0] = "boom" // 無法編譯
}

這不是「Kotlin 在刁難」。Kotlin 只是在老實履行契約: out 投影代表「可以讀,但不能寫」。

投影 Array<in X>:接收陣列

接著看鏡像情境。有時候我們需要陣列不是當來源,而是當接收端: 我們想把它填滿。此時我們在乎的是 set,而讀取是次要的。

Array<in String> 可以讀成:「某種 String 的父型別的陣列,我可以安全地把字串放進去。」

用字串填滿陣列:fillWithOk

fun fillWithOk(dest: Array<in String>) {
    for (i in dest.indices) {
        dest[i] = "ok"
    }
}

fun main() {
    val anyArray: Array<Any> = Array(3) { 0 }
    fillWithOk(anyArray)

    println(anyArray.joinToString()) // ok, ok, ok
}

為什麼安全?因為 Array<Any> 的確能存放 String: 字串就是 Any。

為什麼從 Array<in X> 讀取會變得更「貧乏」

這裡有個很多人會覺得惱人的點(然後會習慣,接著開始對其他事情惱人)。

如果我們有 Array<in String>, 那就不能把它當成能讀出 String:因為它實際上可能是 Array<Any>,裡面可能不只有字串。 所以安全的讀取通常只能得到 Any?。

fun showFirst(dest: Array<in String>) {
    val x: Any? = dest[0]
    println("first = $x") // first = ...
}

fun main() {
    val anyArray: Array<Any> = arrayOf(10, 20, 30)
    showFirst(anyArray) // first = 10
}

再強調一次:這不是刁難,而是保證。in 的契約說: 「我可以寫入 String」,但不承諾裡面原本放了什麼、也不承諾那些值的型別。

4. MutableList 的投影:out 與 in

陣列搞懂了,接著來看更貼近實務的:MutableList。 它在語意上「既讀又寫」,因此也不能「直接」做成協變。 但在函式參數中,我們常把 MutableList 用在兩種模式之一:

  1. 當元素來源(讀取,但不修改);
  2. 當接收端(新增元素)。

這時 use-site variance 就非常有幫助: MutableList<out T> 以及 MutableList<in T>。

別搞混:我們不是把 MutableList 永久做成協變。 我們是在說:「在這個函式裡,把它當成 producer / consumer 來對待。」

MutableList<out Number>:讀取數字,不新增

假設我們有 MutableList<Int>,但函式希望用 Number 來工作。 沒有投影時你會撞上型別不相容(可變集合是不變的), 但加上 out 投影後,只要你不新增元素,就一切正常。

fun sumFirstTwo(list: MutableList<out Number>): Double {
    val a = list[0].toDouble()
    val b = list[1].toDouble()
    return a + b
    // list.add(1) // 無法編譯:out 投影禁止寫入
}

fun main() {
    val ints: MutableList<Int> = mutableListOf(10, 20, 30)

    println(sumFirstTwo(ints)) // 30.0
}

這裡 Kotlin 讓我們避免一個微妙錯誤:如果允許寫入,我們就可能把 Double 加到 Int 的列表裡, 整個型別模型就會「走鐘」。

MutableList<in Int>:把 Int 加進合適的列表

現在反過來:函式必須新增 Int。同時,如果它也能接受更一般的列表會更好, 例如 MutableList<Number>。

fun addOne(list: MutableList<in Int>) {
    list.add(1)
}

fun main() {
    val numbers: MutableList<Number> = mutableListOf(10, 2.5)

    addOne(numbers)

    println(numbers) // [10, 2.5, 1]
}

這個契約的意思是:既然列表保證能接收 Int,那它的元素型別必然是 Int 或任何父型別 (Number、Any)。這就是 consumer 的邏輯。

5. out 與 in 速查表

剛開始使用投影時,大腦會先抗議:「為什麼我不能想怎樣就怎樣」。 為了讓大腦不要離職,最好準備一張短表。

讀完這段之後,每次編譯器跟你說「不行」時,你都可以回來查它。

參數中的投影 概念 適合做的事 Kotlin 刻意讓你做起來更困難的事
Array<out T> / MutableList<out T>
來源 讀取 T 寫入 T
Array<in T> / MutableList<in T>
接收端 寫入 T 以 T 讀取(通常只能讀成 Any?)

這套邏輯直接源自 type projections(use-site variance)的概念,以及 Kotlin 對可能破壞型別安全的操作會直接禁止。

6. 範例:Finance Tracker 與 MutableList 上的投影

為了不把主題停留在「抽象的狗與貓」,我們把投影放進一段更接近現實的程式碼。

想像我們有一個主控台應用程式 Finance Tracker,用來儲存金融操作。 我們已經會儲存物件集合、撰寫函式並使用繼承,因此建立一個操作的基底型別與兩個子型別。

open class Operation(
    val amount: Double,
    val note: String,
)

class Expense(amount: Double, note: String) : Operation(amount, note)
class Income(amount: Double, note: String) : Operation(amount, note)

列印操作:producer MutableList<out Operation>

這個函式只需要讀取操作並輸出,不需要修改列表,否則它會變得太「霸道」。

fun printOperations(ops: MutableList<out Operation>) {
    for (op in ops) {
        println("${op::class.simpleName}: ${op.amount} (${op.note})")
        // Output example: Expense: 12.5 (coffee)
    }
}

fun main() {
    val expenses: MutableList<Expense> = mutableListOf(
        Expense(12.5, "coffee"),
        Expense(40.0, "groceries"),
    )

    printOperations(expenses)
}

為什麼這很重要?因為沒有 out 的話,你無法把 MutableList<Expense> 傳到 需要「操作列表」的地方。而加上 out,你就明確宣告:這個列表在此被當成來源使用。

新增支出:consumer MutableList<in Expense>

接著是相反任務:函式要新增支出。如果它不只能新增到 MutableList<Expense>, 也能新增到通用日誌 MutableList<Operation>,就更實用。

fun addExpense(ops: MutableList<in Expense>, amount: Double, note: String) {
    ops.add(Expense(amount, note))
}

fun main() {
    val journal: MutableList<Operation> = mutableListOf(
        Income(1000.0, "salary"),
    )

    addExpense(journal, 12.5, "coffee")

    printOperations(journal)
    // Income: 1000.0 (salary)
    // Expense: 12.5 (coffee)
}

從型別角度來說:MutableList<Operation> 是很好的 Expense 接收端, 因為 Expense 是 Operation。

7. 投影限制的是「引用的 API」,不是物件本身

常見誤解:以為 Array<out Any> 是某種「特殊陣列」。 但實際上陣列還是同一個。改變的只是:你透過這個變數被允許做什麼。

可以把它想成一張小示意圖:

flowchart LR
    A["真實物件:Array⟨Int⟩"]
    B["引用型別為 Array⟨out Any⟩"]
    C["引用型別為 Array⟨Int⟩"]

    A --> B
    A --> C

    B -->|"可以讀取(Any)"| R["get(i)"]
    B -.->|"不能寫入"| W["set(i, ...)"]

    C -->|"可以讀取(Int)"| R2["get(i)"]
    C -->|"可以寫入(Int)"| W2["set(i, Int)"]

從這個角度看,投影是一種很「工程化」的工具。 你不需要重寫資料模型;你只是對編譯器提出清楚限制:「在這個函式裡我會乖一點」。

8. 常見錯誤

錯誤 #1:嘗試往 Array<out …> 或 MutableList<out …> 裡「再寫入」。
通常表現是:你已經把參數謹慎宣告成 producer,但在函式內又突然想「我就加一點點」。 編譯器不會讓你這麼做,而且它是對的:如果你能把 MutableList<Int> 以 MutableList<out Number> 傳進來, 那寫入 2.5 會造成邏輯上的災難。

錯誤 #2:期待能從 Array<in …> 像從 Array<T> 一樣讀取。
若參數宣告為 consumer,Kotlin 會刻意讓讀取變得「不舒服」:安全的讀取型別通常會是 Any? 之類。 這是正常的。如果你同時需要以 T 讀取又要寫入 T,那就不是 consumer/producer 的情境——也許投影不適合用在這裡。

錯誤 #3:用 as 來解決泛型型別不相容,而不是用投影。
當你只想「讓它能編譯」,手就會想伸向 as。但在泛型中,型別轉換常把編譯期錯誤變成執行期驚喜。 投影的好處在於:它不會把問題藏起來,而是逼你誠實描述契約:「只讀」或「只寫」。

錯誤 #4:把投影和型別宣告處的 out/in 混為一談。
在型別宣告中使用 out 與 in,是你對類別/介面做出的設計決策(「這個型別天生是 producer」)。 在函式參數中的投影則是局部解法(「在這個函式裡我把容器當成 producer/consumer」)。 實務上這是不同層級的東西,建議心裡要能明確自言自語:「我現在是在設計型別,還是只是在寫一個安全的函式簽名」。

錯誤 #5:想寫一個同時讀又同時寫的萬用函式。
有時候會想「既要複製,又要順便改一點」,而且希望參數型別越寬越好。 但不變性正是在提醒你:如果你同時要讀與寫——請接受精確型別 (Array<T>、MutableList<T>)。 若想接受更寬的型別,就必須犧牲一些東西(通常是寫入能力或讀取的精確型別)。

1
任務
Kotlin SELF, 等級 36, 課堂 2
上鎖
搬運箱子
搬運箱子
1
任務
Kotlin SELF, 等級 36, 課堂 2
上鎖
填充標籤
填充標籤
1
任務
Kotlin SELF, 等級 36, 課堂 2
上鎖
感測器讀值匯總
感測器讀值匯總
1
任務
Kotlin SELF, 等級 36, 課堂 2
上鎖
追加數字
追加數字
留言
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION