第七章 Haskell模塊

裝載模塊

haskell中的模塊是含有一組相關(guān)的函數(shù)，類型和類型類的組合。而haskell程序的本質(zhì)便是從主模塊中引用其它模塊并調(diào)用其中的函數(shù)來執(zhí)行操作。這樣可以把代碼分成多塊，只要一個模塊足夠的獨立，它里面的函數(shù)便可以被不同的程序反復(fù)重用。這就讓不同的代碼各司其職，提高了代碼的健壯性。

haskell的標(biāo)準(zhǔn)庫就是一組模塊，每個模塊都含有一組功能相近或相關(guān)的函數(shù)和類型。有處理List的模塊，有處理并發(fā)的模塊，也有處理復(fù)數(shù)的模塊，等等。目前為止我們談及的所有函數(shù),類型以及類型類都是Prelude模塊的一部分，它默認(rèn)自動裝載。在本章，我們看一下幾個常用的模塊，在開始瀏覽其中的函數(shù)之前，我們先得知道如何裝載模塊.

在haskell中，裝載模塊的語法為import，這必須得在函數(shù)的定義之前，所以一般都是將它置于代碼的頂部。無疑，一段代碼中可以裝載很多模塊，只要將import語句分行寫開即可。裝載Data.List試下，它里面有很多實用的List處理函數(shù).

執(zhí)行import Data.List，這樣一來Data.List中包含的所有函數(shù)就都進(jìn)入了全局命名空間。也就是說，你可以在代碼的任意位置調(diào)用這些函數(shù).Data.List模塊中有個nub函數(shù)，它可以篩掉一個List中的所有重復(fù)元素。用點號將length和nub組合:length . nub，即可得到一個與(\xs -> length (nub xs))等價的函數(shù)。

import Data.List   

numUniques :: (Eq a) => [a] -> Int   
numUniques = length . nub

你也可以在GHCi中裝載模塊，若要調(diào)用Data.List中的函數(shù)，就這樣:

ghci> :m Data.List

若要在GHci中裝載多個模塊，不必多次:m命令，一下就可以全部搞定:

ghci> :m Data.List Data.Map Data.Set

而你的程序中若已經(jīng)有包含的代碼，就不必再用:m了.

如果你只用得到某模塊的兩個函數(shù)，大可僅包含它倆。若僅裝載Data.List模塊nub和sort，就這樣:

import Data.List (nub，sort)

也可以只包含除去某函數(shù)之外的其它函數(shù)，這在避免多個模塊中函數(shù)的命名沖突很有用。假設(shè)我們的代碼中已經(jīng)有了一個叫做nub的函數(shù)，而裝入Data.List模塊時就要把它里面的nub除掉.

import Data.List hiding (nub)

避免命名沖突還有個方法，便是qualified import，Data.Map模塊提供一了一個按鍵索值的數(shù)據(jù)結(jié)構(gòu)，它里面有幾個和Prelude模塊重名的函數(shù)。如filter和null，裝入Data.Map模塊之后再調(diào)用filter，haskell就不知道它究竟是哪個函數(shù)。如下便是解決的方法:

import qualified Data.Map

這樣一來，再調(diào)用Data.Map中的filter函數(shù)，就必須得Data.Map.filter，而filter依然是為我們熟悉喜愛的樣子。但是要在每個函數(shù)前面都加個Data.Map實在是太煩人了! 那就給它起個別名，讓它短些:

import qualified Data.Map as M

好，再調(diào)用Data.Map模塊的filter函數(shù)的話僅需M.filter就行了

要瀏覽所有的標(biāo)準(zhǔn)庫模塊，參考這個手冊。翻閱標(biāo)準(zhǔn)庫中的模塊和函數(shù)是提升個人haskell水平的重要途徑。你也可以各個模塊的源代碼，這對haskell的深入學(xué)習(xí)及掌握都是大有好處的.

檢索函數(shù)或搜尋函數(shù)位置就用Hoogle，相當(dāng)了不起的Haskell搜索引擎! 你可以用函數(shù)名，模塊名甚至類型聲明來作為檢索的條件.

Data.List

顯而易見，Data.List是關(guān)于List操作的模塊，它提供了一組非常有用的List處理函數(shù)。在前面我們已經(jīng)見過了其中的幾個函數(shù)(如map和filter)，這是Prelude模塊出于方便起見，導(dǎo)出了幾個Data.List里的函數(shù)。因為這幾個函數(shù)是直接引用自Data.List，所以就無需使用qulified import。在下面，我們來看看幾個以前沒見過的函數(shù):

intersperse取一個元素與List作參數(shù)，并將該元素置于List中每對元素的中間。如下是個例子:

ghci> intersperse '.' "MONKEY"   
"M.O.N.K.E.Y"   
ghci> intersperse 0 [1,2,3,4,5,6]   
[1,0,2,0,3,0,4,0,5,0,6]

intercalate取兩個List作參數(shù)。它會將第一個List交叉插入第二個List中間，并返回一個List.

ghci> intercalate " " ["hey","there","guys"]   
"hey there guys"   
ghci> intercalate [0,0,0] [[1,2,3],[4,5,6],[7,8,9]]   
[1,2,3,0,0,0,4,5,6,0,0,0,7,8,9]

transpose函數(shù)可以反轉(zhuǎn)一組List的List。你若把一組List的List看作是個2D的矩陣，那transpose的操作就是將其列為行。

ghci> transpose [[1,2,3],[4,5,6],[7,8,9]]   
[[1,4,7],[2,5,8],[3,6,9]]   
ghci> transpose ["hey","there","guys"]   
["htg","ehu","yey","rs","e"]

假如有兩個多項式3x2+ 5x + 9，_10x3 + 9_和8x3 + 5x2 + x - 1，將其相加，我們可以列三個List:[0,3,5,9]，[10,0,0,9]和[8,5,1,-1]來表示。再用如下的方法取得結(jié)果.

