藝術地說，Scala中的Partial Function就是一個“殘缺”的函數，就像一個嚴重偏科的學生，只對某些科目感興趣，而對沒有興趣的內容棄若蔽履。Partial Function做不到以“偏”概全，因而需要將多個偏函數組合，最終才能達到全面覆蓋的目的。所以這個Partial Function確實是一個“部分”的函數。

對比Function和Partial Function，更學術味的解釋如下：

• 對給定的輸入參數類型，函數可接受該類型的任何值。換句話說，一個(Int) => String 的函數可以接收任意Int值，并返回一個字符串。
• 對給定的輸入參數類型，偏函數只能接受該類型的某些特定的值。一個定義為(Int) => String 的偏函數可能不能接受所有Int值為輸入。

在Scala中，所有偏函數的類型皆被定義為PartialFunction[-A, +B]類型，PartialFunction[-A, +B]又派生自Function1。由于它僅僅處理輸入參數的部分分支，因而它通過isDefineAt()來判斷輸入值是否應該由當前偏函數進行處理。PartialFunction的定義如下所示：

trait PartialFunction[-A, +B] extends (A => B) { self => 
  import PartialFunction._ 
  def isDefinedAt(x: A): Boolean 
  def applyOrElse[A1 <: A, B1 >: B](x: A1, default: A1 => B1): B1 = 
    if (isDefinedAt(x)) apply(x) else default(x) 
} 

既然偏函數僅處理部分分支，自然可以與模式匹配結合起來。case語句從本質上講就是PartialFunction的子類。當我們定義了如下值：

val p:PartialFunction[Int, String] = { case 1 => "One" } 

實際上就是創建了一個PartialFunction[Int, String]的子類，其中isDefineAt方法提供類似這樣的實現：

def isDefineAt(x: Int):Boolean = x == 1 

當我們通過p(1)去調用該偏函數時，就相當于調用了Int => String函數的apply()方法，從而返回轉換后的值“one”。如果傳入的參數使得isDifineAt返回false，就會拋出MatchError異常。追本溯源，是因為這里對偏函數值的調用，實則是調用了AbstractPartialFunction的apply()方法(case語句相當于是繼承AbstractPartialFunction的子類)：

abstract class AbstractPartialFunction[ 
@specialized(scala.Int, scala.Long, scala.Float, scala.Double, scala.AnyRef) -T1,  
@specialized(scala.Unit, scala.Boolean, scala.Int, scala.Float, scala.Long, scala.Double, scala.AnyRef) +R]  
extends Function1[T1, R] with PartialFunction[T1, R] { self => 
    def apply(x: T1): R = applyOrElse(x, PartialFunction.empty) 
} 

apply()方法內部調用了PartialFunction的applyOrElse()方法。若isDefineAt(x)返回為false，就會將x值傳遞給PartialFunction.empty。這個empty等于類型為PartialFunction[Any, Nothong]的值empty_pf，定義如下：

private[this] val empty_pf: PartialFunction[Any, Nothing] = new PartialFunction[Any, Nothing] { 
   def isDefinedAt(x: Any) = false 
   def apply(x: Any) = throw new MatchError(x) 
   override def orElse[A1, B1](that: PartialFunction[A1, B1]) = that 
   override def andThen[C](k: Nothing => C) = this 
   override val lift = (x: Any) => None 
   override def runWith[U](action: Nothing => U) = constFalse 
 } 

這正是執行p(2)會拋出MatchError的由來。

為什么要用偏函數呢?以我個人愚見，還是一個重用粒度的問題。函數式的編程思想是以一種“演繹法”而非“歸納法”去尋求解決空間。也就是說，它并不是要去歸納問題然后分解問題并解決問題，而是看透問題本質，定義最原初的操作和組合規則，面對問題時，可以通過組合各種函數去解決問題，這也正是“組合子(combinator)”的含義。偏函數則更進一步，將函數求解空間中各個分支也分離出來，形成可以被組合的偏函數。

偏函數中最常見的組合方法為orElse、andThen與compose。orElse相當于一個或運算，如果通過它將多個偏函數組合起來，就相當于形成了多個case合成的模式匹配。倘若所有偏函數滿足了輸入值的所有分支，組合起來就形成一個函數了。例如寫一個求絕對值的運算，就可以利用偏函數：

val positiveNumber:PartialFunction[Int, Int] = {  
    case x if x > 0 => x  
} 
val zero:PartialFunction[Int, Int] = {  
    case x if x == 0 => 0  
} 
val negativeNumber:PartialFunction[Int, Int] = {  
    case x if x < 00 => -x  
} 
def abs(x: Int): Int = { 
    (positiveNumber orElse zero orElse negativeNumber)(x) 
} 

利用orElse組合時，還可以直接組合case語句，例如：

val pf: PartialFunction[Int, String] = { 
  case i if i%2 == 0 => "even" 
} 
val tf: (Int => String) = pf orElse { case _ => "odd" } 

