Haskell的基本的列表操作函数

最新推荐文章于 2022-06-28 09:41:20 发布

随处瞎晃荡

最新推荐文章于 2022-06-28 09:41:20 发布

阅读量6.2k

点赞数 3

分类专栏： Haskell

本文链接：https://blog.csdn.net/gongyi199393/article/details/88292388

版权

Haskell 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

length函数告诉我们一个列表中包含多少个元素。
如果需要检查列表是不是空的，用null函数。
要访问列表的第一个元素，用head函数。
tail函数，返回列表中除了第一个其它所有的元素。
last，返回列表的最后一个元素。
init，它返回列表中除了最后一个其它所有的元素。
concat函数取一个包含列表的列表，这些列表中的元素具有相同的类型，它把这些列表连接在一起成为一个单一的列表。它会去掉一级的嵌套。（译注：每次调用concat会去除最外一层的方括号）
reverse函数返回一个元素以相反的顺序排列的新列表。
对包含Bool值的列表，and和or函数相当于用&&和||遍历这个列表并两两求值还有两个与and和or功能近似的函数，all和any，它们操作任何类型的列表。每一个带着一个谓词作为它的第一个参数；如果谓词对列表中的每个元素的判断都为真，all函数返回True，当对列表中的每个元素的谓词至少有一个成功了，any函数返回True。
take函数，在“函数应用”一节遇到过，返回一个由头n个元素组成的子列表。与它相反，drop，丢掉列表开头的n个元素。
splitAt函数组合了take和drop的功能，返回由一个列表产生的二元组，两部分是由原来的列表根据给定的索引分割而成。

ghci> :type splitAt
splitAt :: Int -> [a] -> ([a], [a])
ghci> splitAt 3 "foobar"
("foo","bar")

takeWhile和dropWhile函数带着谓词：takeWhile从开头遍历一个列表，抽取使谓词返回True的元素组成一个新列表（就是让该函数的第一个参数，返回True的元素组成一个新列表）；dropWhile则是把使谓词返回True的元素丢掉。（译注：实际上两个函数都是走到第一个使谓词返回False的元素处就停止操作了，即使这个元素后面还有使谓词返回True的元素，两个函数都不再往下执行了）

ghci> :type takeWhile
takeWhile :: (a -> Bool) -> [a] -> [a]
ghci> takeWhile odd [1,3,5,6,8,9,11]
[1,3,5]
ghci> :type dropWhile
dropWhile :: (a -> Bool) -> [a] -> [a]
ghci> dropWhile even [2,4,6,7,9,10,12]
[7,9,10,12]

break和span函数利用takeWhile和dropWhile的结果组成二元组。每个函数带着一个谓词，break提取列表中使谓词失败的元素组成二元组的首项，而span提取列表中使谓词成功的元素组成二元组的首项。

ghci> :type span
span :: (a -> Bool) -> [a] -> ([a], [a])
ghci> span even [2,4,6,7,9,10,11]
([2,4,6],[7,9,10,11])
ghci> :type break
break :: (a -> Bool) -> [a] -> ([a], [a])
ghci> break even [1,3,5,6,8,9,10]
([1,3,5],[6,8,9,10])

elem函数标示一个值是否出现在一个列表中。它有一个伴生的函数，notElem。

ghci> :type elem
elem :: (Eq a) => a -> [a] -> Bool
ghci> 2 `elem` [5,3,2,1,1]
True
ghci> 2 `notElem` [5,3,2,1,1]
False

filter函数带着一个谓词，返回列表中使谓词成功的每一个元素。

	ghci> :type filter
	filter :: (a -> Bool) -> [a] -> [a]
	ghci> filter odd [2,4,1,3,6,8,5,7]
	[1,3,5,7]

在Data.List模块中的三个查找函数。isPrefixOf函数告诉我们左边的列表是否出现在右边的列表的开始处、isInfixOf函数标示左边的列表是否是右边的列表的一个子列表、isSuffixOf函数告诉我们左边的列表是否出现在右边的列表的结尾处。

ghci> :module +Data.List
ghci> :type isPrefixOf
isPrefixOf :: (Eq a) => [a] -> [a] -> Bool
ghci> "foo" `isPrefixOf` "foobar"
True
ghci> [1,2] `isPrefixOf` []
False

ghci> [2,6] `isInfixOf` [3,1,4,1,5,9,2,6,5,3,5,8,9,7,9]
True
ghci> "funk" `isInfixOf` "sonic youth"
False

ghci> ".c" `isSuffixOf` "crashme.c"
True

zip函数把两个列表压缩成一个单一的由二元组组成的列表。较长的那个列表中的多出来的元素会被丢弃。

ghci> :type zip
zip :: [a] -> [b] -> [(a, b)]
ghci> zip [12,72,93] "zippity"
[(12,'z'),(72,'i'),(93,'p')]

zipWith函数，它带两个列表作为参数并为从每个列表中抽取一个元素而组成的二元组提供一个函数，最后生成与较短的那个列表等长的新列表。（所以如果想把三个列表压缩在一起，要调用zip3或者zipWith3，可以类推到zip7和zipWith7）

ghci> :type zipWith
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
ghci> zipWith (+) [1,2,3] [4,5,6]
[5,7,9]

lines函数，它有个对应的函数，unlines。注意unlines总是在它处理的结果（译注：列表中的每个元素）的尾部放一个换行符。

ghci> lines "foo\nbar"
["foo","bar"]
ghci> unlines ["foo", "bar"]
"foo\nbar\n"

words函数利用任何空白字符分割一个字符串，它对应的函数，unwords，用一个空格字符把一个字符串构成的列表连接起来。

ghci> words "the  \r  quick \t  brown\n\n\nfox"
["the","quick","brown","fox"]
ghci> unwords ["jumps", "over", "the", "lazy", "dog"]
"jumps over the lazy dog"