ghci> map sum $ transpose [[0,3,5,9],[10,0,0,9],[8,5,1,-1]]   
[18,8,6,17]

使用transpose處理這三個List之后，三次冪就倒了第一行，二次冪到了第二行，以此類推。在用sum函數(shù)將其映射，即可得到正確的結(jié)果。

foldl'和foldl1'是它們各自惰性實現(xiàn)的嚴(yán)格版本。在用fold處理較大的List時，經(jīng)常會遇到堆棧溢出的問題。而這罪魁禍?zhǔn)拙褪莊old的惰性: 在執(zhí)行fold時，累加器的值并不會被立即更新，而是做一個"在必要時會取得所需的結(jié)果"的承諾。每過一遍累加器，這一行為就重復(fù)一次。而所有的這堆"承諾"最終就會塞滿你的堆棧。嚴(yán)格的fold就不會有這一問題，它們不會作"承諾"，而是直接計算中間值的結(jié)果并繼續(xù)執(zhí)行下去。如果用惰性fold時經(jīng)常遇到溢出錯誤，就應(yīng)換用它們的嚴(yán)格版。

concat把一組List連接為一個List。

ghci> concat ["foo","bar","car"]   
"foobarcar"   
ghci> concat [[3,4,5],[2,3,4],[2,1,1]]   
[3,4,5,2,3,4,2,1,1]

它相當(dāng)于移除一級嵌套。若要徹底地連接其中的元素，你得concat它兩次才行.

concatMap函數(shù)與map一個List之后再concat它等價.

ghci> concatMap (replicate 4) [1..3]   
[1,1,1,1,2,2,2,2,3,3,3,3]

and取一組布爾值List作參數(shù)。只有其中的值全為True的情況下才會返回True。

ghci> and $ map (>4) [5,6,7,8]   
True   
ghci> and $ map (==4) [4,4,4,3,4]   
False

or與and相似，一組布爾值List中若存在一個True它就返回True.

ghci> or $ map (==4) [2,3,4,5,6,1]   
True   
ghci> or $ map (>4) [1,2,3]   
False

any和all取一個限制條件和一組布爾值List作參數(shù)，檢查是否該List的某個元素或每個元素都符合該條件。通常較map一個List到and或or而言，使用any或all會更多些。

ghci> any (==4) [2,3,5,6,1,4]   
True   
ghci> all (>4) [6,9,10]   
True   
ghci> all (`elem` ['A'..'Z']) "HEYGUYSwhatsup"   
False   
ghci> any (`elem` ['A'..'Z']) "HEYGUYSwhatsup"   
True

iterate取一個函數(shù)和一個值作參數(shù)。它會用該值去調(diào)用該函數(shù)并用所得的結(jié)果再次調(diào)用該函數(shù)，產(chǎn)生一個無限的List.

ghci> take 10 $ iterate (*2) 1   
[1,2,4,8,16,32,64,128,256,512]   
ghci> take 3 $ iterate (++ "haha") "haha"   
["haha","hahahaha","hahahahahaha"]

splitAt取一個List和數(shù)值作參數(shù)，將該List在特定的位置斷開。返回一個包含兩個List的二元組.

ghci> splitAt 3 "heyman"   
("hey","man")   
ghci> splitAt 100 "heyman"   
("heyman","")   
ghci> splitAt (-3) "heyman"   
("","heyman")   
ghci> let (a,b) = splitAt 3 "foobar" in b ++ a   
"barfoo"

takeWhile這一函數(shù)十分的實用。它從一個List中取元素，一旦遇到不符合條件的某元素就停止.

ghci> takeWhile (>3) [6,5,4,3,2,1,2,3,4,5,4,3,2,1]   
[6,5,4]   
ghci> takeWhile (/=' ') "This is a sentence"   
"This"

如果要求所有三次方小于1000的數(shù)的和，用filter來過濾map (^3) [1..]所得結(jié)果中所有小于1000的數(shù)是不行的。因為對無限List執(zhí)行的filter永遠(yuǎn)都不會停止。你已經(jīng)知道了這個List是單增的，但haskell不知道。所以應(yīng)該這樣：

ghci> sum $ takeWhile (10000) $ map (^3) [1..]   
53361

用(^3)處理一個無限List，而一旦出現(xiàn)了大于10000的元素這個List就被切斷了，sum到一起也就輕而易舉.

dropWhile與此相似，不過它是扔掉符合條件的元素。一旦限制條件返回False，它就返回List的余下部分。方便實用!

ghci> dropWhile (/=' ') "This is a sentence"   
" is a sentence"   
ghci> dropWhile (3) [1,2,2,2,3,4,5,4,3,2,1]   
[3,4,5,4,3,2,1]

給一Tuple組成的List，這Tuple的首相表示股票價格，第二三四項分別表示年,月,日。我們想知道它是在哪天首次突破$1000的!

ghci> let stock = [(994.4,2008,9,1),(995.2,2008,9,2),(999.2,2008,9,3),(1001.4,2008,9,4),(998.3,2008,9,5)]   
ghci> head (dropWhile (\(val,y,m,d) -> val 1000) stock)   
(1001.4,2008,9,4)

span與takeWhile有點像，只是它返回兩個List。第一個List與同參數(shù)調(diào)用takeWhile所得的結(jié)果相同，第二個List就是原List中余下的部分。

ghci> let (fw，rest) = span (/=' ') "This is a sentence" in "First word:" ++ fw ++ "，the rest:" ++ rest   
"First word: This，the rest: is a sentence"

span是在條件首次為False時斷開list，而break則是在條件首次為True時斷開List。break p與span (not 。p)是等價的.

ghci> break (==4) [1,2,3,4,5,6,7]   
([1,2,3],[4,5,6,7])   
ghci> span (/=4) [1,2,3,4,5,6,7]   
([1,2,3],[4,5,6,7])

break返回的第二個List就會以第一個符合條件的元素開頭。

sort可以排序一個List，因為只有能夠作比較的元素才可以被排序，所以這一List的元素必須是Ord類型類的實例類型。

