当长度不到3次以下无限列表时，我该如何总和列表列表？

Question

我的代码正在起作用，但不适合无尽的列表。我该如何使其工作？

sumsOf :: Num a => [[a]] -> [a]
sumsOf a = map sum [ x | x <- a , length x < 3]

示例：

sumsOf [[],[1,2,4],[],[6]] == [0,0,6]
sumsOf [[1],[8],[6],[],[9,9]] == [1,8,6,0,18]
sumsOf [[1,2,9,10],[7,8,9],[6,9,4,2,0],[9,9,9]] == []
sumsOf [[1..],[7..],[6..],[9..],[10..],[100..]] == []
sumsOf [[1,2], [1..], [], [4]] == [3,0,4]

Answer 1

长度是您应该按照经验的列表函数之一从不使用使用，除非您确切地知道为什么还可以。 （另一个是head和!!。）这不仅是因为它与无限列表不起作用，还因为它通常完全不必要的 o （ n ）在整个列表上进行遍历。即使您以后需要遍历它，这两次也可能会带来很大的性能差异。

在这种情况下，请考虑您真正需要的内容：sum避免进入漫长或无限列表，而是在两个元素后放弃。实际上，这可以以一种愚蠢的疲惫方式实现：

sumIfLenLt3 :: Num a => [a] -> Maybe a
sumIfLenLt3 [] = Just 0
sumIfLenLt3 [x] = Just x
sumIfLenLt3 [x,y] = Just $ x+y
sumIfLenLt3 _ = Nothing

为了使其对任何最大长度进行一般性，您可以使用递归：

sumIfLenLe :: Num a => Int -> [a] -> Maybe a
sumIfLenLe _ [] = Just 0
sumIfLenLe 0 _ = Nothing
sumIfLenLe n (h:t) = h + sumIfLenLe (n-1) t

...但是，这不是一个很好的实现，原因有两个：它会以负面的论点炸毁，并且不是尾部递归。一个更好的，尽管有点麻烦，但版本会

sumIfLenLe :: Num a => Int -> [a] -> Maybe a
sumIfLenLe n l
  | n<0        = Nothing
  | otherwise  = go n l 0
 where go n [] acc  = Just acc
       go 0 _ _ = Nothing
       go n (h:t) acc = go (n-1) t (h+acc)

更优雅，是使用标准功能来获取最大可用元素的计数，并查看是否剩下任何东西：

sumIfLenLe :: Num a => Int -> [a] -> Maybe a
sumIfLenLe n l
  | null remains  = Just $ sum relevant
  | otherwise     = Nothing
 where (relevant, remains) = splitAt n l

...或，某些等效的形式，

sumIfLenLe n l = case splitAt n l of
   (relevant, []) -> Just $ sum relevant
   _              -> Nothing

或者

sumIfLenLe n l
 | (relevant, []) <- splitAt n l
              = Just $ sum relevant
 | otherwise  = Nothing

您可以只是可以在整个给定的列表中绘制该图，并收集成功的所有结果。

import Data.Maybe (catMaybes)

sumsOf :: Num a => [[a]] -> [a]
sumsOf = catMaybes . map (sumIfLe 2)

Answer 2

简单液体解决方案：

您只关心长度是否小于3，因此，如果您将输入列表截断为3个元素，则结果不会更改：

$ ghci
GHCi, version 8.8.4: https://www.haskell.org/ghc/  :? for help
 λ> 
 λ> sumsOf a = map sum [ x | x <- a , length (take 3 x) < 3]
 λ> 
 λ> sumsOf [[],[1,2,4],[],[6]]
 [0,0,6]
 λ> sumsOf [[1],[8],[6],[],[9,9]]
 [1,8,6,0,18]
 λ> sumsOf [[1,2,9,10],[7,8,9],[6,9,4,2,0],[9,9,9]]
 []
 λ> sumsOf [[1..],[7..],[6..],[9..],[10..],[100..]]
 []
 λ> sumsOf [[1,2], [1..], [], [4]]
 [3,0,4]
 λ> 

因此，这很容易通过无限列表解决问题。

以稍微惯用的方式：

sumsOf :: Num a => [[a]] -> [a]
sumsOf xss = map sum [ xs | xs <- xss , length (take 3 xs) < 3]

唯一的缺点是库函数tot必须复制列表节点。

N.1.8e9-在评论中提到的一个想法，通过编写一些boundedlength函数，可以使某些内容更有效，以最多返回k < /code>，例如这样：

boundedLength :: Int -> [a] -> Int
boundedLength k xs = go 0 xs
  where
    go depth   []    =  depth
    go depth (x:xs)  =  if (depth < k)  then  go (depth + 1) xs
                                        else  k

在这种情况下，我们的sumsof函数最终以：

sumsOf :: Num a => [[a]] -> [a]
sumsOf xss = map sum [ xs | xs <- xss , boundedLength 3 xs < 3]