Haskell 的 `++` 有多懒？

Question

我很好奇应该如何提高 Haskell 例程的性能，该例程可以找到字符串的字典顺序最小循环旋转。

import Data.List
swapAt n = f . splitAt n where f (a,b) = b++a
minimumrotation x = minimum $ map (\i -> swapAt i x) $ elemIndices (minimum x) x

我想我应该使用 Data.Vector 而不是列表，因为 Data.Vector 提供就地操作，可能只是将一些索引操作到原始数据中。我实际上不应该自己费心跟踪索引以避免过度复制，对吧？

我很好奇++ 如何影响优化。我想它会产生一个惰性字符串 thunk，在字符串被读取到那么远之前永远不会进行附加。因此，a 永远不应该被附加到 b 上，只要 minimum 可以尽早消除该字符串，例如因为它以一些非常晚的字母开头。这是正确的吗？

Answer 1

xs ++ ys 在来自xs 的所有列表单元格中增加了一些开销，但一旦到达xs 的末尾，它是免费的——它只是返回ys。

查看(++) 的定义有助于了解原因：

[] ++ ys = ys
(x:xs) ++ ys = x : (xs ++ ys)

即，它必须在遍历结果时“重新构建”整个第一个列表。 This article 非常有助于理解如何以这种方式推理惰性代码。

要意识到的关键是追加不是一次完成的；通过首先遍历所有xs，然后将ys 放在[] 所在的位置，逐步构建一个新的链表。

因此，您不必担心到达b 的末尾并突然产生“附加”a 的一次性成本；成本分布在b 的所有元素上。

向量完全是另一回事；它们的结构很严格，因此即使只检查xs V.++ ys 的第一个元素也会产生分配新向量并将xs 和ys 复制到它的全部开销——就像在严格的语言中一样。这同样适用于可变向量（除了在执行操作时会产生成本，而不是在强制生成向量时产生成本），尽管我认为无论如何您都必须编写自己的附加操作。如果这对您来说是个问题，您可以将一堆附加的（不可变的）向量表示为 [Vector a] 或类似的，但这只会将开销转移到当您将其展平回单个向量时，听起来您更多对可变向量感兴趣。

Answer 2

试试

minimumrotation :: Ord a => [a] -> [a]
minimumrotation xs = minimum . take len . map (take len) $ tails (cycle xs)
  where
    len = length xs

我希望它比您拥有的更快，尽管在未装箱的 Vector 或 UArray 上进行索引处理可能会更快。但是，真的是瓶颈吗？

Answer 3

如果您对快速连接和快速splitAt 感兴趣，请使用Data.Sequence。

我对您的代码进行了一些风格上的修改，使其看起来更像惯用的 Haskell，但逻辑完全相同，除了与 Seq 的一些转换：

import qualified Data.Sequence as S
import qualified Data.Foldable as F

minimumRotation :: Ord a => [a] -> [a]
minimumRotation xs = F.toList
                   . F.minimum
                   . fmap (`swapAt` xs')
                   . S.elemIndicesL (F.minimum xs')
                   $ xs'
  where xs' = S.fromList xs
        swapAt n = f . S.splitAt n
          where f (a,b) = b S.>< a