ghci> sort [8,5,3,2,1,6,4,2]   
[1,2,2,3,4,5,6,8]   
ghci> sort "This will be sorted soon"   
" Tbdeehiillnooorssstw"

group取一個List作參數(shù)，并將其中相鄰并相等的元素各自歸類，組成一個個子List.

ghci> group [1,1,1,1,2,2,2,2,3,3,2,2,2,5,6,7]   
[[1,1,1,1],[2,2,2,2],[3,3],[2,2,2],[5],[6],[7]]

若在group一個List之前給它排序就可以得到每個元素在該List中的出現(xiàn)次數(shù)。

ghci> map (\l@(x:xs) -> (x,length l)) . group . sort $ [1,1,1,1,2,2,2,2,3,3,2,2,2,5,6,7]   
[(1,4),(2,7),(3,2),(5,1),(6,1),(7,1)]

inits和tails與init和tail相似，只是它們會遞歸地調(diào)用自身直到什么都不剩，看:

ghci> inits "w00t"   
["","w","w0","w00","w00t"]   
ghci> tails "w00t"   
["w00t","00t","0t","t",""]   
ghci> let w = "w00t" in zip (inits w) (tails w)   
[("","w00t"),("w","00t"),("w0","0t"),("w00","t"),("w00t","")]

我們用fold實現(xiàn)一個搜索子List的函數(shù):

search :: (Eq a) => [a] -> [a] -> Bool   
search needle haystack =   
  let nlen = length needle   
  in foldl (\acc x -> if take nlen x == needle then True else acc) False (tails haystack)

首先，對搜索的List調(diào)用tails，然后遍歷每個List來檢查它是不是我們想要的.

ghci> "cat" `isInfixOf` "im a cat burglar"   
True   
ghci> "Cat" `isInfixOf` "im a cat burglar"   
False   
ghci> "cats" `isInfixOf` "im a cat burglar"   
False

由此我們便實現(xiàn)了一個類似isIndexOf的函數(shù)，isInfixOf從一個List中搜索一個子List，若該List包含子List，則返回True.

isPrefixOf與isSuffixOf分別檢查一個List是否以某子List開頭或者結(jié)尾.

ghci> "hey" `isPrefixOf` "hey there!"   
True   
ghci> "hey" `isPrefixOf` "oh hey there!"   
False   
ghci> "there!" `isSuffixOf` "oh hey there!"   
True   
ghci> "there!" `isSuffixOf` "oh hey there"   
False

elem與notElem檢查一個List是否包含某元素.

partition取一個限制條件和List作參數(shù)，返回兩個List，第一個List中包含所有符合條件的元素，而第二個List中包含余下的.

ghci> partition (`elem` ['A'..'Z']) "BOBsidneyMORGANeddy"   
("BOBMORGAN","sidneyeddy")   
ghci> partition (>3) [1,3,5,6,3,2,1,0,3,7]   
([5,6,7],[1,3,3,2,1,0,3])

了解span和break的差異是很重要的.

ghci> span (`elem` ['A'..'Z']) "BOBsidneyMORGANeddy"   
("BOB","sidneyMORGANeddy")

span和break會在遇到第一個符合或不符合條件的元素處斷開，而partition則會遍歷整個List。

find取一個List和限制條件作參數(shù)，并返回首個符合該條件的元素，而這個元素是個Maybe值。在下章，我們將深入地探討相關(guān)的算法和數(shù)據(jù)結(jié)構(gòu)，但在這里你只需了解Maybe值是Just something或Nothing就夠了。與一個List可以為空也可以包含多個元素相似，一個Maybe可以為空，也可以是單一元素。同樣與List類似，一個Int型的List可以寫作Int，Maybe有個Int型可以寫作Maybe Int。先試一下find函數(shù)再說.

ghci> find (>4) [1,2,3,4,5,6]   
Just 5   
ghci> find (>9) [1,2,3,4,5,6]   
Nothing   
ghci> :t find   
find :: (a -> Bool) -> [a] -> Maybe a

注意一下find的類型，它的返回結(jié)果為Maybe a··，這與a的寫法有點像，只是Maybe型的值只能為空或者單一元素，而List可以為空,一個元素，也可以是多個元素.

想想前面那段找股票的代碼，head (dropWhile (\(val,y,m,d) -> val < 1000) stock)。但head并不安全! 如果我們的股票沒漲過$1000會怎樣?dropWhile會返回一個空List，而對空List取head就會引發(fā)一個錯誤。把它改成find (\(val,y,m,d) -> val > 1000) stock就安全多啦，若存在合適的結(jié)果就得到它,像Just (1001.4,2008,9,4)，若不存在合適的元素(即我們的股票沒有漲到過$1000)，就會得到一個Nothing.

elemIndex與elem相似，只是它返回的不是布爾值，它只是'可能'(Maybe)返回我們找的元素的索引，若這一元素不存在，就返回Nothing。

ghci> :t elemIndex   
elemIndex :: (Eq a) => a -> [a] -> Maybe Int   
ghci> 4 `elemIndex` [1,2,3,4,5,6]   
Just 3   
ghci> 10 `elemIndex` [1,2,3,4,5,6]   
Nothing

elemIndices與elemIndex相似，只不過它返回的是List，就不需要Maybe了。因為不存在用空List就可以表示，這就與Nothing相似了.

ghci> ' ' `elemIndices` "Where are the spaces?"   
[5,9,13]

findIndex與find相似，但它返回的是可能存在的首個符合該條件元素的索引。findIndices會返回所有符合條件的索引.

ghci> findIndex (==4) [5,3,2,1,6,4]   
Just 5   
ghci> findIndex (==7) [5,3,2,1,6,4]   
Nothing   
ghci> findIndices (`elem` ['A'..'Z']) "Where Are The Caps?"   
[0,6,10,14]

