haskell - 'return' 关键字有什么特别之处

Question

当我似乎理解了 Haskell 中 return 的用途时，我尝试使用不同的替代方案，似乎 return 不仅可以在 monad 链中的任何地方使用，而且可以完全排除

*Main> Just 9 >>= \y -> (Just y) >>= \x -> return x
Just 9

*Main> Just 9 >>= \y -> (return y) >>= \x -> (Just y)
Just 9

*Main> Just 9 >>= \y -> (Just y) >>= \x -> (Just x)
Just 9 

即使我在自己的实例中省略 return ，我也只会收到警告......

data MaybeG a = NothingG | JustG a deriving Show 
instance Monad MaybeG where  
    --    return x = JustG x  
        NothingG >>= f = NothingG  
        JustG x >>= f  = f x  
        fail _ = NothingG  

Monad.hs:3:10:
    Warning: No explicit method nor default method for `return'
    In the instance declaration for `Monad MaybeG'

我仍然可以使用单子(monad)

*Main> JustG 9 >>= \y -> (JustG 11) >>= \x -> (JustG y)
JustG 9

*Main> JustG 9 >>= \y -> (NothingG) >>= \x -> (JustG y)
NothingG

那么 return 关键字有什么特别之处呢？这是关于我不能省略的更复杂的情况吗？还是因为这是做事的“正确”方式，即使它们可以以不同的方式完成？

更新:
.. 或另一种选择，我可以定义我自己的一元值构造函数

finallyMyLastStepG :: Int -> MaybeG Int
finallyMyLastStepG a = JustG a  

并产生同一链的另一个变体(具有相同的结果)

*Main> JustG 9 >>= \y -> (JustG 11) >>= \x -> (finallyMyLastStepG y)
JustG 9

Answer 1

So what's so special about the return keyword?

首先， return不是 Haskell 中的关键字。它是一个重载函数。

其类型由下式给出:

class  Monad m  where
    -- | Sequentially compose two actions, passing any value produced
    -- by the first as an argument to the second.
    (>>=)       :: m a -> (a -> m b) -> m b

    -- | Inject a value into the monadic type.
    return      :: a -> m a

所以你看到 return是一个给定 a 类型值的函数, 返回 m a 类型的新值, 其中 m是某种类型，它是 Monad 的实例.此类类型包括:

单子(monad) []

单子(monad) I0

单子(monad) Maybe

单子(monad) STM

单子(monad) ((->) r)

单子(monad) (Either e)

单子(monad) (ST s)

还有更多。 'Monad' 的实例应满足以下定律:

> return a >>= k  ==  k a
> m >>= return  ==  m
> m >>= (\x -> k x >>= h)  ==  (m >>= k) >>= h

一个函数的实现 a -> m a很容易猜到。以下是最常见的 monad 的定义:

列表:

 return x = [x]

也许

 return x = Just x

所以你看到 return是一个重载函数，它将一个值“提升”到一个单子(monad)包装器中。因此，您可以在任何可以使用其定义的地方使用它。例如。

Prelude> 1 : return 2
[1,2]

或在 the do notion (在 chaining expressions 时有用)。

> do v <- return 7 ; return v :: Maybe Int
Just 7

使用单子(monad)的真正原因 return是在某些 monad 中组合多个值时:

Prelude> do x <- return 1 ; y <- return 2 ; return (x + y) :: Maybe Int
Just 3
Prelude> do x <- Nothing  ; y <- return 2 ; return y
Nothing

在最后一个语句中，您会看到链在给定 monad 达到零值后是如何短路的。在这种情况下 Nothing .

摘要: return是一个重载函数，它将一个值提升到一个单子(monad)包装器中。当您需要提升值(value)时，您可以使用它。它不是控制流关键字，因为它在命令式语言中。