是否有可能在函数结果已知时停止GHCi调试器?
例如，考虑下面的代码片段:blabla :: [Int] -> Int
bla :: Int -> Int
papperlap :: Int -> Int -> Int
bla x = x+x
papperlap y x = ((y *) . bla) x
blabla xs = foldl papperlap 0 x
现在，我想看看' paperlap '和'bla'的结果。但是记住，我想在计算结果时停止。因此，使用':force'是不可能的，因为它改变了求值的顺序。
当我使用':break'时，调试器停止，但_result尚未评估。请在下面找到我的GHCi会话，它没有产生期望的中间结果:
GHCi, version 7.6.3: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
[1 of 1] Compiling Main ( bla1.hs, interpreted )
Ok, modules loaded: Main.
*Main> :break blabla
Breakpoint 0 activated at bla1.hs:7:1-36
*Main> :break papperlap
Breakpoint 1 activated at bla1.hs:6:1-31
*Main> :break bla
Breakpoint 2 activated at bla1.hs:5:1-19
*Main> blabla [1,2,3]
Stopped at bla1.hs:7:1-36
_result :: Int = _
[bla1.hs:7:1-36] *Main> :step
Stopped at bla1.hs:7:17-36
_result :: Int = _
xs :: [Int] = [1,2,3]
[bla1.hs:7:17-36] *Main> :step
Stopped at bla1.hs:6:1-31
_result :: Int = _
[bla1.hs:6:1-31] *Main> :step
Stopped at bla1.hs:6:17-31
_result :: Int = _
x :: Int = 3
y :: Int = _
[bla1.hs:6:17-31] *Main> :step
Stopped at bla1.hs:6:1-31
_result :: Int = _
[bla1.hs:6:1-31] *Main> :step
Stopped at bla1.hs:6:17-31
_result :: Int = _
x :: Int = 2
y :: Int = _
[bla1.hs:6:17-31] *Main> :step
Stopped at bla1.hs:6:1-31
_result :: Int = _
[bla1.hs:6:1-31] *Main> :step
Stopped at bla1.hs:6:17-31
_result :: Int = _
x :: Int = 1
y :: Int = 0
[bla1.hs:6:17-31] *Main> :step
Stopped at bla1.hs:5:1-19
_result :: Int = _
[bla1.hs:5:1-19] *Main> :step
Stopped at bla1.hs:5:17-19
_result :: Int = _
x :: Int = 1
[bla1.hs:5:17-19] *Main> :step
Stopped at bla1.hs:5:1-19
_result :: Int = _
[bla1.hs:5:1-19] *Main> :step
Stopped at bla1.hs:5:17-19
_result :: Int = _
x :: Int = 2
[bla1.hs:5:17-19] *Main> :step
Stopped at bla1.hs:5:1-19
_result :: Int = _
[bla1.hs:5:1-19] *Main> :step
Stopped at bla1.hs:5:17-19
_result :: Int = _
x :: Int = 3
[bla1.hs:5:17-19] *Main> :step
0
*Main>
对于您当前的调试问题来说可能有点晚了，但是我要这样做:
blabla :: [Int] -> Int
bla :: Int -> Int
papperlap :: Int -> Int -> Int
bla x = (undefined :: Int)
papperlap y x = ((y *) . bla) x
blabla xs = foldl papperlap 0 xs
现在我们知道我们将在bla的求值中得到一个异常。我们输入ghci:
[1 of 1] Compiling Main ( temp.hs, interpreted )
Ok, modules loaded: Main.
λ: :set -fbreak-on-exception
λ: :trace blabla [1,5,17]
Stopped at <exception thrown>
_exception :: e = _
λ: :hist
-1 : bla (temp.hs:6:17-35)
-2 : bla (temp.hs:6:1-35)
-3 : papperlap (temp.hs:7:17-31)
-4 : papperlap (temp.hs:7:1-31)
-5 : papperlap (temp.hs:7:17-31)
-6 : papperlap (temp.hs:7:1-31)
-7 : papperlap (temp.hs:7:17-31)
-8 : papperlap (temp.hs:7:1-31)
-9 : blabla (temp.hs:8:13-32)
-10 : blabla (temp.hs:8:1-32)
<end of history>
λ: :back
Logged breakpoint at temp.hs:6:17-35
_result :: a
λ: :list
5
6 bla x = (undefined :: Int )
^^^^^^^^^^^^^^^^^^^
7 papperlap y x = ((y *) . bla) x
λ: :back
Logged breakpoint at temp.hs:6:1-35
_result :: a
λ: :list
5
6 bla x = (undefined :: Int )
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
7 papperlap y x = ((y *) . bla) x
λ: :back
Logged breakpoint at temp.hs:7:17-31
_result :: Int
x :: Int
y :: Int
λ: :list
6 bla x = (undefined :: Int )
7 papperlap y x = ((y *) . bla) x
^^^^^^^^^^^^^^^
8 blabla xs = foldl papperlap 0 xs
因此我们可以看到bla右侧求值前的堆栈
这是不完美的，因为把undefined s无处不在似乎俗气和hacky，但:hist给了你相当多的工作已经，并使用:list作为你退后一步，使事情更加清晰。
Haskell不会为您逐步遍历文字表达式。比如
e = 2*(2+2)
将立即求值为8，因为编译器将优化任何由文字组成的表达式，它可以在编译时发现只是"躺着"(这种类型的表达式称为常量应用形式)。
现在你必须意识到foldl是懒惰的。如果在列表上调用foldl f，它不会执行f的单次求值，直到绝对被迫这样做。
>foldl (+) 0 [1,2,3]
>foldl (+) a1 [2,3]
where a1 = 0+1
>foldl (+) a2 [3]
where a2 = a1+2
where a1 = 0+1
最终我们得到了((0+1)+2)+3)，编译器说:"好吧，我们已经用尽了每个列表，并将每个求值扩展为最原始的形式。让评估"。而且我们已经知道Haskell 不会逐步完成CAF的求值。
如果你想看到求值的中间值，你必须首先生成它们。执行此操作的方法是foldl的以下严格变体:
foldl' f z [] = z
foldl' f z (x:xs) = let z' = z `f` x
in seq z' $ foldl' f z' xs
我将留给你去弄清楚它是如何工作的，但是seq a b将在继续惰性计算b之前完全评估a。
除了将foldl更改为foldl'之外，其他一切都和以前一样。当您逐步执行计算时，当您暂停在foldl'函数中时，您将看到中间值。