在前面，我們講過了zip和zipWidth，它們只能將兩個List組到一個二元組數(shù)或二參函數(shù)中，但若要組三個List該怎么辦? 好說~有zip3,zip4,,,,和zipWith3,zipWidth4...直到7。這看起來像是個hack，但工作良好。連著組8個List的情況很少遇到。還有個聰明辦法可以組起無限多個List，但限于我們目前的水平，就先不談了.

ghci> zipWith3 (\x y z -> x + y + z) [1,2,3] [4,5,2,2] [2,2,3]   
[7,9,8]   
ghci> zip4 [2,3,3] [2,2,2] [5,5,3] [2,2,2]   
[(2,2,5,2),(3,2,5,2),(3,2,3,2)]

與普通的zip操作相似，以返回的List中長度最短的那個為準(zhǔn).

在處理來自文件或其它地方的輸入時，lines會非常有用。它取一個字符串作參數(shù)。并返回由其中的每一行組成的List.

ghci> lines "first line\nsecond line\nthird line"   
["first line","second line","third line"]

'\n'表示unix下的換行符，在haskell的字符中，反斜杠表示特殊字符.

unlines是lines的反函數(shù)，它取一組字符串的List，并將其通過'\n'合并到一塊.

ghci> unlines ["first line"，"second line"，"third line"]   
"first line\nsecond line\nthird line\n"

words和unwords可以把一個字符串分為一組單詞或執(zhí)行相反的操作，很有用.

ghci> words "hey these are the words in this sentence"   
["hey","these","are","the","words","in","this","sentence"]   
ghci> words "hey these are the words in this\nsentence"   
["hey","these","are","the","words","in","this","sentence"]   
ghci> unwords ["hey","there","mate"]   
"hey there mate"

我們前面講到了nub，它可以將一個List中的重復(fù)元素全部篩掉，使該List的每個元素都如雪花般獨一無二，'nub'的含義就是'一小塊'或'一部分'，用在這里覺得很古怪。我覺得，在函數(shù)的命名上應(yīng)該用更確切的詞語，而避免使用老掉牙的過時詞匯.

ghci> nub [1,2,3,4,3,2,1,2,3,4,3,2,1]   
[1,2,3,4]   
ghci> nub "Lots of words and stuff"   
"Lots fwrdanu"

delete取一個元素和List作參數(shù)，會刪掉該List中首次出現(xiàn)的這一元素.

ghci> delete 'h' "hey there ghang!"   
"ey there ghang!"   
ghci> delete 'h' 。delete 'h' $ "hey there ghang!"   
"ey tere ghang!"   
ghci> delete 'h' 。delete 'h' 。delete 'h' $ "hey there ghang!"   
"ey tere gang!"

\表示List的差集操作，這與集合的差集很相似，它會除掉左邊List中所有存在于右邊List中的元素.

ghci> [1..10] \\ [2,5,9]   
[1,3,4,6,7,8,10]   
ghci> "Im a big baby" \\ "big"   
"Im a baby"

union與集合的并集也是很相似，它返回兩個List的并集，即遍歷第二個List若存在某元素不屬于第一個List，則追加到第一個List?？矗诙€List中的重復(fù)元素就都沒了!

ghci> "hey man" `union` "man what's up"   
"hey manwt'sup"   
ghci> [1..7] `union` [5..10]   
[1,2,3,4,5,6,7,8,9,10]

intersection相當(dāng)于集合的交集。它返回兩個List的相同部分.

ghci> [1..7] `intersect` [5..10]   
[5,6,7]

insert可以將一個元素插入一個可排序的List，并將其置于首個大于它的元素之前，如果使用insert來給一個排過序的List插入元素，返回的結(jié)果依然是排序的.

ghci> insert 4 [1,2,3,5,6,7]   
[1,2,3,4,5,6,7]   
ghci> insert 'g' $ ['a'..'f'] ++ ['h'..'z']   
"abcdefghijklmnopqrstuvwxyz"   
ghci> insert 3 [1,2,4,3,2,1]   
[1,2,3,4,3,2,1]

length，take，drop，splitAt和replace之類的函數(shù)有個共同點。那就是它們的參數(shù)中都有個Int值，我覺得使用Intergal或Num類型類會更好，但出于歷史原因，修改這些會破壞掉許多既有的代碼。在Data.List中包含了更通用的替代版，如:genericLength，genericTake，genericDrop，genericSplitAt，genericIndex 和 genericReplicate。length的類型聲明為length :: [a] -> Int，而我們?nèi)粢襁@樣求它的平均值，let xs = [1..6] in sum xs / length xs，就會得到一個類型錯誤，因為/運算符不能對Int型使用! 而genericLength的類型聲明則為genericLength :: (Num a) => [b] -> a，Num既可以是整數(shù)又可以是浮點數(shù)，let xs = [1..6] in sum xs / genericLength xs這樣再求平均數(shù)就不會有問題了.

nub,delete,union,intsect和group函數(shù)也有各自的通用替代版nubBy，deleteBy，unionBy，intersectBy和groupBy，它們的區(qū)別就是前一組函數(shù)使用(==)來測試是否相等，而帶By的那組則取一個函數(shù)作參數(shù)來判定相等性，group就與groupBy (==)等價.

假如有個記錄某函數(shù)在每秒的值的List，而我們要按照它小于零或者大于零的交界處將其分為一組子List。如果用group，它只能將相鄰并相等的元素組到一起，而在這里我們的標(biāo)準(zhǔn)是它是否為負(fù)數(shù)。groupBy登場! 它取一個含兩個參數(shù)的函數(shù)作為參數(shù)來判定相等性.

ghci> let values = [-4.3，-2.4，-1.2，0.4，2.3，5.9，10.5，29.1，5.3，-2.4，-14.5，2.9，2.3]   
ghci> groupBy (\x y -> (x > 0) == (y > 0)) values   
[[-4.3,-2.4,-1.2],[0.4,2.3,5.9,10.5,29.1,5.3],[-2.4,-14.5],[2.9,2.3]]

