我正在努力理解 State
monad 并编写了两个简单版本的著名斐波那契来内存函数。带有 let
的那个在体内跑得很慢。带有 <-
的那个跑得非常快。我的问题:为什么?让 <-
以某种方式引起全面评估允许 M.lookup
通过 Data.Map
去工作?
-- using state monad and let
-- very slow
fibLet :: Int -> State (M.Map Int Integer) Integer
fibLet n = do
case n of 0 -> return 0
1 -> return 1
n -> do
mp <- get
if M.member n mp
then return $ fromJust (M.lookup n mp)
else do
let s1 = evalState (fibLet (n - 1)) mp
let s2 = evalState (fibLet (n - 2)) mp
let s3 = s1+s2
modify $ M.insert n s3
return s3
fibonacciLet :: Int -> Integer
fibonacciLet n = evalState (fibLet n) M.empty
-- using state monad and <-
-- very fast
fibArrow :: Int -> State (M.Map Int Integer) Integer
fibArrow n = do
case n of 0 -> return 0
1 -> return 1
n -> do
mp <- get
if M.member n mp
then return $ fromJust (M.lookup n mp)
else do
s1 <-fibArrow (n - 1)
s2 <-fibArrow (n - 2)
let s3 = s1+s2
modify $ M.insert n s3
return s3
fibonacciArrow :: Int -> Integer
fibonacciArrow n = evalState (fibArrow n) M.empty
最佳答案
fibLet
实际上根本没有使用它的状态!这就是它如此缓慢的原因;它本质上是一种非常复杂的方式来编写经典的 Haskell 斐波那契定义:
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
仔细看看这里发生了什么:-- from earlier: mp <- get
do
let s1 = evalState (fibLet (n - 1)) mp
let s2 = evalState (fibLet (n - 2)) mp
let s3 = s1+s2
modify $ M.insert n s3
return s3
mp
是 Map
目前已知的结果。您使用 evalState
运行 fibLet (n - 1)
,以 mp
开始其状态.然后你使用 evalState
再次运行fibLet (n - 2)
,以 mp
开始其状态再次。这意味着 fibLet (n - 1)
和 fibLet (n - 2)
不分享任何工作;他们每个人都使用相同的已知结果的起始 map mp
,因此该 map 中尚未包含的任何内容都必须由两个分支计算。然而实际上比这还要糟糕。查看
evalState
的类型:evalState :: State s a -> s -> a
它没有 State
在它的返回类型中。这意味着它实际上不是有状态的。它不与任何周围的状态交互;实际上,它启动了一个新的状态线程,将其运行到完成1,之后状态被丢弃。通过查看
evalState
的类型,您可以很容易地看出这一点。略有不同(但等效):evalState :: State s a -> (s -> a)
evalState
变成 State s a
输入一个简单的函数 s -> a
.显然,一个普通的旧函数不能改变 do
的隐式状态。阻止它的调用(这就是在类型中明确声明状态的全部意义)。所以这意味着:evalState (fibLet (n - 1)) :: M.Map Int Integer -> Integer
evalState (fibLet (n - 1))
只是一个从映射到整数的普通旧函数。它既不访问也不影响任何类型的状态。这意味着在
let s1 = evalState (fibLet (n - 1)) mp
之后外部状态do
block 仍然完全等于 mp
. 没有已保存在我们已计算结果的状态图中。因此,我们不仅没有在两个单独的递归调用之间共享任何工作,而且它们甚至没有在每个调用内部的更深层递归中共享工作!为了证明这一点,请尝试运行
fibLet
使用 runState
而不是 evalState
,所以你可以看到最终的 map 是什么:ghci> runState (fibLet 20) M.empty
(6765,fromList [(20,6765)])
it :: (Integer, M.Map Int Integer)
map 中只有一个条目,作为 do
的最后一步添加阻止在最外层调用 fibLet
,就在它返回之前。如果你对
fibArrow
做同样的事情你得到这个:ghci> runState (fibArrow 20) M.empty
(6765,fromList [(2,1),(3,2),(4,3),(5,5),(6,8),(7,13),(8,21),(9,34),(10,55),(11,89),(12,144),(13,233),(14,377),(15,610),(16,987),(17,1597),(18,2584),(19,4181),(20,6765)])
it :: (Integer, M.Map Int Integer)
您可以清楚地看到它记住了所有中间结果,而不仅仅是最终结果。底线:您通常不想使用
evalState
(以及类似的函数,如 runState
和 execState
)在 State
中运行的函数中单子(monad)。这些函数旨在运行整个有状态计算,因此通常从状态单子(monad)上下文“外部”运行。当你碰巧在一个状态单子(monad)上下文中运行它们时,它们不会与之交互;相反,它们通过普通的参数传递和函数返回接收(并返回,在 runState
和 execState
的情况下)状态,而不是通过 State
提供的隐式状态线程。 .如果要调用“有状态子计算”(即在返回
State _ _
的函数内调用 State _ _
),则需要将子计算绑定(bind)为外部计算的一部分。 do
内的箭头语句 block 这样做; let
声明没有,它 仅限 为普通表达式命名。这就是为什么你发现自己不得不使用 evalState
获得结果并明确提供 mp
即使你已经在一个有状态的上下文中,它应该是隐式可用的;这种困惑是在暗示某些事情是不对的。1 好吧,假设完全需要结果值,它会“运行到完成”。
关于haskell - 对 Haskell 中的 Do 语句中的箭头感到困惑,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/69547542/