Haskell语言学习笔记（15）Data.List

Data.List

Basic functions

Prelude> [1,2,3] ++ [4,5,6]
[1,2,3,4,5,6]
Prelude Data.List> head [1,2,3]
1
Prelude Data.List> last [1,2,3]
3
Prelude Data.List> tail [1,2,3]
[2,3]
Prelude Data.List> init [1,2,3]
[1,2]
Prelude Data.List> uncons [1,2,3]
Just (1,[2,3])
Prelude Data.List> uncons []
Nothing
Prelude Data.List> null [1,2,3]
False
Prelude Data.List> null []
True
Prelude Data.List> length [1,2,3]
3

List transformations

Prelude Data.List> map (3+) [1,2,3]
[4,5,6]
Prelude Data.List> reverse [1,2,3]
[3,2,1]
Prelude Data.List> intersperse ',' "abc"
"a,b,c"
Prelude Data.List> intercalate "," ["abc","def","ghi"]
"abc,def,ghi"
Prelude Data.List> transpose [[1,2,3],[4,5,6]]
[[1,4],[2,5],[3,6]]
Prelude Data.List> subsequences "abc"
["","a","b","ab","c","ac","bc","abc"]
Prelude Data.List> permutations "abc"
["abc","bac","cba","bca","cab","acb"]

Reducing lists (folds)

Prelude Data.List> foldl (-) 0 [1,2,3]
-6
Prelude Data.List> foldl' (-) 0 [1,2,3]
-6
Prelude Data.List> foldl1 (-) [1,2,3]
-4
Prelude Data.List> foldl1' (-) [1,2,3]
-4
Prelude Data.List> foldr (-) 0 [1,2,3]
2
Prelude Data.List> foldr1 (-) [1,2,3]
2

Special folds

Prelude Data.List> concat [[1,2],[3,4],[5,6]]
[1,2,3,4,5,6]
Prelude Data.List> concatMap (\x -> [x,x+1]) [1,2,3]
[1,2,2,3,3,4]
Prelude Data.List> and [True,False,True]
False
Prelude Data.List> and [True,True,True]
True
Prelude Data.List> or [True,False,True]
True
Prelude Data.List> or [False,False,False]
False
Prelude Data.List> any (<3) [1,2,3]
True
Prelude Data.List> all (<3) [1,2,3]
False
Prelude Data.List> sum [1,2,3]
6
Prelude Data.List> product [1,2,3]
6
Prelude Data.List> maximum [1,2,3]
3
Prelude Data.List> minimum [1,2,3]
1

Building lists

Prelude Data.List> scanl (+) 0 [1,2,3]
[0,1,3,6]
Prelude Data.List> scanl' (+) 0 [1,2,3]
[0,1,3,6]
Prelude Data.List> scanl1 (+) [1,2,3]
[1,3,6]
Prelude Data.List> scanr (+) 0 [1,2,3]
[6,5,3,0]
Prelude Data.List> scanr1 (+) [1,2,3]
[6,5,3]

Accumulating maps

Prelude Data.List> mapAccumL (\acc v -> (acc+v, v*2)) 0 [1,2,3]
(6,[2,4,6])
Prelude Data.List> mapAccumR (\acc v -> (acc+v, v*2)) 0 [1,2,3]
(6,[2,4,6])

Infinite lists

Prelude Data.List> take 5 $ iterate (+1) 1
[1,2,3,4,5]
Prelude Data.List> take 5 $ repeat 1
[1,1,1,1,1]
Prelude Data.List> replicate 5 1
[1,1,1,1,1]
Prelude Data.List> take 15 $ cycle [1,2,3]
[1,2,3,1,2,3,1,2,3,1,2,3,1,2,3]

Unfolding

Prelude Data.List> unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
[10,9,8,7,6,5,4,3,2,1]

Sublists

Prelude Data.List> take 5 "Hello World!"
"Hello"
Prelude Data.List> take 3 [1,2,3,4,5]
[1,2,3]
Prelude Data.List> drop 6 "Hello World!"
"World!"
Prelude Data.List> drop 3 [1,2,3,4,5]
[4,5]
Prelude Data.List> splitAt 6 "Hello World!"
("Hello ","World!")
Prelude Data.List> splitAt 3 [1,2,3,4,5]
([1,2,3],[4,5])
Prelude Data.List> takeWhile (< 3) [1,2,3,4,1,2,3,4]
[1,2]
Prelude Data.List> dropWhile (< 3) [1,2,3,4,5,1,2,3]
[3,4,5,1,2,3]
Prelude Data.List Data.Char> dropWhileEnd isSpace "foo\n"
"foo"
Prelude Data.List> span (< 3) [1,2,3,4,1,2,3,4]
([1,2],[3,4,1,2,3,4])
Prelude Data.List> break (> 3) [1,2,3,4,1,2,3,4]
([1,2,3],[4,1,2,3,4])
Prelude Data.List> stripPrefix "foo" "foobar"
Just "bar"
Prelude Data.List> stripPrefix "foo" "barfoo"
Nothing
Prelude Data.List> group "Mississippi"
["M","i","ss","i","ss","i","pp","i"]
Prelude Data.List> inits "abc"
["","a","ab","abc"]
Prelude Data.List> tails "abc"
["abc","bc","c",""]