orElse被定義在PartialFunction類型中，而andThen與compose卻不同，它們實則被定義在Function中，PartialFunction只是重寫了這兩個方法。這意味著函數之間的組合可以使用andThen與compose，偏函數也可以。這兩個方法的功能都是將多個(偏)函數組合起來形成一個新函數，只是組合的順序不同，andThen是組合***個，接著是第二個，依次類推;而compose則順序相反。

利用andThen組合偏函數，設計本質接近Pipe-and-Filter模式，每個偏函數都可以理解為是一個Filter。因為要將這些偏函數組合起來形成一個管道，這就要求被組合的偏函數其輸入值與輸出值必須支持可串接，即上一個偏函數的輸出值會作為下一個偏函數的輸入值。對比orElse，則有所不同，orElse要求組合的所有偏函數必須是同樣類型的偏函數定義，例如都是Int => String，或者String => CustomizedClass。

在PartialFunction中，andThen方法返回的是一個名為AndThen的偏函數：

trait PartialFunction[-A, +B] extends (A => B) { 
  override def andThen[C](k: B => C): PartialFunction[A, C] = 
    new AndThen[A, B, C] (this, k) 
} 
object PartialFunction { 
  private class AndThen[-A, B, +C] (pf: PartialFunction[A, B], k: B => C) extends PartialFunction[A, C] { 
    def isDefinedAt(x: A) = pf.isDefinedAt(x) 
    def apply(x: A): C = k(pf(x)) 
    override def applyOrElse[A1 <: A, C1 >: C](x: A1, default: A1 => C1): C1 = { 
      val z = pf.applyOrElse(x, checkFallback[B]) 
      if (!fallbackOccurred(z)) k(z) else default(x) 
    } 
  } 
} 

注意看，andThen接收的參數為k: B => C，即函數類型而非偏函數類型。當然，由于偏函數繼承自函數，它也可以組合偏函數。如果andThen組合了偏函數，則要求輸入參數必須滿足所有參與組合的偏函數，否則就會拋出MatchError錯誤。例如編寫一個函數，要求將字符串中的數字替換為對應的英文單詞，則可以實現為：

val p1:PartialFunction[String, String] = {  
    case s if s.contains("1") => s.replace("1", "one")  
} 
val p2:PartialFunction[String, String] = {  
    case s if s.contains("2") => s.replace("2", "two")  
} 
val p = p1 andThen p2 

如果調用p("123")，返回結果為"onetwo3"，但如果傳入p("13")，由于p2偏函數的isDefineAt返回false，就會拋出MatchError錯誤。

偏函數可以用在很多場景。例如我們可以利用orElse之類的語義，編寫DSL風格的代碼，使其更加靈活且可讀。《DSL in Action》一書中就是用了orElse來處理金融行業的需求：

val forHKG:PartialFunction[Market, List[TaxFee]] = ... 
val forSGP:PartialFunction[Market, List[TaxFee]] = ... 
val forAll:PartialFunction[Market, List[TaxFee]] = ... 
 
def forTrade(trade: Trade): List[TaxFee] =  
    (forHKG orElse forSGP orElse forAll)(trade.market) 

也可以有效地利用偏函數的開放性，使得API的調用者可以根據具體的需求場景傳入自己的case語句。例如Twitter的Effective Scala給出的案例：

trait Publisher[T] { 
  def subscribe(f: PartialFunction[T, Unit]) 
} 
val publisher: Publisher[Int] = ... 
 
publisher.subscribe { 
  case i if isPrime(i) => println("found prime", i) 
  case i if i%2 == 0 => count += 2 
  /* ignore the rest */ 
} 

定義在AKKA的Actor中的receive()方法也是一個偏函數：

trait Actor { 
    type Receive = Actor.Receive 
    def receive: Actor.Receive 
} 
object Actor { 
  type Receive = PartialFunction[Any, Unit] 
} 

由于偏函數繼承自函數，因而，如果一個方法要求接收函數，那么它也可以接收偏函數。例如我們常常使用的map、filter等方法，就可以接收偏函數：

val sample = 1 to 10 
sample map { 
    case x if x % 2 == 0 => x + " is even" 
    case x if x % 2 == 1 => x + " is odd" 
} 

在Twitter的Effetive Scala中，給出了一個使用map的編碼風格建議：

//avoid 
list map { item => 
  item match { 
    case Some(x) => x 
    case None => default 
  } 
} 
//recommend 
list map { 
  case Some(x) => x 
  case None => default 
} 

從本質上講，假設這個list的類型為List[Option[String]]，則前者傳給map的其實是一個形如Option[String] => String的函數，后者則通過case語句創建了PartialFunction[Option[String], String]的實例傳遞給了map。

【本文為51CTO專欄作者“張逸”原創稿件，轉載請聯系原作者】

戳這里，看該作者更多好文