這樣一來我們就可以很清楚地看出哪部分是正數(shù)，哪部分是負(fù)數(shù)，這個判斷相等性的函數(shù)會在兩個元素同時大于零或同時小于零時返回True。也可以寫作\x y -> (x > 0) && (y > 0) || (x <= 0) && (y <= 0)。但我覺得第一個寫法的可讀性更高。Data.Function中還有個on函數(shù)可以讓它的表達(dá)更清晰，其定義如下:

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c   
f `on` g = \x y -> f (g x) (g y)

執(zhí)行(==)on(> 0)得到的函數(shù)就與\x y -> (x > 0) == (y > 0)基本等價。on與帶By的函數(shù)在一起會非常好用，你可以這樣寫:

ghci> groupBy ((==) `on` (> 0)) values   
[[-4.3,-2.4,-1.2],[0.4,2.3,5.9,10.5,29.1,5.3],[-2.4,-14.5],[2.9,2.3]]

可讀性很高! 你可以大聲念出來: 按照元素是否大于零，給它分類！

同樣，sort，insert，maximum和min都有各自的通用版本。如groupBy類似，sortBy，insertBy，maximumBy和minimumBy都取一個函數(shù)來比較兩個元素的大小。像sortBy的類型聲明為:sortBy :: (a -> a -> Ordering) -> [a] -> [a]。前面提過，Ordering類型可以有三個值,LT，EQ和GT。compare取兩個Ord類型類的元素作參數(shù)，所以sort與sortBy compare等價.

List是可以比較大小的，且比較的依據(jù)就是其中元素的大小。如果按照其子List的長度為標(biāo)準(zhǔn)當(dāng)如何? 很好，你可能已經(jīng)猜到了，sortBy函數(shù).

ghci> let xs = [[5,4,5,4,4],[1,2,3],[3,5,4,3],[],[2],[2,2]]   
ghci> sortBy (compare `on` length) xs   
[[],[2],[2,2],[1,2,3],[3,5,4,3],[5,4,5,4,4]]

太絕了!compareonlength，乖乖，這簡直就是英文! 如果你搞不清楚on在這里的原理，就可以認(rèn)為它與\x y -> length xcomparelength y等價。通常，與帶By的函數(shù)打交道時，若要判斷相等性，則(==)onsomething。若要判定大小，則compareonsomething.

Data.Char

如其名，Data.Char模塊包含了一組用于處理字符的函數(shù)。由于字符串的本質(zhì)就是一組字符的List，所以往往會在filter或是map字符串時用到它.

Data.Char模塊中含有一系列用于判定字符范圍的函數(shù)，如下:

isControl判斷一個字符是否是控制字符。

isSpace判斷一個字符是否是空格字符，包括空格，tab，換行符等.

isLower判斷一個字符是否為小寫.

isUper判斷一個字符是否為大寫。

isAlpha判斷一個字符是否為字母.

isAlphaNum判斷一個字符是否為字母或數(shù)字.

isPrint判斷一個字符是否是可打印的.

isDigit判斷一個字符是否為數(shù)字.

isOctDigit判斷一個字符是否為八進(jìn)制數(shù)字.

isHexDigit判斷一個字符是否為十六進(jìn)制數(shù)字.

isLetter判斷一個字符是否為字母.

isMark判斷是否為unicode注音字符，你如果是法國人就會經(jīng)常用到的.

isNumber判斷一個字符是否為數(shù)字.

isPunctuation判斷一個字符是否為標(biāo)點符號.

isSymbol判斷一個字符是否為貨幣符號.

isSeperater判斷一個字符是否為unicode空格或分隔符.

isAscii判斷一個字符是否在unicode字母表的前128位。

isLatin1判斷一個字符是否在unicode字母表的前256位.

isAsciiUpper判斷一個字符是否為大寫的ascii字符.

isAsciiLower判斷一個字符是否為小寫的ascii字符.

以上所有判斷函數(shù)的類型聲明皆為Char -> Bool，用到它們的絕大多數(shù)情況都無非就是過濾字符串或類似操作。假設(shè)我們在寫個程序，它需要一個由字符和數(shù)字組成的用戶名。要實現(xiàn)對用戶名的檢驗，我們可以結(jié)合使用Data.List模塊的all函數(shù)與Data.Char的判斷函數(shù).

ghci> all isAlphaNum "bobby283"   
True   
ghci> all isAlphaNum "eddy the fish!"   
False

Kewl~ 免得你忘記，all函數(shù)取一個判斷函數(shù)和一個List做參數(shù)，若該List的所有元素都符合條件，就返回True.

也可以使用isSpace來實現(xiàn)Data.List的words函數(shù).

ghci> words "hey guys its me"   
["hey","guys","its","me"]   
ghci> groupBy ((==) `on` isSpace) "hey guys its me"   
["hey"," ","guys"," ","its"," ","me"]   
ghci>

Hmm，不錯，有點words的樣子了。只是還有空格在里面，恩，該怎么辦? 我知道，用filter濾掉它們!

啊哈.

Data.Char中也含有與Ordering相似的類型。Ordering可以有兩個值，LT，GT和EQ。這就是個枚舉，它表示了兩個元素作比較可能的結(jié)果.GeneralCategory類型也是個枚舉，它表示了一個字符可能所在的分類。而得到一個字符所在分類的主要方法就是使用generalCategory函數(shù).它的類型為:generalCategory :: Char -> GeneralCategory。那31個分類就不在此一一列出了，試下這個函數(shù)先:

ghci> generalCategory ' '   
Space   
ghci> generalCategory 'A'   
UppercaseLetter   
ghci> generalCategory 'a'   
LowercaseLetter   
ghci> generalCategory '.'   
OtherPunctuation   
ghci> generalCategory '9'   
DecimalNumber   
ghci> map generalCategory " \t\nA9?|"   
[Space,Control,Control,UppercaseLetter,DecimalNumber,OtherPunctuation,MathSymbol]

由于GeneralCategory類型是Eq類型類的一部分，使用類似generalCategory c == Space的代碼也是可以的.

