Scala講座：函數式語言的體驗
本文節選自最近在日本十分流行的Scala講座系列的第五篇，由JavaEye的fineqtbull翻譯。本系列的作者牛尾剛在日本寫過不少有關Java和Ruby的書籍，相當受歡迎。
序言
這一次講的不是作為Java改良版的Scala語言中所具有強大的純面向對象功能，而是以函數式語言來介紹他。函數本身是對象，他可以被賦值給變量，或者作為方法的參數來傳遞，我們把他作為“第一類對象”來看一下他的處理方法。另外也讓讀者體驗一下函數式語言特有的模式匹配的強大功能。好，讓我們馬上出發，開始我們第三次迷你旅行吧。
Scala的函數定義
在Scala中方法被作為函數用def語句以“def 函數名(參數類表): 返回值 = 函數體”格式來定義。
- def foo(s: String, n: Int): Int = {
- s.length * n
- }
但是函數體僅由單個句子來構成的話可以省略{}。
- def foo(s: String, n: Int): Int = s.length * n
還有，類型推斷對于返回值也是有效的，在允許的情況下是可以省略他的類型的（函數定義中，參數的類型則不可省略）。但是為了理解方便，除了交互式環境下以腳本語言方式使用外，還是作為標記保留下來比較好吧。
- scala> def foo(s: String, n: Int) = s.length * n
- foo: (String,Int)Int
- scala> foo("Zhang Fei", 3)
- res0: Int = 27
為了聲明無返回值的函數可以將返回值定義為Unit。這個與Java中的void相同。
- def bar(s: String, n: Int): Unit = for(i <- 1 to n) print(s)
上述函數的目的是為了執行被認為是副作用的打印n次傳入字符串，所以返回值是Unit。附帶說一下，Unit唯一的實例是用()文本來表示。
引入單例對象內的方法
這些方法一般都定義在類之中，但是如果想單獨使用它的話，通常將其定義在單例對象中。
- object MyFunctions {
- def foo(s: String, n: Int): Int = s.length * n
- def bar(s: String, n: Int): Unit = for(i <- 1 to n) print(s)
- }
為了使用foo或bar這些方法，通常指定單例對象名和方法名來調用他。
- scala> MyFunctions.foo("Zhang Fei", 3)
- res1: Int = 27
- scala> MyFunctions.bar("Zhang Fei", 3)
- Zhang FeiZhang FeiZhang Fei
如下所示將方法引入之后就不用一次一次的指定單例對象名了。下面引入了所有MyFunctions里的方法。
- scala> import MyFunctions._
- import MyFunctions._
- scala> foo("Zhang Fei", 3)
- res0: Int = 27
- scala> bar("Zhang Fei", 3)
- Zhang FeiZhang FeiZhang Fei
匿名函數的定義
到此為止，每一次的函數定義中都指定了函數名，但是如果能不指定函數名就更方便了。因為即使沒有函數名，只要將函數體作為參數來傳遞或賦值給變量之后，該函數實例也就能確定了。這類函數稱為匿名函數（anonymous function），以“參數表 => 函數體”格式來定義。例如可以用如下形式來定義取得字符串長度的函數。
- scala> (s:String) => s.length
如果僅這樣定義的話，該語句結束后該函數就消失了，為了能夠持續使用該函數就需要，或者持續定義該函數并適用他，或者將他賦值給變量，或者將他作為參數傳給別的函數。
- scala> ((s:String) => s.length)( "Zhang Fei") //對字符串直接適用函數文本
- res2: Int = 9
- scala> val ssize = (s:String) => s.length //將函數賦值給變量
- ssize: (String) => Int =
- scala> ssize("Zhang Fei") //用變量來調用函數
- res3: Int = 9
- scala> List("Zhang ", "Fei").map((s:String) => s.length) //對于列表每一項目都適用同一函數文本
- res4: List[Int] = List(6, 3)
- scala> List("Zhang ", "Fei").map(ssize) //對于列表每一項目都適用同一函數變量
- res5: List[Int] = List(6, 3)
上述最后兩個例子中使用了map函數，他對列表中的每一項目都適用作為參數傳入的函數之后將適用結果作為列表返回。函數則是由函數文本(s:String) => s.length或函數變量ssize來指定的。這也是閉包的一個例子，在Scala中用函數來定義閉包。任意的函數都可以作為參數來傳給別的函數。
例如前面的bar函數如下所示
- def bar(s: String, n: Int): Unit = for(i <- 1 to n) print(s)
這也可以用匿名函數來定義，這次是有兩個參數且返回值是Unit的函數。
- scala> val f0 = (s:String, n:Int) => for(i <- 1 to n) print(s)
- f0: (String, Int) => Unit =
這個函數中用for語句進行了n次循環，其實還可以改寫成如下形式。
- def bar(s: String, n: Int): Unit = 1 to n foreach {i => print(s)}
函數體中出現的{i => print(s)}就是以匿名函數形式定義的閉包。1 to n是1.to(n)的簡化形式，然后將閉包作為參數傳遞給剛創建的Range對象的foreach方法（參數i在閉包的函數體中并沒有被使用，僅是為了語法需要）。
在表達式中作為占位符的下劃線
實際上，Scala中備有比匿名函數更簡潔的描述方式。
如下所示，對于“(s:String) => s.length”來說，可以用“_”以“( _:String).length”形式來描述。還有可以用“(_:Int)+(_:Int)”來定義類型為“(Int, Int) => Int”的加法表達式。
- scala> ((_:String).length)("abcde")
- res6: Int = 5
- scala> ((_:Int)+(_:Int))(3, 4)
- res7: Int = 7
- scala> ((_:String).length + (_:Int)) ("abc", 4)
- res8: Int = 7
部分函數的定義
Scala中不僅可以用到現在所看到的式子來定義，還可以通過將具體的實例一排排列出后，用類似于數學中學到的映像圖的形式來描述。聲明了“f1:A=>B”之后可以認為是定義了將類型A映像為類型B的函數f1。實際上這可以認為是將函數定義為類Function1[A, B]的實例（圖 6-１）。
- def f1: Symbol=>Int = {
- case 'a => 1
- case 'b => 2
- case 'c => 3
- }
- scala> f1('c)
- res9: Int = 3
- scala> f1('d)
- scala.MatchError: 'd
- at $anonfun$f1$1.apply(
: 8)- at $anonfun$f1$1.apply(
: 8)- at .
( 10): - at .
( ) - at RequestResult$.
( 3): - at RequestResult$.
( ) - at RequestResult$result(
) - at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
- at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)...
圖 6-１定義為源值域與目標值域映像的函數
函數本來不就因該是這樣的嗎？但是問題是，如果將函數定義域中沒有的參數傳給f1函數后將會拋出例外。為了避免這種情況在對于某一值適用函數前可以先檢查一下該值是否在定義域中。部分函數(PartialFunction)定義為我們提供了這種結構。
- def f2: PartialFunction[Symbol, Int] =
- {case 'a => 1; case 'b => 2; case 'c => 3}
- scala> for(s <- List('a, 'b, 'c, 'd)){ if( f2.isDefinedAt(s) ) println( f2(s) ) }
- 1
- 2
- 3
用部分函數定義了f2:A=>B函數之后，就可以在適用函數前先使用isDefinedAt(x:A)方法來確定定義域
了。所謂的部分函數就是，對于反應源值域到目標值域的映射的函數f:A=>B，不一定存在對應于x<-A的f(x)。反過來如果對于任意的x<-A都存在f(x)的話，那f就稱為全函數。
Scala中方法和函數的關系
Scala即是純面向對象語言又是函數式語言，給人一種朦朧的感覺。所謂的純面向對象就是所有的語言元素都是作為對象來處理的。各個對象所持有的屬性不管是數還是字符串還是數組還是Person等實例都是對象。
因此，當然函數也是對象。實際上函數f: (ArgType1,...ArgTypeN)=>ReturnTyp是以類FunctionN[ArgType1,..., ArgTypeN, ReturnType]的實例形式被定義的。N是表示參數個數的正整數。如果是1個參數的話則是Function1[ArgType1, ReturnType]。
- def double(n:Int):Int = n * 2
上述函數基本上與下述定義是等同的。
- object double extends Function1[Int, Int] {
- def apply(n: Int): Int = n * 2
- }
- scala> double(10)
- res1: Int = 20
那么各個對象的方法也可以稱得上對象嗎？作為測試，試著將MyFunctions對象的方法綁定于變量。
- scala> val f1 = MyFunctions.foo
: 8: error: missing arguments for method foo in object MyFunctions;- follow this method with `_' if you want to treat it as a partially applied funct
- ion
- val f1 = MyFunctions.foo
看來光是方法原樣是不能作為函數對象來處理的。實際上只要將方法簡單地轉換一下就可以作為對象來使用了。在方法名后空一格加上“_”就可以了。
- scala> val f1 = MyFunctions.foo _
- f1: (String, Int) => Int =
- scala> f1("abcde", 3)
- res13: Int = 15
這樣處理之后，我們就可以明白對象的方法也可以像屬性一樣作為對象來統一處理了。Scala語言在這一點上可以說比Smalltalk那種純面向對象語言還貫徹了面向對象的思想。
高階函數和延遲評估參數
因為Scala的函數是對象，所以不要做什么特殊處理只要將他作為參數傳給別的函數就自然而然地成為使用高階函數了。函數將別的函數作為參數來使用，所以稱之為高階函數。這時被傳遞的函數就稱為閉包。
用于List統一操作的函數群就是高階函數的典型例。下面的foreach函數，接受了以()或{}形式定義的閉包作為參數，然后將其逐一適用于接受者列表的所有元素。
- scala> val list = List("Scala", "is", "functional", "language")
- list: List[java.lang.String] = List(Scala, is, functional, language)
- scala> list.foreach { e => println(e) }
- Scala
- is
- functional
- language
對于同一列表list適用map函數后，對于列表list的所有元素適用s => s + “!”函數后將適用結果以列表的形式返回。這里用空格代替了調用方法的“.”，然后用( _ + “!”)替代(s => s + “!”)也是可以的。
- scala> list map(s => s + "!")
- res15: List[java.lang.String] = List(Scala!, is!, functional!, language!)
- scala> list map( _ + "!")
- res16: List[java.lang.String] = List(Scala!, is!, functional!, language!)
進一步，Scala中除了有f1(p1:T1)這種通常的“基于值的參數傳遞(by value parameter)”，還有表示為f2(p2 => T2)的“基于名稱的參數傳遞（by name parameter）”，后者用于參數的延時評估。將這個結構和高階函數相混合后，就可以簡單地定義新的語言控制結構了。下面是新語言結構MyWhile的定義和使用例。
- def MyWhile (p: => Boolean) (s: => Unit) {
- if (p) { s ; MyWhile( p )( s ) }
- }
- scala> var i: Int = 0
- i: Int = 0
- scala> MyWhile(i < 3) {i=i+1; print("World ") }
- World World World
- scala> MyWhile(true) {print(“World is unlimited”) }
- 無限循環
像這樣充分利用了函數式語言的特點之后，我們會驚奇地發現像定義DSL（特定領域語言）那樣進行語言的擴展是多么的容易和自由。
模式匹配
Scala的case語句非常強大，可以處理任何類型的對象。mach{}內部列出了case 模式 => 語句。為了確保覆蓋性可以在末尾加上 _。
- scala> val value: Any = "string"
- value: Any = string
- scala> value match {
- | case null => println("null!")
- | case i: Int => println("Int: " + i)
- | case s: String => println("String: " + s)
- | case _ => println("Others")
- | }
- String: string
這次匹配一下Person類的對象。
- scala> class Person(name:String)
- defined class Person
- scala> val value : Any = new Person("Zhang Fei")
- value: Any = Person@e90097
- scala> value match {
- | case null => println("null!")
- | case i: Int => println("Int: " + i)
- | case s: String => println("String: " + s)
- | case _ => println("Others")
- | }
- Others
Case類
在Scala中模式匹配的不僅是對象，對象的屬性和類型等也可以作為模式來匹配。
例如，假設想匹配Person類，一般情況下最多就是指定“_ : Person”來匹配屬于Person類的對象了。
- scala> val value : Any = new Person("Zhang Fei")
- value: Any = Person@1e3c2c6
- scala> value match {
- | case _ : Person => println("person: who")
- | case _ => println("others: what")
- | }
- person: who
不過如果使用了Case類之后，對象內的公有屬性變得也可以匹配了。定義類時只要把“class”換成“case class”之后，編譯器就會自動定義和生成同名的單例對象。并且在該單例對象中自動定義了返回該類實例的apply方法，以及返回以構造函數的參數為參數的Some類型（范型）對象的unapply（或unapplySeq）方法。并且，還自動定義了equals、hashCode和toString方法。
定義apply方法的效果是，只要定義好某個Case類之后，就可以用“類名（參數列表）”的形式來創建對象了。定義unapply方法后的效果是，可以在case語句中以Case類的構造函數的參數（對象屬性）來作為匹配目標了。
- scala> case class Person(name:String) //定義Case類Person
- defined class Person
- scala> val value : Any = Person("Zhang Fei") //不用new就可以創建對象
- value: Any = Person(Zhang Fei)
- scala> value match {
- | case Person(ns) => println("person:" + ns) //可以將Person的屬性作為匹配目標
- | case _ => println("others: what")
- | }
- person:Zhang Fei //Person的屬性name將會被抽取出來
下面是將將整數N(v)、Add(l, r)和Mult(l, r)組合后來變現四則運算Term。由于是以case形式定義的類，請注意一下在創建Term對象時，不用new就可以直接調用N(5)、Add(…)、Mult(…)實現了。如此使用Scala的模式匹配功能后就可以很方便地實現對象的解析工作了。
- abstract class Term
- case class N (v :Int) extends Term
- case class Add(l :Term, r :Term) extends Term
- case class Mult(l :Term, r :Term) extends Term
- def eval(t :Term) :Int = t match {
- case N (v) => v
- case Add(l, r) => eval(l) + eval(r)
- case Mult(l, r) => eval(l) * eval(r)
- }
- scala> eval(Mult(N (5), Add(N (3), N (4))))
- res7:Int = 35 // 5 * (3 + 4)
附帶說一下，上述的Term類可以認為是作為N、Add和Mult類的抽象數據類型來定義的。
將模式匹配與for語句組合
下面就看一下將模式匹配與for語句組合在一起的技巧。
- scala> val list = List((1, "a"), (2, "b"), (3, "c"), (1, "z"), (1, "a"))
- list: List[(Int, java.lang.String)] = List((1,a), (2,b), (3,c), (1,z), (1,a))
這時在<-前面寫的是像(1, x)一樣的模板。
- scala> for( (1, x) <- list ) yield (1, x)
- res6: List[(Int, java.lang.String)] = List((1,a), (1,z), (1,a))
而且非常令人驚奇的是<-前面沒有變量也是可以的。在<-之前寫上(1, “a”)之后，for語句也可以正常地循環并且正確地返回了兩個元素。
- scala> for( (1, "a") <- list ) yield (1, "a")
- res7: List[(Int, java.lang.String)] = List((1,a), (1,a))
還有在使用Option[T]類來避免判斷null的情況下，傳入List[Option[T]]類型的列表時，不用顯示的判斷是否是Some還是None就可以一下子返回正確的結果了。
- scala> val list = List(Some(1), None, Some(3), None, Some(5))
- list: List[Option[Int]] = List(Some(1), None, Some(3), None, Some(5))
- scala> for(Some(v) <- list) println(v)
- 1
- 3
- 5
接著用以下的例子看一下組合模式匹配和for語句之后所產生的威力。
- scala> val list = List(1, "two", Some(3), 4, "five", 6.0, 7)
- list: List[Any] = List(1, two, Some(3), 4, five, 6.0, 7)
對上述例表中的元素對象類型進行判別后再分類一下吧。模式匹配里不僅可以使用值來作為模式，從下例可知模式還具有對Some（x）形式中的x也起作用的靈活性。
- for(x <- list){ x match{
- case x:Int => println("integer " + x)
- case x:String => println("string " + x)
- case Some(x) => println("some " + x)
- case _ => println("else " + x)
- } }
- scala> for(x <- list){ x match{
- | case x:Int => println("integer " + x)
- | case x:String => println("string " + x)
- | case Some(x) => println("some " + x)
- | case _ => println("else " + x)
- | } }
- integer 1
- string two
- some 3
- integer 4
- string five
- else 6.0
- integer 7
結束語
看了本文之后大家覺得怎么樣呀？應該享受了Scala所具備的，將面向對象式和函數式語言功能充分融合的能力，以及高階函數和模式匹配功能了吧。
Scala語法的初步介紹就到本講為止了，接下來的講座將介紹一下Scala語言更深入的部分。包括隱式轉換、范型和單子等有趣的話題。
【編輯推薦】
