藝術地說，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 < 0 => -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風格的代碼，使其更加靈活且可讀?！禗SL 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](http://twitter.github.io/effectivescala/#Functional programming-Partial functions)給出的案例：
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。