toUpper將一個字符轉(zhuǎn)為大寫字母，若該字符不是小寫字母，就按原值返回.

toLower將一個字符轉(zhuǎn)為小寫字母，若該字符不是大寫字母，就按原值返回.

toTitle將一個字符轉(zhuǎn)為title-case，對大多數(shù)字符而言，title-case就是大寫.

digitToInt將一個字符轉(zhuǎn)為Int值，而這一字符必須得在'1'..'9','a'..'f'或'A'..'F'的范圍之內(nèi).

ghci> map digitToInt "34538"   
[3,4,5,3,8]   
ghci> map digitToInt "FF85AB"   
[15,15,8,5,10,11]

intToDigit是digitToInt的反函數(shù)。它取一個0到15的Int值作參數(shù)，并返回一個小寫的字符.

ghci> intToDigit 15   
'f'   
ghci> intToDigit 5   
'5'

ord與char函數(shù)可以將字符與其對應(yīng)的數(shù)字相互轉(zhuǎn)換.

ghci> ord 'a'   
97   
ghci> chr 97   
'a'   
ghci> map ord "abcdefgh"   
[97,98,99,100,101,102,103,104]

兩個字符的ord值之差就是它們在unicode字符表上的距離.

_Caesar ciphar_是加密的基礎(chǔ)算法，它將消息中的每個字符都按照特定的字母表進(jìn)行替換。它的實現(xiàn)非常簡單，我們這里就先不管字母表了.

encode :: Int -> String -> String   
encode shift msg =  
  let ords = map ord msg   
  shifted = map (+ shift) ords   
  in map chr shifted

先將一個字符串轉(zhuǎn)為一組數(shù)字，然后給它加上某數(shù)，再轉(zhuǎn)回去。如果你是標(biāo)準(zhǔn)的組合牛仔，大可將函數(shù)寫為:map (chr 。(+ shift) 。ord) msg。試一下它的效果:

ghci> encode 3 "Heeeeey"   
"Khhhhh|"   
ghci> encode 4 "Heeeeey"   
"Liiiii}"   
ghci> encode 1 "abcd"   
"bcde"   
ghci> encode 5 "Marry Christmas! Ho ho ho!"   
"Rfww~%Hmwnxyrfx&%Mt%mt%mt&"

不錯。再簡單地將它轉(zhuǎn)成一組數(shù)字，減去某數(shù)后再轉(zhuǎn)回來就是解密了.

decode :: Int -> String -> String   
decode shift msg = encode (negate shift) msg

ghci> encode 3 "Im a little teapot"   
"Lp#d#olwwoh#whdsrw"   
ghci> decode 3 "Lp#d#olwwoh#whdsrw"   
"Im a little teapot"   
ghci> decode 5 . encode 5 $ "This is a sentence"   
"This is a sentence"

Data.Map

關(guān)聯(lián)列表(也叫做字典)是按照鍵值對排列而沒有特定順序的一種List。例如，我們用關(guān)聯(lián)列表儲存電話號碼，號碼就是值，人名就是鍵。我們并不關(guān)心它們的存儲順序，只要能按人名得到正確的號碼就好.在haskell中表示關(guān)聯(lián)列表的最簡單方法就是弄一個二元組的List，而這二元組就首項為鍵，后項為值。如下便是個表示電話號碼的關(guān)聯(lián)列表:

phoneBook = [("betty","555-2938") , 
             ("bonnie","452-2928") , 
             ("patsy","493-2928") , 
             ("lucille","205-2928") , 
             ("wendy","939-8282") , 
             ("penny","853-2492") ]

不理這貌似古怪的縮進(jìn)，它就是一組二元組的List而已。話說對關(guān)聯(lián)列表最常見的操作就是按鍵索值，我們就寫個函數(shù)來實現(xiàn)它。

findKey :: (Eq k) => k -> [(k,v)] -> v  
findKey key xs = snd . head . filter (\(k,v) -> key == k) $ xs

簡潔漂亮。這個函數(shù)取一個鍵和List做參數(shù)，過濾這一List僅保留鍵匹配的項，并返回首個鍵值對。但若該關(guān)聯(lián)列表中不存在這個鍵那會怎樣? 哼，那就會在試圖從空List中取head時引發(fā)一個運行時錯誤。無論如何也不能讓程序就這么輕易地崩潰吧，所以就應(yīng)該用Maybe類型。如果沒找到相應(yīng)的鍵，就返回Nothing。而找到了就返回Just something。而這something就是鍵對應(yīng)的值。

findKey :: (Eq k) => k -> [(k,v)] -> Maybe v  
findKey key [] = Nothing findKey key ((k,v):xs) =  
     if key == k then  
         Just v  
     else  
         findKey key xs

看這類型聲明，它取一個可判斷相等性的鍵和一個關(guān)聯(lián)列表做參數(shù)，可能(Maybe)得到一個值。聽起來不錯.這便是個標(biāo)準(zhǔn)的處理List的遞歸函數(shù)，邊界條件，分割List，遞歸調(diào)用，都有了 -- 經(jīng)典的fold模式。

看看用fold怎樣實現(xiàn)吧。

findKey :: (Eq k) => k -> [(k,v)] -> Maybe v  
findKey key = foldr (\(k,v) acc -> if key == k then Just v else acc) Nothing

Note: 通常，使用fold來替代類似的遞歸函數(shù)會更好些。用fold的代碼讓人一目了然，而看明白遞歸則得多花點腦子。

ghci> findKey "penny" phoneBook  
Just "853-2492"  
ghci> findKey "betty" phoneBook  
Just "555-2938"  
ghci> findKey "wilma" phoneBook  
Nothing

