haskell - haskell 中最快的错误单子(monad)是什么？

Question

Maybe/Either monad 显着减慢了速度。使用一些延续单子(monad)来处理错误会加快速度吗？是否存在“内置延续单子(monad)”或“内置错误单子(monad)”之类的东西？内置我的意思是像ST。

基准:

import Criterion.Main                                          

unsafeDiv x 0 = error "division by zero"                       
unsafeDiv x y = x `div` y                                      

safeDiv x 0 = Nothing                                          
safeDiv x y = Just (x `div` y)                                 

test1 :: Int -> [Int]                                          
test1 n = map (n `unsafeDiv`) [n,n-1..1]                       

test2 :: Int -> Maybe [Int]                                    
test2 n = mapM (n `safeDiv`) [n-1,n-2..0]                      

test3 :: Int -> Maybe [Int]                                    
test3 n = test3' Just [n-1,n-2..0]                             
  where test3' k []     = k []                                 
        test3' k (0:ns) = Nothing                              
        test3' k (n:ns) = test3' (k . (n:)) ns                 

main = defaultMain                                             
  [ bench "test1" (nf test1 100000)                            
  , bench "test2" (nf test2 100000)                            
  , bench "test3" (nf test3 100000)                            
  ] 

Answer 1

通常使用 Maybe/Either 不会减慢速度。但是，如果 Maybe/Either 确实是您的瓶颈，您可以尝试使用基于 CPS 的 Maybe monad，如 contstuff包裹。另一种可能性是使用带有逃生路线的 Cont monad。

无论如何，我不相信 Maybe 和 Either 是瓶颈。您可能会错误地使用它们，例如强制太多。一种常见的误解是，所有性能问题都可以通过使用 seq 来解决。 .