Predicates

Prelude Data.List> isPrefixOf "a" "abc"
True
Prelude Data.List> isPrefixOf "b" "abc"
False
Prelude Data.List> isSuffixOf "b" "abc"
False
Prelude Data.List> isSuffixOf "c" "abc"
True
Prelude Data.List> isInfixOf "a" "abc"
True
Prelude Data.List> isInfixOf "b" "abc"
True
Prelude Data.List> isInfixOf "d" "abc"
False
Prelude Data.List> isSubsequenceOf "ab" "abc"
True
Prelude Data.List> isSubsequenceOf "ac" "abc"
True

Searching by equality

Prelude Data.List> elem 3 [1,2,3]
True
Prelude Data.List> elem 4 [1,2,3]
False
Prelude Data.List> notElem 4 [1,2,3]
True
Prelude Data.List> lookup 2 [(1,"a"),(2,"b"),(3,"c")]
Just "b"
Prelude Data.List> lookup 4 [(1,"a"),(2,"b"),(3,"c")]
Nothing

Searching with a predicate

Prelude Data.List> find (>3) [1,2,3]
Nothing
Prelude Data.List> find (<3) [1,2,3]
Just 1
Prelude Data.List> filter (<3) [1,2,3]
[1,2]
Prelude Data.List> partition (<3) [1,2,3]
([1,2],[3])

Indexing lists

Prelude Data.List> [1,2,3,4] !! 2
3
Prelude Data.List> elemIndex 3 [1,2,3,4]
Just 2
Prelude Data.List> elemIndices 3 [1,2,3,3,3,4]
[2,3,4]
Prelude Data.List> findIndex (<3) [1,2,3]
Just 0
Prelude Data.List> findIndices (<3) [1,2,3]
[0,1]

Zipping and unzipping lists

Prelude Data.List> zip [1,2,3] ["a","b","c"]
[(1,"a"),(2,"b"),(3,"c")]
Prelude Data.List> zipWith (+) [1,2,3] [4,5,6]
[5,7,9]
Prelude Data.List> unzip [(1,"a"),(2,"b"),(3,"c")]
([1,2,3],["a","b","c"])

Special lists

Prelude Data.List> lines "one\ntwo"
["one","two"]
Prelude Data.List> words "one two"
["one","two"]
Prelude Data.List> unlines ["one","two"]
"one\ntwo\n"
Prelude Data.List> unwords ["one","two"]
"one two"

"Set" operations

Prelude Data.List> nub [1,2,3,1,4,5,2,6,7]
[1,2,3,4,5,6,7]
Prelude Data.List> delete 'a' "banana"
"bnana"
Prelude Data.List> "defabcdefabc" \\ "cba"
"defdefabc"
Prelude Data.List> "dog" `union` "cow"
"dogcw"
Prelude Data.List> [1,2,3,4] `intersect` [2,4,6,8]
[2,4]

Ordered lists

Prelude Data.List> sort [-3,2,-1,6,-5]
[-5,-3,-1,2,6]
Prelude Data.List> sortOn abs [-3,2,-1,6,-5]
[-1,2,-3,-5,6]
Prelude Data.List> insert 3 [1,2,4,5] 
[1,2,3,4,5]

User-supplied equality (replacing an Eq context)

Prelude Data.List> nubBy (\a b -> abs a == abs b) [1,2,-1,-2,3]
[1,2,3]
Prelude Data.List Data.Function> nubBy ((==) `on` abs) [1,2,-1,-2,3]
[1,2,3]
Prelude Data.List Data.Function> deleteBy ((==) `on` abs) 2 [1,2,-1,-2,3]
[1,-1,-2,3]
Prelude Data.List Data.Function> deleteFirstsBy ((==) `on` abs) [1,2,3] [-2,-3]
[1]
Prelude Data.List Data.Function> unionBy ((==) `on` abs) [1,2,3] [-2,-3,-4]
[1,2,3,-4]
Prelude Data.List Data.Function> intersectBy ((==) `on` abs) [1,2,3] [-2,-3,-4]
[2,3]
Prelude Data.List Data.Function> groupBy ((==) `on` abs) [1,-1,-2,2,3]
[[1,-1],[-2,2],[3]]

User-supplied comparison (replacing an Ord context)

Prelude Data.List> sortBy (\a b -> abs a `compare` abs b) [1,3,-2,-5,4]
[1,-2,3,4,-5]
Prelude Data.List Data.Function> sortBy (compare `on` abs) [1,3,-2,-5,4]
[1,-2,3,4,-5]
Prelude Data.List Data.Function> maximumBy (compare `on` abs) [1,3,-2,-5,4]
-5
Prelude Data.List Data.Function> minimumBy (compare `on` abs) [1,3,-2,-5,4]
1

The "generic" operations

Prelude Data.List> genericLength [1,2,3] :: Integer
3
Prelude Data.List> genericTake (2 :: Integer) [1,2,3]
[1,2]
Prelude Data.List> genericDrop (2 :: Integer) [1,2,3]
[3]
Prelude Data.List> genericSplitAt (2 :: Integer) [1,2,3]
([1,2],[3])
Prelude Data.List> genericIndex [1,2,3] (2 :: Integer)
3
Prelude Data.List> genericReplicate (2 :: Integer) 2
[2,2]