为什么 throw 和 throwIO 有区别？

Question

我正在努力牢牢掌握异常情况，以便改进我的conditional loop implementation。为此，我进行了各种实验，扔东西，看看会被抓到什么。

这个让我惊喜不已：

% cat X.hs
module Main where

import Control.Exception
import Control.Applicative

main = do
    throw (userError "I am an IO error.") <|> print "Odd error ignored."

% ghc X.hs && ./X
...
X: user error (I am an IO error.)

% cat Y.hs
module Main where

import Control.Exception
import Control.Applicative

main = do
    throwIO (userError "I am an IO error.") <|> print "Odd error ignored."

% ghc Y.hs && ./Y
...
"Odd error ignored."

我认为替代方案应该完全忽略 IO 错误。 （不知道我从哪里得到这个想法，但我当然不能提供一个在替代链中会被忽略的非 IO 异常。） 所以我想我可以手工制作并提供一个 IO 错误.事实证明，它是否被忽略取决于包装和内容：如果我 throw 一个 IO 错误，它在某种程度上不再是一个 IO 错误。

我完全迷路了。为什么它会这样工作？是有意的吗？这些定义深入到 GHC 内部模块；虽然我自己或多或少可以理解不同代码片段的含义，但我很难看到整体情况。

如果很难预测，是否应该使用这个 Alternative 实例？如果它消除任何同步异常，而不仅仅是以特定方式定义并以特定方式抛出的一小部分异常，这不是更好吗？

Answer 1

说你有

x :: Integer

这意味着x 当然应该是一个整数。

x = throw _whatever

这是什么意思？这意味着应该有一个Integer，但实际上只是一个错误。

现在考虑

x :: IO ()

这意味着x 应该是一个不返回有用值的 I/O 执行程序。请记住，IO 值只是 值。它们是恰好代表命令式程序的值。所以现在考虑

x = throw _whatever

这意味着那里应该有一个执行 I/O 的程序，但实际上只是一个错误。 x 不是引发错误的程序——没有程序。无论您是否使用过IOError，x 都不是有效的IO 程序。当你尝试执行程序时

x <|> _whatever

你必须执行x 来查看它是否会抛出错误。但是，你不能执行x，因为它不是程序——这是一个错误。相反，一切都会爆炸。

这与

有很大不同

x = throwIO _whatever

现在x 是一个有效的程序。它是一个总是会抛出错误的有效程序，但它仍然是一个可以实际执行的有效程序。当你尝试执行时

x <|> _whatever

现在，x 被执行，产生的错误被丢弃，_whatever 被执行。您还可以认为计算程序/弄清楚要执行什么和实际执行它之间存在差异。 throw 在计算要执行的程序时抛出错误（它是一个“纯异常”），而throwIO 在执行过程中抛出它（它是一个“不纯异常”）。这也解释了它们的类型：throw 返回任何类型，因为所有类型都可以“计算”，但throwIO 仅限于IO，因为只能执行程序。

由于您可以捕获在执行IO 程序时发生的纯异常，这使情况变得更加复杂。我相信这是一种设计妥协。从理论上讲，您不应该能够捕获纯粹的异常，因为它们的存在应始终被视为表明程序员错误，但这可能相当尴尬，因为那样您就只能处理外部错误，而程序员的错误会导致一切崩溃。如果我们是完美的程序员，那很好，但我们不是。因此，您可以捕获纯异常。

is :: [Int]
is = []

-- fails, because the print causes a pure exception
-- it was a programmer error to call head on is without checking that it,
-- in fact, had a head in the first place
-- (the program on the left is not valid, so main is invalid)
main1 = print (head is) <|> putStrLn "Oops"
-- throws exception

-- catch creates a program that computes and executes the program print (head is)
-- and catches both impure and pure exceptions
-- the program on the left is invalid, but wrapping it with catch
-- makes it valid again
-- really, that shouldn't happen, but this behavior is useful
main2 = print (head is) `catch` (\(_ :: SomeException) -> putStrLn "Oops")
-- prints "Oops"

Answer 2

throw 是undefined 和error 的泛化，是为了在纯代码中抛出异常。当异常的值无关紧要时（大多数情况下），它用符号 ⟘ 表示“未定义值”。

throwIO 是一个抛出异常的 IO 动作，但它本身并不是一个未定义的值。

throwIO 的文档因此说明了差异：

throw e   `seq` x  ===> throw e
throwIO e `seq` x  ===> x

问题是(<|>) 被定义为mplusIO，它使用catchException，这是catch 的严格变体。这种严格性总结如下：

⟘ <|> x = ⟘

因此您在throw 变体中得到一个异常（并且x 永远不会运行）。

请注意，如果不严格，“未定义的动作”（即throw ... :: IO a）实际上表现得就像从catch 的角度抛出的动作：

catch (throw   (userError "oops")) (\(e :: SomeException) -> putStrLn "caught")  -- caught
catch (throwIO (userError "oops")) (\(e :: SomeException) -> putStrLn "caught")  -- caught
catch (pure    (error     "oops")) (\(e :: SomeException) -> putStrLn "caught")  -- not caught

Answer 3

这个答案的其余部分可能并不完全正确。但从根本上讲，区别在于：throwIO 终止并返回一个 IO 操作，而 throw 不 终止。

---

一旦您尝试评估throw (userError "...")，您的程序就会中止。 <|> 从来没有机会查看它的第一个参数来决定是否应该评估第二个参数；事实上，它永远获取第一个参数，因为throw 没有返回值。

对于throwIO，<|> 不评估任何内容；它正在创建一个新的IO 动作，当它确实被执行时，将首先查看它的第一个参数。运行时可以“安全地”执行IO 操作并看到它实际上没有提供值，此时它可以停止并尝试<|> 表达式的另一“半”。