使用连续的 Either/Maybe 时减少嵌套

这可能是一个非常基本的 Haskell 问题，但让我们假设以下函数签名

-- helper functions
getWeatherInfo :: Day -> IO (Either WeatherException WeatherInfo)
craftQuery :: WeatherInfo -> Either QueryException ModelQuery
makePrediction :: ModelQuery -> IO (Either ModelException ModelResult)

将以上所有内容链接成一个的天真的方式predict day函数可以是：

predict :: Day -> IO (Maybe Prediction)
predict day = do
    weather <- getWeatherInfo day
    pure $ case weather of
        Left ex -> do
            log "could not get weather: " <> msg ex
            Nothing
        Right wi -> do
            let query = craftQuery wi
            case query of
                Left ex -> do
                    log "could not craft query: " <> msg ex
                    Nothing
                Right mq -> do
                    prediction <- makePrediction mq
                    case prediction of
                        Left ex -> do
                            log "could not make prediction: " <> msg ex
                            Nothing
                        Right p ->
                            Just p

在更命令式的语言中，人们可以这样做：

def getWeatherInfo(day) -> Union[WeatherInfo, WeatherError]:
    pass

def craftQuery(weather) -> Union[ModelQuery, QueryError]:
    pass

def makePrediction(query) -> Union[ModelResult, ModelError]:
    pass

def predict(day) -> Optional[ModelResult]:
    weather = getWeatherInfo(day)
    if isinstance((err := weather), WeatherError):
        log(f"could not get weather: {err.msg}")
        return None

    query = craftQuery weather
    if isinstance((err := query), QueryError):
        log(f"could not craft query: {err.msg}")
        return None

    prediction = makePrediction query
    if isinstance((err := prediction), ModelError):
        log(f"could not make prediction: {err.msg}")
        return None

    return prediction

可以说，它在很多方面都不太安全，也更笨重，但也可以说，更扁平。我可以看到主要的区别是在Python中我们可以（是否应该是一个不同的故事）使用make multiple Earlyreturn在任何阶段停止流程的语句。但这在 Haskell 中是不可用的（无论如何，这看起来非常不惯用，并且首先违背了使用该语言的全部目的）。

然而，在处理链接连续的相同逻辑时，是否有可能在 Haskell 中实现相同类型的“平坦度”Either/Maybe一个接一个地？

-- 按照重复的建议进行编辑：

我可以看到另一个问题是如何相关的，但仅此而已 （相关）-它没有回答这里暴露的问题，即如何 展平 3 层嵌套案例。此外这个问题（这里） 以比其他问题更通用的方式暴露问题， 这是非常特定于用例的。我想回答这个问题 （此处）对社区中的其他读者有益， 与另一位相比。

我理解对于经验丰富的 Haskellers 来说这是多么明显 ”只需使用 EitherT“听起来是一个完全有效的答案，但是 这里的要点是，这个问题是从以下角度提出的： 一个不是经验丰富的 Haskeller 的人，也是一个读过并阅读过的人 再次强调 Monad 转换器有其局限性，也许是免费的 monad 或 Polysemy 或其他替代品是最好的，等等。我想 这对于整个社区来说是有用的，拥有这个特定的 在这方面问题有不同的答案，所以 新手哈斯凯勒会发现自己稍微不那么“迷失在翻译中” 当开始面对更复杂的代码库时。

为了“反向推断”monad 转换器是正确的工具，请考虑不需要 IO 的情况（例如，因为天气信息来自内存中已有的静态数据库）：

getWeatherInfo' :: Day -> Either WeatherException WeatherInfo
craftQuery :: WeatherInfo -> Either QueryException ModelQuery
makePrediction' :: ModelQuery -> Either ModelException ModelResult

你的例子现在看起来像

predict' :: Day -> Maybe Prediction
predict' day =
    let weather = getWeatherInfo' day
    in case weather of
        Left ex ->
            Nothing
        Right wi -> do
            let query = craftQuery wi
            in case query of
                Left ex ->
                    Nothing
                Right mq ->
                    let prediction = makePrediction' mq
                    in case prediction of
                        Left ex ->
                            Nothing
                        Right p ->
                            Just p

几乎任何 Haskell 教程都解释了如何将其扁平化，使用以下事实：Maybe是一个单子：

predict' :: Day -> Maybe Prediction
predict' day = do
    let weather = getWeatherInfo' day
    weather' <- case weather of
      Left ex -> Nothing
      Right wi -> Just wi
    let query = craftQuery weather'
    query' <- case query of
      Left ex -> Nothing
      Right mq -> Just mq
    let prediction = makePrediction' query'
    prediction' <- case prediction of
      Left ex -> Nothing
      Right p -> Just p
    return prediction'

