Ranges
有时候我们有这样一种需求：我们需要一个 List，它的元素从 1 到 20。从 1 到 20 敲出每一个元素肯定是一种可以搞定的办法，但肯定不是好办法。这时候，我们可以使用 Haskell 的 Ranges 来处理这种需求。
Ranges 用来构建元素可以按照某种顺序枚举的 List。像数字 1,2,3,4 就是可枚举的；字母 a,b,c,d 也是。我们看看两个 Ranges 的例子：上面说到的 1-20，使用 Ranges 可以这样表示：
Prelude> [1..20]
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
同理，所有的小写字母可以这样表示：
Prelude> ['a'..'z']
"abcdefghijklmnopqrstuvwxyz"
这只是最基本的，我们还可以设置 Ranges 的步进(step)。比如，我们需要一个含有 1-20 中所有偶数的 List，我们可以这样：
Prelude> [2,4..20]
[2,4,6,8,10,12,14,16,18,20]
但是需要注意的是，只能够设置一个步进，下面这种就不是 Ranges 了：
Prelude> [1,2,4,8..100]
<interactive>:5:9: parse error on input..'
如果你不设置上限，那么得到的就是一个无限的 List：
Prelude> [1..]
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27, ...
我们可以结合之前介绍的 take 函数，按你的要求获得指定数目的元素构成的 List：
Prelude> take 5 [1..]
[1,2,3,4,5]
这种方式是可行的，因为 Haskell 一旦得到了指定数目的元素就拉到了，不会去评估整个无限的List。 当然还有几个函数可以创建无限的 List：
- cycle 函数
Prelude> take 10 (cycle [1,2,3])
[1,2,3,1,2,3,1,2,3,1]
cycle 的参数是一个列表。
- repeat 函数
Prelude> take 10 (repeat 5)
[5,5,5,5,5,5,5,5,5,5]
repeat 的参数是单个元素或者 List：
Prelude> take 10 (repeat [1,2,3])
[[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3]]
- replicate 函数
Prelude> replicate 3 5
[5,5,5]
replicate 创建一个含有 a 个元素 b 的 List。需要特别指出的是，浮点数使用Ranges会出现精度问题。
列表解析
List Comprehension是一种过滤、转换和连接 List 的方式。List Comprehension 与数学中集合的定义非常类似，比如：
要完成这样的工作，我们可以用之前提到 take 函数：
Prelude> take 10 [2,4..]
[2,4,6,8,10,12,14,16,18,20]
我们也可以使用 List Comprehension 的方式完成这个工作：
Prelude> [x*2|x<-[1..10]]
[2,4,6,8,10,12,14,16,18,20]
这个表达式的意思是，从列表 [1..10]中依次取出每个元素给 x，然后 x乘以2。在 List Comprehension 中，| 左边的部分是输出，这一部分我们可以自己定义我们想要的输出是什么样子。List Comprehension 可以加条件。例如：
Prelude> [x * 2 | x <- [1..10], x > 5]
[12,14,16,18,20]
这个 List Comprehension 的意思很直接，1..10 中，大于 5 的翻倍输出。条件是由 , 隔开的，可以有多个。还可以在函数定义中使用 List Comprehension：
let boomBangs xs = [ if x < 10 then "BOOM" else "BANG" | x <- xs, odd x]
函数 boomBangs 接收一个 List，将 List 中的大于 10 的奇数替换为 "BANG"，将小于 10 的替换为 "BOOM"。我们可以使用一下这个函数：
Prelude> boomBangs [7..13]
["BOOM","BOOM","BANG","BANG"]
我们还可以同时添加多个条件：
Prelude> [x | x <- [10..20], x /= 11,x /= 13, x /= 15]
[10,12,14,16,17,18,19,20]
不仅条件可以添加多个，也可以同时从多个 List 中取值：
Prelude> [x * y | x <- [1,2,3], y <- [4,5,6]]
[4,5,6,8,10,12,12,15,18]
再看几个例子：
Prelude> [x * y | x <- [2,5,10], y <- [8,10,11]]
[16,20,22,40,50,55,80,100,110]
Prelude> [x * y | x <- [2,5,10], y <- [8,10,11], x * y > 50]
[55,80,100,110]
Prelude> let nouns = ["hobo","frog","pope"]
Prelude> let adjectives = ["lazy","grouchy","scheming"]
Prelude> [adjective ++ " " ++ noun | adjective <- adjectives, noun <- nouns]
["lazy hobo","lazy frog","lazy pope","grouchy hobo","grouchy frog","grouchy pope","scheming hobo","scheming frog","scheming pope"]
我们可以使用 List Comprehension 来实现一个 length 函数：
length' xs = sum [1 | _ <- xs]
这个函数对于 List xs 中出现的每一个元素输出 1，最后通过 sum 函数计算有多少个元素。再看一个去除字符串中小写字母的函数：
removeNonUppercase st = [ c | c <- st, c elem ['A'..'Z']]
Prelude> let removeNonUppercase st = [ c | c <- st, c elem ['A'..'Z']]
Prelude> removeNonUppercase "Hahaha! Ahahaha!"
"HA"
Prelude> removeNonUppercase "IdontLIKEFROGS"
"ILIKEFROGS"
此外，List Comprehension 也是可以嵌套的：
Prelude> let xxs = [[1,3,5,2,3,1,2,4,5],[1,2,3,4,5,6,7,8,9],[1,2,4,2,1,6,3,1,3,2,3,6]]
Prelude> [ [ x | x <- xs, even x ] | xs <- xxs]
[[2,2,4],[2,4,6,8],[2,4,2,6,2,6]]
小结
看了这么多例子，个人感觉 List Comprehension 在处理一些比较复杂的情况很灵活，尤其是允许嵌套 List Comprehension。Python 中的列表解析也与之相似。
