Question

我写了这个函数：

appFunc :: Integer -> Integer -> Bool -> Maybe (Integer,Integer)
appFunc i1 i2 b = if b then Just (i1,i2) else Nothing

然后我在GHCi中使用它：

> appFunc <$> Just 3 <*> Nothing <*> Just True
Nothing

这很棒，因为如果至少一个参数为Nothing，则整个表达式的计算结果为Nothing。但是，当所有参数均为Just时，我得到一个嵌套的Maybe：

> appFunc <$> Just 3 <*> Just 1 <*> Just False
Just Nothing

理想情况下，我希望它评估为普通的旧Nothing。所以我的解决方案是使用join：

> join $ appFunc <$> Just 3 <*> Just 1 <*> Just True
Just (3,1)

是否有更好的解决方案或更简洁的风格？我正在尝试monad >>=函数，但没有成功。例如，我尝试编写：

> Just True >>= appFunc <$> Just 3 <*> Just 1
* Couldn't match expected type `Bool -> Maybe b'
              with actual type `Maybe (Bool -> Maybe (Integer, Integer))'
* Possible cause: `(<*>)' is applied to too many arguments
  In the second argument of `(>>=)', namely
    `appFunc <$> Just 5 <*> Just 4'
  In the expression: Just True >>= appFunc <$> Just 5 <*> Just 4
  In an equation for `it':
      it = Just True >>= appFunc <$> Just 5 <*> Just 4
* Relevant bindings include
    it :: Maybe b (bound at <interactive>:51:1)

这个错误对我来说很有意义，因为：

 appFunc <$> Just 3 <*> Just 1 :: m (a -> m b)

而>>= :: m a -> (a -> m b) -> m b

有单子解决方案吗？还是应该坚持使用join的应用风格？

Answer 1

为什么不只是

module Main where

import Data.Bool

appFunc :: Integer -> Integer -> Bool -> Maybe (Integer, Integer)
appFunc i1 i2 what = bool Nothing (Just (i1,i2)) what

result = do
  i1 <- Just 1
  i2 <- Just 2
  test <- Just True
  appFunc i1 i2 test

result2 = Just 1 >>= \i1 -> Just 2 >>= \i2 -> Just True >>= appFunc i1 i2 

main = do
  print result
  print result2

您的appFunc更像是典型的monadFunc。正如duplode已经提到的，使用join只是monad解决方案，我只是将其改写为更惯用的样式。

为了更好地了解这些内容，让我们看一下中央应用操作的签名

(<*>) :: Applicative f => f (a -> b) -> f a -> f b

(<*>)的所有三个参数都是应用包装的值，并且(<*>)在需要进行深入处理之前就知道了“包装”。例如

Just (+1) <*> Just 5

在这种情况下，涉及“包装”函数(+1)和“包装”值5的计算在这种情况下无法更改“包装” Just。

另一方面，您的appFunc需要纯值才能产生“包装”中的内容。那不是适用的。在这里，我们需要对这些值进行一些计算，以了解“包装”的组成部分是什么。

让我们看一下中央单子手术：

(>>=) :: Monad m => m a -> (a -> m b) -> m b

第二个参数正是这样做的。它是一个采用纯值并在包装中返回某些内容的函数。就像appFunc i1 i2。

有关适用性和嵌套Maybe的问题

1 个答案: