Scala講座：函數(shù)式語(yǔ)言的體驗(yàn)

作者：fineqtbull 2009-12-11 10:44:00

本文選自Scala講座的第五篇的內(nèi)容，介紹了Scala的函數(shù)定義，引入單例對(duì)象內(nèi)的方法，匿名函數(shù)的定義，在表達(dá)式中作為占位符的下劃線，部分函數(shù)的定義，Scala中方法和函數(shù)的關(guān)系，高階函數(shù)和延遲評(píng)估參數(shù)，模式匹配，Case類，將模式匹配與for語(yǔ)句組合，希望大家喜歡。

本文節(jié)選自最近在日本十分流行的Scala講座系列的第五篇，由JavaEye的fineqtbull翻譯。本系列的作者牛尾剛在日本寫過(guò)不少有關(guān)Java和Ruby的書籍，相當(dāng)受歡迎。

序言

這一次講的不是作為Java改良版的Scala語(yǔ)言中所具有強(qiáng)大的純面向?qū)ο蠊δ埽且院瘮?shù)式語(yǔ)言來(lái)介紹他。函數(shù)本身是對(duì)象，他可以被賦值給變量，或者作為方法的參數(shù)來(lái)傳遞，我們把他作為“第一類對(duì)象”來(lái)看一下他的處理方法。另外也讓讀者體驗(yàn)一下函數(shù)式語(yǔ)言特有的模式匹配的強(qiáng)大功能。好，讓我們馬上出發(fā)，開始我們第三次迷你旅行吧。

Scala的函數(shù)定義

在Scala中方法被作為函數(shù)用def語(yǔ)句以“def 函數(shù)名(參數(shù)類表): 返回值 = 函數(shù)體”格式來(lái)定義。

def foo(s: String, n: Int): Int = {  
s.length * n  
}

但是函數(shù)體僅由單個(gè)句子來(lái)構(gòu)成的話可以省略{}。

def foo(s: String, n: Int): Int = s.length * n

還有，類型推斷對(duì)于返回值也是有效的，在允許的情況下是可以省略他的類型的（函數(shù)定義中，參數(shù)的類型則不可省略）。但是為了理解方便，除了交互式環(huán)境下以腳本語(yǔ)言方式使用外，還是作為標(biāo)記保留下來(lái)比較好吧。

scala> def foo(s: String, n: Int) = s.length * n  
foo: (String,Int)Int  
scala> foo("Zhang Fei", 3)  
res0: Int = 27

為了聲明無(wú)返回值的函數(shù)可以將返回值定義為Unit。這個(gè)與Java中的void相同。

def bar(s: String, n: Int): Unit = for(i <- 1 to n) print(s)

上述函數(shù)的目的是為了執(zhí)行被認(rèn)為是副作用的打印n次傳入字符串，所以返回值是Unit。附帶說(shuō)一下，Unit唯一的實(shí)例是用()文本來(lái)表示。

引入單例對(duì)象內(nèi)的方法

這些方法一般都定義在類之中，但是如果想單獨(dú)使用它的話，通常將其定義在單例對(duì)象中。

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這些方法，通常指定單例對(duì)象名和方法名來(lái)調(diào)用他。

scala> MyFunctions.foo("Zhang Fei", 3)  
res1: Int = 27 
scala> MyFunctions.bar("Zhang Fei", 3)  
Zhang FeiZhang FeiZhang Fei

如下所示將方法引入之后就不用一次一次的指定單例對(duì)象名了。下面引入了所有MyFunctions里的方法。

scala> import MyFunctions._  
import MyFunctions._  
scala> foo("Zhang Fei", 3)  
res0: Int = 27 
scala> bar("Zhang Fei", 3)  
Zhang FeiZhang FeiZhang Fei

匿名函數(shù)的定義

到此為止，每一次的函數(shù)定義中都指定了函數(shù)名，但是如果能不指定函數(shù)名就更方便了。因?yàn)榧词箾](méi)有函數(shù)名，只要將函數(shù)體作為參數(shù)來(lái)傳遞或賦值給變量之后，該函數(shù)實(shí)例也就能確定了。這類函數(shù)稱為匿名函數(shù)（anonymous function），以“參數(shù)表 => 函數(shù)體”格式來(lái)定義。例如可以用如下形式來(lái)定義取得字符串長(zhǎng)度的函數(shù)。

scala> (s:String) => s.length

如果僅這樣定義的話，該語(yǔ)句結(jié)束后該函數(shù)就消失了，為了能夠持續(xù)使用該函數(shù)就需要，或者持續(xù)定義該函數(shù)并適用他，或者將他賦值給變量，或者將他作為參數(shù)傳給別的函數(shù)。

scala> ((s:String) => s.length)( "Zhang Fei") //對(duì)字符串直接適用函數(shù)文本  
res2: Int = 9 
 
scala> val ssize = (s:String) => s.length //將函數(shù)賦值給變量  
ssize: (String) => Int =   
scala> ssize("Zhang Fei") //用變量來(lái)調(diào)用函數(shù)  
res3: Int = 9 
scala> List("Zhang ", "Fei").map((s:String) => s.length) //對(duì)于列表每一項(xiàng)目都適用同一函數(shù)文本  
res4: List[Int] = List(6, 3)  
scala> List("Zhang ", "Fei").map(ssize) //對(duì)于列表每一項(xiàng)目都適用同一函數(shù)變量  
res5: List[Int] = List(6, 3)

上述最后兩個(gè)例子中使用了map函數(shù)，他對(duì)列表中的每一項(xiàng)目都適用作為參數(shù)傳入的函數(shù)之后將適用結(jié)果作為列表返回。函數(shù)則是由函數(shù)文本(s:String) => s.length或函數(shù)變量ssize來(lái)指定的。這也是閉包的一個(gè)例子，在Scala中用函數(shù)來(lái)定義閉包。任意的函數(shù)都可以作為參數(shù)來(lái)傳給別的函數(shù)。

例如前面的bar函數(shù)如下所示

def bar(s: String, n: Int): Unit = for(i <- 1 to n) print(s)

這也可以用匿名函數(shù)來(lái)定義，這次是有兩個(gè)參數(shù)且返回值是Unit的函數(shù)。

scala> val f0 = (s:String, n:Int) => for(i <- 1 to n) print(s)  
f0: (String, Int) => Unit =

這個(gè)函數(shù)中用for語(yǔ)句進(jìn)行了n次循環(huán)，其實(shí)還可以改寫成如下形式。

def bar(s: String, n: Int): Unit = 1 to n foreach {i => print(s)}

函數(shù)體中出現(xiàn)的{i => print(s)}就是以匿名函數(shù)形式定義的閉包。1 to n是1.to(n)的簡(jiǎn)化形式，然后將閉包作為參數(shù)傳遞給剛創(chuàng)建的Range對(duì)象的foreach方法（參數(shù)i在閉包的函數(shù)體中并沒(méi)有被使用，僅是為了語(yǔ)法需要）。

在表達(dá)式中作為占位符的下劃線

實(shí)際上，Scala中備有比匿名函數(shù)更簡(jiǎn)潔的描述方式。

如下所示，對(duì)于“(s:String) => s.length”來(lái)說(shuō)，可以用“_”以“( _:String).length”形式來(lái)描述。還有可以用“(_:Int)+(_:Int)”來(lái)定義類型為“(Int, Int) => Int”的加法表達(dá)式。

scala> ((_:String).length)("abcde")  
res6: Int = 5 
scala> ((_:Int)+(_:Int))(3, 4)  
res7: Int = 7 
scala> ((_:String).length + (_:Int)) ("abc", 4)  
res8: Int = 7

部分函數(shù)的定義

Scala中不僅可以用到現(xiàn)在所看到的式子來(lái)定義，還可以通過(guò)將具體的實(shí)例一排排列出后，用類似于數(shù)學(xué)中學(xué)到的映像圖的形式來(lái)描述。聲明了“f1:A=>B”之后可以認(rèn)為是定義了將類型A映像為類型B的函數(shù)f1。實(shí)際上這可以認(rèn)為是將函數(shù)定義為類Function1[A, B]的實(shí)例（圖 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-１定義為源值域與目標(biāo)值域映像的函數(shù)

函數(shù)本來(lái)不就因該是這樣的嗎？但是問(wèn)題是，如果將函數(shù)定義域中沒(méi)有的參數(shù)傳給f1函數(shù)后將會(huì)拋出例外。為了避免這種情況在對(duì)于某一值適用函數(shù)前可以先檢查一下該值是否在定義域中。部分函數(shù)(PartialFunction)定義為我們提供了這種結(jié)構(gòu)。

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

用部分函數(shù)定義了f2:A=>B函數(shù)之后，就可以在適用函數(shù)前先使用isDefinedAt(x:A)方法來(lái)確定定義域

了。所謂的部分函數(shù)就是，對(duì)于反應(yīng)源值域到目標(biāo)值域的映射的函數(shù)f:A=>B，不一定存在對(duì)應(yīng)于x<-A的f(x)。反過(guò)來(lái)如果對(duì)于任意的x<-A都存在f(x)的話，那f就稱為全函數(shù)。

Scala中方法和函數(shù)的關(guān)系

Scala即是純面向?qū)ο笳Z(yǔ)言又是函數(shù)式語(yǔ)言，給人一種朦朧的感覺(jué)。所謂的純面向?qū)ο缶褪撬械恼Z(yǔ)言元素都是作為對(duì)象來(lái)處理的。各個(gè)對(duì)象所持有的屬性不管是數(shù)還是字符串還是數(shù)組還是Person等實(shí)例都是對(duì)象。

因此，當(dāng)然函數(shù)也是對(duì)象。實(shí)際上函數(shù)f: (ArgType1,...ArgTypeN)=>ReturnTyp是以類FunctionN[ArgType1,..., ArgTypeN, ReturnType]的實(shí)例形式被定義的。N是表示參數(shù)個(gè)數(shù)的正整數(shù)。如果是1個(gè)參數(shù)的話則是Function1[ArgType1, ReturnType]。

def double(n:Int):Int = n * 2

上述函數(shù)基本上與下述定義是等同的。

object double extends Function1[Int, Int] {  
def apply(n: Int): Int = n * 2 
}  
scala> double(10)  
res1: Int = 20

那么各個(gè)對(duì)象的方法也可以稱得上對(duì)象嗎？作為測(cè)試，試著將MyFunctions對(duì)象的方法綁定于變量。

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

看來(lái)光是方法原樣是不能作為函數(shù)對(duì)象來(lái)處理的。實(shí)際上只要將方法簡(jiǎn)單地轉(zhuǎn)換一下就可以作為對(duì)象來(lái)使用了。在方法名后空一格加上“_”就可以了。

scala> val f1 = MyFunctions.foo _  
f1: (String, Int) => Int =   
scala> f1("abcde", 3)  
res13: Int = 15

這樣處理之后，我們就可以明白對(duì)象的方法也可以像屬性一樣作為對(duì)象來(lái)統(tǒng)一處理了。Scala語(yǔ)言在這一點(diǎn)上可以說(shuō)比Smalltalk那種純面向?qū)ο笳Z(yǔ)言還貫徹了面向?qū)ο蟮乃枷搿?/P>

高階函數(shù)和延遲評(píng)估參數(shù)

因?yàn)镾cala的函數(shù)是對(duì)象，所以不要做什么特殊處理只要將他作為參數(shù)傳給別的函數(shù)就自然而然地成為使用高階函數(shù)了。函數(shù)將別的函數(shù)作為參數(shù)來(lái)使用，所以稱之為高階函數(shù)。這時(shí)被傳遞的函數(shù)就稱為閉包。

用于List統(tǒng)一操作的函數(shù)群就是高階函數(shù)的典型例。下面的foreach函數(shù)，接受了以()或{}形式定義的閉包作為參數(shù)，然后將其逐一適用于接受者列表的所有元素。

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

對(duì)于同一列表list適用map函數(shù)后，對(duì)于列表list的所有元素適用s => s + “!”函數(shù)后將適用結(jié)果以列表的形式返回。這里用空格代替了調(diào)用方法的“.”，然后用( _ + “!”)替代(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!)

進(jìn)一步，Scala中除了有f1(p1:T1)這種通常的“基于值的參數(shù)傳遞(by value parameter)”，還有表示為f2(p2 => T2)的“基于名稱的參數(shù)傳遞（by name parameter）”，后者用于參數(shù)的延時(shí)評(píng)估。將這個(gè)結(jié)構(gòu)和高階函數(shù)相混合后，就可以簡(jiǎn)單地定義新的語(yǔ)言控制結(jié)構(gòu)了。下面是新語(yǔ)言結(jié)構(gòu)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”) }  
無(wú)限循環(huán)

像這樣充分利用了函數(shù)式語(yǔ)言的特點(diǎn)之后，我們會(huì)驚奇地發(fā)現(xiàn)像定義DSL（特定領(lǐng)域語(yǔ)言）那樣進(jìn)行語(yǔ)言的擴(kuò)展是多么的容易和自由。

模式匹配

Scala的case語(yǔ)句非常強(qiáng)大，可以處理任何類型的對(duì)象。mach{}內(nèi)部列出了case 模式 => 語(yǔ)句。為了確保覆蓋性可以在末尾加上 _。

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類的對(duì)象。

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中模式匹配的不僅是對(duì)象，對(duì)象的屬性和類型等也可以作為模式來(lái)匹配。

例如，假設(shè)想匹配Person類，一般情況下最多就是指定“_ : Person”來(lái)匹配屬于Person類的對(duì)象了。

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

不過(guò)如果使用了Case類之后，對(duì)象內(nèi)的公有屬性變得也可以匹配了。定義類時(shí)只要把“class”換成“case class”之后，編譯器就會(huì)自動(dòng)定義和生成同名的單例對(duì)象。并且在該單例對(duì)象中自動(dòng)定義了返回該類實(shí)例的apply方法，以及返回以構(gòu)造函數(shù)的參數(shù)為參數(shù)的Some類型（范型）對(duì)象的unapply（或unapplySeq）方法。并且，還自動(dòng)定義了equals、hashCode和toString方法。

定義apply方法的效果是，只要定義好某個(gè)Case類之后，就可以用“類名（參數(shù)列表）”的形式來(lái)創(chuàng)建對(duì)象了。定義unapply方法后的效果是，可以在case語(yǔ)句中以Case類的構(gòu)造函數(shù)的參數(shù)（對(duì)象屬性）來(lái)作為匹配目標(biāo)了。

scala> case class Person(name:String) //定義Case類Person  
defined class Person  
scala> val value : Any = Person("Zhang Fei") //不用new就可以創(chuàng)建對(duì)象  
value: Any = Person(Zhang Fei)  
scala> value match {  
| case Person(ns) => println("person:" + ns) //可以將Person的屬性作為匹配目標(biāo)  
| case _ => println("others: what")  
| }  
person:Zhang Fei //Person的屬性name將會(huì)被抽取出來(lái)

下面是將將整數(shù)N(v)、Add(l, r)和Mult(l, r)組合后來(lái)變現(xiàn)四則運(yùn)算Term。由于是以case形式定義的類，請(qǐng)注意一下在創(chuàng)建Term對(duì)象時(shí)，不用new就可以直接調(diào)用N(5)、Add(…)、Mult(…)實(shí)現(xiàn)了。如此使用Scala的模式匹配功能后就可以很方便地實(shí)現(xiàn)對(duì)象的解析工作了。

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)

附帶說(shuō)一下，上述的Term類可以認(rèn)為是作為N、Add和Mult類的抽象數(shù)據(jù)類型來(lái)定義的。

將模式匹配與for語(yǔ)句組合

下面就看一下將模式匹配與for語(yǔ)句組合在一起的技巧。

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))

這時(shí)在<-前面寫的是像(1, x)一樣的模板。

scala> for( (1, x) <- list ) yield (1, x)  
res6: List[(Int, java.lang.String)] = List((1,a), (1,z), (1,a))

而且非常令人驚奇的是<-前面沒(méi)有變量也是可以的。在<-之前寫上(1, “a”)之后，for語(yǔ)句也可以正常地循環(huán)并且正確地返回了兩個(gè)元素。

scala> for( (1, "a") <- list ) yield (1, "a")  
res7: List[(Int, java.lang.String)] = List((1,a), (1,a))

還有在使用Option[T]類來(lái)避免判斷null的情況下，傳入List[Option[T]]類型的列表時(shí)，不用顯示的判斷是否是Some還是None就可以一下子返回正確的結(jié)果了。

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語(yǔ)句之后所產(chǎn)生的威力。

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)

對(duì)上述例表中的元素對(duì)象類型進(jìn)行判別后再分類一下吧。模式匹配里不僅可以使用值來(lái)作為模式，從下例可知模式還具有對(duì)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