如魔咒般靈驗! 只要我們有這姑娘的號碼就Just可以得到，否則就是Nothing.方才我們實現(xiàn)的函數(shù)便是Data.List模塊的lookup，如果要按鍵去尋找相應(yīng)的值，它就必須得遍歷整個List，直到找到為止。而Data.Map模塊提供了更高效的方式(通過樹實現(xiàn))，并提供了一組好用的函數(shù)。從現(xiàn)在開始，我們?nèi)拥絷P(guān)聯(lián)列表，改用map.由于Data.Map中的一些函數(shù)與Prelude和Data.List模塊存在命名沖突，所以我們使用qualified import。import qualified Data.Map as Map在代碼中加上這句，并load到ghci中.繼續(xù)前進(jìn)，看看Data.Map是如何的一座寶庫!

如下便是其中函數(shù)的一瞥:

fromList取一個關(guān)聯(lián)列表，返回一個與之等價的map。

ghci> Map.fromList [("betty","555-2938"),("bonnie","452-2928"),("lucille","205-2928")]  
fromList [("betty","555-2938"),("bonnie","452-2928"),("lucille","205-2928")]  
ghci> Map.fromList [(1,2),(3,4),(3,2),(5,5)]  
fromList [(1,2),(3,2),(5,5)]

若其中存在重復(fù)的鍵,就將其忽略。如下即fromList的類型聲明。

Map.fromList :: (Ord k) => [(k，v)] -> Map.Map k v

這表示它取一組鍵值對的List，并返回一個將k映射為v的map。注意一下，當(dāng)使用普通的關(guān)聯(lián)列表時，只需要鍵的可判斷相等性就行了。而在這里，它還必須得是可排序的。這在Data.Map模塊中是強(qiáng)制的。因為它會按照某順序?qū)⑵浣M織在一棵樹中.在處理鍵值對時，只要鍵的類型屬于Ord類型類，就應(yīng)該盡量使用Data.Map.empty返回一個空map.

ghci> Map.empty  
fromList []

insert取一個鍵，一個值和一個map做參數(shù)，給這個map插入新的鍵值對，并返回一個新的map。

ghci> Map.empty  
fromList []  
ghci> Map.insert 3 100  
Map.empty fromList [(3,100)]  
ghci> Map.insert 5 600 (Map.insert 4 200 ( Map.insert 3 100  Map.empty))  
fromList [(3,100),(4,200),(5,600)] 
ghci> Map.insert 5 600 。Map.insert 4 200 . Map.insert 3 100 $ Map.empty  
fromList [(3,100),(4,200),(5,600)]

通過empty，insert與fold，我們可以編寫出自己的fromList。

fromList' :: (Ord k) => [(k,v)] -> Map.Map k v  
fromList' = foldr (\(k,v) acc -> Map.insert k v acc) Map.empty

多直白的fold！ 從一個空的map開始，然后從右折疊，隨著遍歷不斷地往map中插入新的鍵值對.

null檢查一個map是否為空.

ghci> Map.null Map.empty  
True  
ghci> Map.null $ Map.fromList [(2,3),(5,5)]  
False

size返回一個map的大小。

ghci> Map.size Map.empty  
0  
ghci> Map.size $ Map.fromList [(2,4),(3,3),(4,2),(5,4),(6,4)]  
5

singleton取一個鍵值對做參數(shù),并返回一個只含有一個映射的map.

ghci> Map.singleton 3 9  
fromList [(3,9)]  
ghci> Map.insert 5 9 $ Map.singleton 3 9  
fromList [(3,9),(5,9)]

lookup與Data.List的lookup很像,只是它的作用對象是map，如果它找到鍵對應(yīng)的值。就返回Just something，否則返回Nothing。

member是個判斷函數(shù)，它取一個鍵與map做參數(shù)，并返回該鍵是否存在于該map。

ghci> Map.member 3 $ Map.fromList [(3,6),(4,3),(6,9)]  
True  
ghci> Map.member 3 $ Map.fromList [(2,5),(4,5)]  
False

map與filter與其對應(yīng)的List版本很相似:

ghci> Map.map (*100) $ Map.fromList [(1,1),(2,4),(3,9)]  
fromList [(1,100),(2,400),(3,900)]  
ghci> Map.filter isUpper $ Map.fromList [(1,'a'),(2,'A'),(3,'b'),(4,'B')]  
fromList [(2,'A'),(4,'B')]

toList是fromList的反函數(shù)。

ghci> Map.toList .Map.insert 9 2 $ Map.singleton 4 3  
[(4,3),(9,2)]

keys與elems各自返回一組由鍵或值組成的List，keys與map fst 。Map.toList等價，elems與map snd 。Map.toList等價.fromListWith是個很酷的小函數(shù)，它與fromList很像，只是它不會直接忽略掉重復(fù)鍵，而是交給一個函數(shù)來處理它們。假設(shè)一個姑娘可以有多個號碼，而我們有個像這樣的關(guān)聯(lián)列表:

phoneBook =  
    [("betty","555-2938"),  
    ("betty","342-2492"), 
    ("bonnie","452-2928"), 
    ("patsy","493-2928"), 
    ("patsy","943-2929"), 
    ("patsy","827-9162"), 
    ("lucille","205-2928"),  
    ("wendy","939-8282"),  
    ("penny","853-2492"), 
    ("penny","555-2111")]

如果用fromList來生成map，我們會丟掉許多號碼! 如下才是正確的做法:

phoneBookToMap :: (Ord k) => [(k，String)] -> Map.Map k String phoneBookToMap xs = Map.fromListWith (\number1 number2 -> number1 ++ "，" ++ number2) xs ghci> Map.lookup "patsy" $ phoneBookToMap phoneBook  
"827-9162，943-2929，493-2928"  
ghci> Map.lookup "wendy" $ phoneBookToMap phoneBook 
"939-8282"  
ghci> Map.lookup "betty" $ phoneBookToMap phoneBook  
"342-2492，555-2938"

一旦出現(xiàn)重復(fù)鍵，這個函數(shù)會將不同的值組在一起，同樣，也可以默認(rèn)地將每個值放到一個單元素的List中，再用++將他們都連接在一起。

