在 Haskell 中测试单例列表内容的最有效或惯用的方法是什么？

Question

这个问题现在对我来说是严格的学术问题，但有一天我会看到它有实际应用。通过 Haskell 自学，我成功地构建了无限的素数列表。其中一部分是这个函数：

isPrime n
    | n < 2                         = False
    | head (primeFactorsOf n) == n  = True
    | otherwise                     = False

其中primeFactorsOf 以升序返回数字的质因数列表。 1 不是素数，所以素数n 的素数是单例列表[n]。因此，第二个保护案例可以替换为：

    | primeFactorsOf n == [n]       = True

其中一个比另一个更有效吗？如果不是，是一种更好的风格吗？我的直觉是调用 head 并比较两个简单的数字比调用 cons 并比较两个单例列表要快，所以我已经得到的将是最好的。但如果没有区别，我认为替代方案看起来更干净。

Answer 1

如果速度真的很重要，唯一确定的方法就是对其进行基准测试，我建议criterion。哪个提供更好的性能尚不完全清楚。如果primeFactorsOf 被内联，那么编译器可能会注意到您正在比较第二种情况下的两个列表并自动删除装箱。也可能不是，在这种情况下，您的预感很可能是正确的。

至于哪种风格更好，第二种是。大多数时候最好避免使用像head 这样的部分函数。但是，也许您可​​以做得更好？

isPrime n = case primeFactorsOf n of
  [n'] | n == n' && n >= 2 -> True
  _ -> False

或者您可以将n >= 2 的支票放在外面。或者，如果您知道primeFactorsOf 为n < 2 返回一个空列表，则可以完全省略它。

编辑：打高尔夫球

isPrime n = case primeFactorsOf n of
  [_] -> n > 1
  _ -> False

Answer 2

(total rewrite) 是的，您的第一个变体更好。相当于

isPrime n = n > 1 && head fs == n
    where
       fs = primeFactorsOf n

第二个变种是

isPrime n = n > 1 && fs == [n]
    where
       fs = primeFactorsOf n

相当于

isPrime n = n > 1 && head fs == n && null (tail fs)
    where
       fs = primeFactorsOf n

对于复合材料，两者的行为相同，但对于素数，后一种变体将不必要地执行额外的测试。

我们可能会想“简化和改进”最后一个变体

isPrime n = n > 1 && null (tail fs)
    where
       fs = primeFactorsOf n

这将节省素数的数字比较操作，但对于复合它实际上会强制计算 n 的第二个因子，这是不必要的，这可能会非常昂贵（例如 n = 2 * p 与 p 一些大素数）。您的第一个变体将找到第一个因素并立即返回 False。

---

为了纠正这个问题，我们可以手动“融合”isPrime 和 primeFactors。假设它被定义为

primeFactors n = factor n primes
    where
        factor n (p:ps) 
            | p*p > n        = [n]
            | n `mod` p == 0 = p : factor (n `div` p) (p:ps)
            | otherwise      = factor n ps

融合上一个版本，变成了

isPrime n = n > 1 && hasOneFactor n primes  -- (null . tail . primeFactorsOf)
    where                                   --   == hasOneFactor
        hasOneFactor n (p:ps) 
            | p*p > n        = True
            | n `mod` p == 0 = False
            | otherwise      = hasOneFactor n ps

这是现在最有效的代码。它可以进一步重写为（另外，rem 比 mod 快）

isPrime n = n > 1 && hasOneFactor primes    -- no need to pass `n` around
    where
        hasOneFactor (p:ps) = p*p > n ||
                              ( n `rem` p /= 0 && 
                                hasOneFactor ps )

或

isPrime n = n > 1 && foldr (\p r-> p*p > n || (rem n p /= 0 && r))
                           undefined primes