总是绑定有点尴尬variableName with let提取之前variableName'来自单子。这里实际上是不必要的（你可以直接输入getWeatherInfo' day本身在case声明），但请注意，更普遍的是这种情况：

predict' :: Day -> Maybe Prediction
predict' day = do
    weather <- pure (getWeatherInfo' day)
    weather' <- case weather of
      Left ex -> Nothing
      Right wi -> Just wi
    query <- pure (craftQuery weather')
    query' <- case query of
      Left ex -> Nothing
      Right mq -> Just mq
    prediction <- pure (makePrediction' query')
    prediction' <- case prediction of
      Left ex -> Nothing
      Right p -> Just p
    return prediction'

重点是，你要绑定的东西weather本身可以在Maybe monad.

避免本质上重复的变量名称的一种方法是使用 lambda-case 扩展，这允许您将其中之一进行 eta 缩减。此外，Just and Nothing值只是一个具体示例pure and empty https://hackage.haskell.org/package/base-4.12.0.0/docs/Control-Applicative.html#t:Alternative，用它你可以得到这个代码：

{-# LANGUAGE LambdaCase #-}

import Control.Applicative

predict' :: Day -> Maybe Prediction
predict' day = do
    weather <- pure (getWeatherInfo' day) >>= \case
      Left ex -> empty
      Right wi -> pure wi
    query <- case craftQuery weather of
      Left ex -> empty
      Right mq -> pure mq
    prediction <- pure (makePrediction' query) >>= \case
      Left ex -> empty
      Right p -> pure p
    return prediction

很好，但你不能在里面工作只是Maybe monad因为你也有以下的影响IO单子。换句话说，你不想要Maybe to bemonad，而是将其短路属性放在IO单子。因此你转换 the IO单子。你仍然可以lift https://hackage.haskell.org/package/base-4.12.0.0/docs/Control-Monad-IO-Class.html#t:MonadIO普通的旧式未转换 IO 操作为MaybeT堆栈，并且仍然使用pure and empty出于可能的考虑，从而获得与没有 IO 时几乎相同的代码：

predict :: Day -> MaybeT IO Prediction
predict day = do
    weather <- liftIO (getWeatherInfo day) >>= \case
      Left ex -> empty
      Right wi -> pure wi
    query <- case craftQuery weather of
      Left ex -> empty
      Right mq -> pure mq
    prediction <- liftIO (makePrediction query) >>= \case
      Left ex -> empty
      Right p -> pure p
    return prediction

最后，您现在可以更进一步，还使用转换器层以更好的方式处理日志记录。可以用以下方法完成WriterT https://hackage.haskell.org/package/transformers-0.5.6.2/docs/Control-Monad-Trans-Writer-Lazy.html。相对于IO日志的优点是日志不会直接结束某处，但是函数的调用者将知道创建了日志，并可以决定是否将其放入文件中或直接在终端上显示或直接丢弃它。

但因为你似乎总是只是记录Nothing情况下，更好的选择是不使用Maybe变压器除了Except https://hackage.haskell.org/package/transformers-0.5.6.2/docs/Control-Monad-Trans-Except.html相反，因为这似乎是你的想法：

import Control.Monad.Trans.Except

predict :: Day -> ExceptT String IO Prediction
predict day = do
    weather <- liftIO (getWeatherInfo day) >>= \case
      Left ex -> throwE $ "could not get weather: " <> msg ex
      Right wi -> pure wi
    query <- case craftQuery weather of
      Left ex -> throwE $ "could not craft query: " <> msg ex
      Right mq -> pure mq
    prediction <- liftIO (makePrediction query) >>= \case
      Left ex -> throwE $ "could not make prediction: " <> msg ex
      Right p -> pure p
    return prediction

事实上，你的原语可能首先应该在那个 monad 中，然后它会变得更加简洁：

getWeatherInfo :: Day -> ExceptT WeatherException IO WeatherInfo
makePrediction :: ModelQuery -> ExceptT ModelException IO WeatherInfo

predict day = do
    weather <- withExcept (("could not get weather: "<>) . msg)
       $ getWeatherInfo day
    query <- withExcept (("could not craft query: "<>) . msg)
        $ except (craftQuery weather)
    prediction <- withExcept (("could not make prediction: "<>) . msg)
        $ makePrediction query
    return prediction

最后，最后请注意，您实际上并不需要绑定中间变量，因为您始终只是在下一个操作中传递它们。也就是说，你有一个组合链克莱斯利箭 https://en.wikipedia.org/wiki/Kleisli_category:

predict = withExcept (("could not get weather: "<>) . msg)
                   . getWeatherInfo
      >=> withExcept (("could not craft query: "<>) . msg)
                   . except . craftQuery
      >=> withExcept (("could not make prediction: "<>) . msg)
                   . makePrediction