有没有办法从 IO monad 中解开类型？

Question

我有这个非常简单的功能

import qualified Data.ByteString.Lazy as B

getJson :: IO B.ByteString
getJson = B.readFile jsonFile

readJFile :: IO (Maybe Response)
readJFile =  parsing >>= (\d ->
             case d of
                 Left err -> return Nothing
                 Right ps -> return (Just ps))
    where parsing = fmap eitherDecode getJson :: IO (Either String Response)

jsonFile 是我硬盘驱动器上文件的路径（请原谅缺少 do-notation，但我发现这样使用起来更清晰）

我的问题是；有没有办法让我放弃IO 部分，以便我可以单独使用字节串？

我知道您可以对某些 monad（例如 Either 和 Maybe）进行模式匹配以获取它们的值，但是您可以使用 IO 做类似的事情吗？

或者说不同的声音：有没有办法让readJFile 在没有 IO 的情况下返回 Maybe Response？

Answer 1

要扩展我的 cmets，您可以这样做：

getJson :: IO B.ByteString
getJson = B.readFile jsonFile -- as before

readJFile :: B.ByteString -> Maybe Response -- look, no IO
readJFile b = case eitherDecode b of
                Left err -> Nothing
                Right ps -> Just ps

最后，您再次将所有内容组合到一个 IO 操作中：

getAndProcess :: IO (Maybe Response)
getAndProcess = do
  b <- getJson
  return (readJFile b)

Answer 2

您永远不需要通过任何函数“拖动 monad”，除非它们都需要实际执行 IO。只需使用fmap（或liftM / liftM2 / ...）将整个链提升到monad。

例如，

f1 :: B.ByteString -> K
f2 :: K -> I
f3 :: K -> J
f4 :: I -> J -> M

你的整个事情应该是这样的

m :: M
m = let k = "f1 getJson"
    in f4 (f2 k) (f3 k)

你可以简单地做

m = fmap (\b -> let k = f1 b
                in f4 (f2 k) (f3 k) )
    getJson

顺便说一句，使用do 表示法可能看起来更好：

m = do
  b <- getJson
  return $ let k = f1 b
           in f4 (f2 k) (f3 k)

---

关于你的编辑和问题

有没有办法让readJFile 在没有IO 的情况下返回Maybe Response？

不，这不可能，因为readJFile 确实需要做 IO。那么，没有办法从IO monad 中逃脱，这就是它的全部意义所在！ （嗯，正如 Ricardo 所说，有 unsafePerformIO，但这绝对不是一个有效的应用程序。）

如果是在 IO monad 中解包 Maybe 值以及其中带有括号的签名的笨拙，您可能需要查看 MaybeT transformer。

readJFile' :: MaybeT IO Response
readJFile' = do
   b <- liftIO getJson
   case eitherDecode b of
     Left err -> mzero
     Right ps -> return ps

Answer 3

不，没有从 IO monad 中获取值的安全方法。相反，您应该通过使用 fmap 或 bind (>>=) 应用函数来完成 IO monad 内部的工作。此外，当您希望结果为 Maybe 时，您应该使用 decode 而不是 eitherDecode。

getJson :: IO B.ByteString
getJson = B.readFile jsonFile

parseResponse :: B.ByteString -> Maybe Response
parseResponse = decode

readJFile :: IO (Maybe Response)
readJFile = fmap parseResponse getJSON

如果你更清楚，你也可以使用 do 表示法：

readJFile :: IO (Maybe Response)
readJFile = do
    bytestring <- getJson
    return $ decode bytestring

请注意，您甚至不需要 parseResponse 函数，因为 readJFile 指定了类型。

Answer 4

一般来说，是的，有办法。伴随着很多“但是”，但是有。你问的是所谓的不安全的 IO 操作：System.IO.Unsafe。它通常用于在调用外部库时编写包装器，而不是在常规 Haskell 代码中使用。

基本上，您可以调用unsafePerformIO :: IO a -> a，它完全符合您的要求，它会去掉IO 部分并返回a 类型的包装值。但是，如果您查看文档，您应该向系统保证一些要求，这些要求都以相同的想法结束：即使您通过 IO 执行操作，答案也应该是函数，正如在 IO 中不运行的任何其他 haskell 函数所期望的那样：它应该始终具有相同的结果而没有副作用，仅基于输入值。

在这里，鉴于您的代码，显然不是这种情况，因为您正在从文件中读取。您应该继续在 IO monad 中工作，方法是从另一个结果类型为 IO something 的函数中调用您的 readJFile。然后，您将能够读取 IO 包装器中的值（您自己在 IO 中），对其进行处理，然后在返回时将结果重新包装到另一个 IO 中。