Scala教程之:深入了解協變和逆變

文章目錄

• 函數的參數和傳回值
• 可變類型的變異

在之前的文章中我們簡單的介紹過scala中的協變和逆變，我們使用+ 來表示協變類型；使用-表示逆變類型；非轉化類型不需要添加标記。

假如我們定義一個class C[+A] {} ,這裡A的類型參數是協變的，這就意味着在方法需要參數是C[AnyRef]的時候，我們可以是用C[String]來代替。

同樣的道理如果我們定義一個class C[-A] {}, 這裡A的類型是逆變的，這就意味着在方法需要參數是C[String]的時候，我們可以用C[AnyRef]來代替。

注意：變異标記隻有在類型聲明中的類型參數裡才有意義，對參數化的方法沒有意義，因為該标記影響的是子類繼承行為，而方法沒有子類。例如List.map 方法的簡化簽名：

sealed abstract class List[+A] ... { // 忽略了混入的trait
...
def map[B](f: A => B): List[B] = {...}
...
}
           

這裡方法map的類型參數B是不能使用變異标記的，如果你修改其變異标記，則會傳回編譯錯誤。

現在我們讨論scala中函數參數的一個非常重要的結論：函數的參數必須是逆變的，而傳回值必須是協變的

為什麼呢？

接下來我們考慮scala内置的帶一個參數的函數類型Function1,其簡化的定義如下:

trait Function1[-T1, +R] extends AnyRef { self =>
  /** Apply the body of this function to the argument.
   *  @return   the result of function application.
   */
  def apply(v1: T1): R

...

  override def toString() = "<function1>"
}
           

我們知道類似 A=>B 的形式在scala中是可以自動被轉換為Function1的形式。

scala> var f: Int=>Int = i=>i+1
f: Int => Int = <function1>
           

實際上其會被轉換成為如下的形式：

val f: Int => Int = new Function1[Int,Int] {
def apply(i: Int): Int = i + 1
}
           

假如我們定義了三個class 如下：

class CSuper { def msuper() = println("CSuper") } 
class C extends CSuper { def m() = println("C") }
class CSub extends C { def msub() = println("CSub") }
           

我們可以定義如下幾個f:

var f: C => C = (c: C) => new C // ➋
f = (c: CSuper) => new CSub // ➌
f = (c: CSuper) => new C // ➍
f = (c: C) => new CSub // ➎
f = (c: CSub) => new CSuper // ➏ 編譯錯誤!
           

根據Function1[-T1, +R]的定義，2-5可以通過編譯，而6會編譯失敗。

怎麼了解6呢？ 這裡我們要區分兩個概念，函數的定義類型和函數的運作類型。

這裡f的定義類型是 C=>C。 當f = (c: CSub) => new CSuper時，它的實際apply方法就是：

def apply(i: CSub): CSuper = new CSuper
           

CSub=>CSuper就是f的運作類型。

在apply中可以能調用到CSub特有的方法，例如：msub（），而傳回的CSuper又缺少了C中的方法 m()。

如果使用者在調用該f的時候，還是按照定義的類型傳入C，并且期待傳回的值是C時候，就會發生錯誤。 因為實際的類型是按照傳入CSub和傳回CSuper來定義的。

如果實際的函數類型為（x:CSuper）=> Csub，該函數不僅可以接受任何C 類值作為參數，也可以處理C 的父類型的執行個體，或其父類型的其他子類型的執行個體（如果存在的話）。是以，由于隻傳入C 的執行個體，我們永遠不會傳入超出f 允許範圍外的參數。從某種意義上說，f 比我們需要的更加“寬容”。

同樣，當它隻傳回Csub 時，這也是安全的。因為調用方可以處理C 的執行個體，是以也一定可以處理CSub 的執行個體。在這個意義上說，f 比我們需要的更加“嚴格”。

如果函數的參數使用了協變，傳回值使用了逆變則會編譯失敗：

scala> trait MyFunction2[+T1, +T2, -R] {
| def apply(v1:T1, v2:T2): R = ???
| }
<console>:37: error: contravariant type R occurs in covariant position
in type (v1: T1, v2: T2)R of method apply
def apply(v1:T1, v2:T2): R = ???
^
<console>:37: error: covariant type T1 occurs in contravariant position
in type T1 of value v1
def apply(v1:T1, v2:T2): R = ???
^
<console>:37: error: covariant type T2 occurs in contravariant position
in type T2 of value v2
def apply(v1:T1, v2:T2): R = ???
^
           

上面我們講的情況下，class的參數化類型是不可變的，如果class的參數類型是可變的話，會是什麼樣的情況呢？

scala> class ContainerPlus[+A](var value: A)
<console>:34: error: covariant type A occurs in contravariant position
in type A of value value_=
class ContainerPlus[+A](var value: A)
^
scala> class ContainerMinus[-A](var value: A)
<console>:34: error: contravariant type A occurs in covariant position
in type => A of method value
class ContainerMinus[-A](var value: A)
           

通過上面的例子，我們也可以得到一個結論，可變參數化類型是不能變異的。

假如可變參數是協變的ContainerPlus[+A]，那麼對于：

val cp: ContainerPlus[C]=new ContainerPlus(new CSub)
           

定義的類型是C,但是運作時類型是CSub,如果需要對類型變量重新指派時就會遇到将C指派給CSub的情況，會出現編譯錯誤。

如果可變參數是逆變的ContainerPlus[-A]，那麼對于：

val cm: ContainerMinus[C] = new ContainerMinus(new CSuper)
           

定義的類型是C，但是運作時類型是CSuper，那麼對于期望的傳回類型是C，但是實際傳回類型是CSuper，也會發生錯誤。

是以可變參數化類型是不能變異的。

更多教程請參考 flydean的部落格