phoneBookToMap :: (Ord k) => [(k，a)] -> Map.Map k [a]  
phoneBookToMap xs = Map.fromListWith (++) $ map (\(k,v) -> (k,[v])) xs  
ghci> Map.lookup "patsy" $ phoneBookToMap phoneBook  
["827-9162","943-2929","493-2928"]

很簡潔! 它還有別的玩法，例如在遇到重復(fù)元素時，單選最大的那個值.

ghci> Map.fromListWith max [(2,3),(2,5),(2,100),(3,29),(3,22),(3,11),(4,22),(4,15)]  
fromList [(2,100),(3,29),(4,22)]

或是將相同鍵的值都加在一起.

ghci> Map.fromListWith (+) [(2,3),(2,5),(2,100),(3,29),(3,22),(3,11),(4,22),(4,15)]  
fromList [(2,108),(3,62),(4,37)]

insertWith之于insert，恰如fromListWith之于fromList。它會將一個鍵值對插入一個map之中，而該map若已經(jīng)包含這個鍵，就問問這個函數(shù)該怎么辦。

ghci> Map.insertWith (+) 3 100 $ Map.fromList [(3,4),(5,103),(6,339)]  
fromList [(3,104),(5,103),(6,339)]

Data.Map里面還有不少函數(shù)，這個文檔中的列表就很全了.

Data.Set

import qualified Data.Set as Set

text1 = "I just had an anime dream. Anime... Reality... Are they so different?"  
text2 = "The old man left his garbage can out and now his trash is all over my lawn!"

ghci> let set1 = Set.fromList text1  
ghci> let set2 = Set.fromList text2  
ghci> set1  
fromList " .?AIRadefhijlmnorstuy"  
ghci> set2  
fromList " !Tabcdefghilmnorstuvwy"

ghci> Set.intersection set1 set2  
fromList " adefhilmnorstuy"

ghci> Set.difference set1 set2  
fromList ".?AIRj"  
ghci> Set.difference set2 set1  
fromList "!Tbcgvw"

ghci> Set.union set1 set2  
fromList " !.?AIRTabcdefghijlmnorstuvwy"

ghci> Set.null Set.empty  
True  
ghci> Set.null $ Set.fromList [3,4,5,5,4,3]  
False  
ghci> Set.size $ Set.fromList [3,4,5,3,4,5]  
3  
ghci> Set.singleton 9  
fromList [9]  
ghci> Set.insert 4 $ Set.fromList [9,3,8,1]  
fromList [1,3,4,8,9]  
ghci> Set.insert 8 $ Set.fromList [5..10]  
fromList [5,6,7,8,9,10]  
ghci> Set.delete 4 $ Set.fromList [3,4,5,4,3,4,5]  
fromList [3,5]

ghci> Set.fromList [2,3,4] `Set.isSubsetOf` Set.fromList [1,2,3,4,5]  
True  
ghci> Set.fromList [1,2,3,4,5] `Set.isSubsetOf` Set.fromList [1,2,3,4,5]  
True  
ghci> Set.fromList [1,2,3,4,5] `Set.isProperSubsetOf` Set.fromList [1,2,3,4,5]  
False  
ghci> Set.fromList [2,3,4,8] `Set.isSubsetOf` Set.fromList [1,2,3,4,5]  
False

ghci> Set.filter odd $ Set.fromList [3,4,5,6,7,2,3,4]  
fromList [3,5,7]  
ghci> Set.map (+1) $ Set.fromList [3,4,5,6,7,2,3,4]  
fromList [3,4,5,6,7,8]

ghci> let setNub xs = Set.toList $ Set.fromList xs  
ghci> setNub "HEY WHATS CRACKALACKIN"  
" ACEHIKLNRSTWY"  
ghci> nub "HEY WHATS CRACKALACKIN"  
"HEY WATSCRKLIN"

module Geometry  
( sphereVolume  
, sphereArea  
, cubeVolume  
, cubeArea  
, cuboidArea  
, cuboidVolume  
) where

module Geometry  
( sphereVolume  
, sphereArea  
, cubeVolume  
, cubeArea  
, cuboidArea  
, cuboidVolume  
) where  

sphereVolume :: Float -> Float  
sphereVolume radius = (4.0 / 3.0) * pi * (radius ^ 3)  

sphereArea :: Float -> Float  
sphereArea radius = 4 * pi * (radius ^ 2)  

cubeVolume :: Float -> Float  
cubeVolume side = cuboidVolume side side side  

cubeArea :: Float -> Float  
cubeArea side = cuboidArea side side side  

cuboidVolume :: Float -> Float -> Float -> Float  
cuboidVolume a b c = rectangleArea a b * c  

cuboidArea :: Float -> Float -> Float -> Float  
cuboidArea a b c = rectangleArea a b * 2 + rectangleArea a c * 2 + rectangleArea c b * 2  

rectangleArea :: Float -> Float -> Float  
rectangleArea a b = a * b

import Geometry

module Geometry.Sphere  
( volume  
, area  
) where  

volume :: Float -> Float  
volume radius = (4.0 / 3.0) * pi * (radius ^ 3)  

area :: Float -> Float  
area radius = 4 * pi * (radius ^ 2)

module Geometry.Cuboid  
( volume  
, area  
) where  

volume :: Float -> Float -> Float -> Float  
volume a b c = rectangleArea a b * c  

area :: Float -> Float -> Float -> Float  
area a b c = rectangleArea a b * 2 + rectangleArea a c * 2 + rectangleArea c b * 2  

rectangleArea :: Float -> Float -> Float  
rectangleArea a b = a * b

module Geometry.Cube  
( volume  
, area  
) where  

import qualified Geometry.Cuboid as Cuboid  

volume :: Float -> Float  
volume side = Cuboid.volume side side side  

area :: Float -> Float  
area side = Cuboid.area side side side

import Geometry.Sphere

import qualified Geometry.Sphere as Sphere  
import qualified Geometry.Cuboid as Cuboid  
import qualified Geometry.Cube as Cube