Haskell 是否总是知道要调用哪个“返回”？

Question

我正在定义一个 monad 的实例，如下所示：

data Something = Something a

instance Monad Something where
    return a = Something a        --Wraps a in 'Something', correct?
    m >>= f = do
        var <- m
        return $ f var            --I want this to pass var to f, then wrap the result
                                  --back up in the 'Something' monad with the return I
                                  --Just defined

问题是->

1：我所做的事情是否有任何明显的错误/误解？

2：Haskell 是否知道从 m >>= f 调用我上面定义的返回值

3：如果我出于某种原因定义了另一个函数

f :: Something a -> Something b
f x = do
    var <- x
    return $ doMagicTo x

return 会调用我在 monad 实例中定义的 return 并将 x 包装在 Something 中吗？

Answer 1

这里有几个大问题。

首先，Monad 实例必须具有 kind * -> *。这意味着他们至少需要一个类型变量，而您的Something 没有。比较：

-- kind * -> *
Maybe
IO
Either String

-- kind *
Maybe Int
IO ()
Either String Double

看到Maybe、IO 和Either String 中的每一个都需要一个类型参数才能使用它们吗？使用Something，没有地方可以填写类型参数。因此您需要将定义更改为：

data Something a = Something a

第二个大问题是你的 Monad 实例中的 >>= 是错误的。您通常不能使用 do-notation，因为它只会调用 Monad 函数 return 和 >>=。因此，您必须在没有任何 monad 函数的情况下将其写出来，无论是 do-notation 还是调用 >>= 或 return。

instance Monad Something where
    return a = Something a        --Wraps a in 'Something'
    (Something m) >>= f = f m     --unwraps m and applies it to f

>>= 的定义比你想象的要简单。展开 m 很容易，因为您只需要在 Something 构造函数上进行模式匹配。还有f :: a -> m b，所以您不必担心再次包装它，因为f 会为您完成。

虽然没有办法一般解开一个monad，但可以解开很多特定的monad。

请注意，在 monad 实例声明中使用 do-notation 或 >>= 在语法上没有任何问题。问题是>>= 是递归定义的，因此当您尝试使用它时程序会进入无限循环。

（注意这里定义的Something 是Identity monad）

对于您的第三个问题，是的，在 Monad 实例中定义的 return 函数将被调用。类型类是按类型分派的，并且由于您已指定类型必须为 Something b，编译器将自动使用 Something 的 Monad 实例。 （我想你的意思是最后一行是doMagicTo var）。

Answer 2

主要问题是您对>>= 的定义是循环的。

Haskell 的 do 语法是 >>= 和 >> 链的语法糖，所以你的定义

m >>= f = do
    var <- m
    return $ f var         

脱糖

m >>= f = 
    m >>= \var -> 
    return $ f var

所以您将m >>= f 定义为m >>= \...，这是循环的。

您需要对>>= 做的是定义如何从m 中提取一个值以传递给f。此外，您的f 应该返回一个单子值，因此在这里使用return 是错误的（这更接近于您定义fmap 的方式）。

>>= 对 Something 的定义可以是：

(Something a) >>= f = f a

这就是 Identity Monad - 有很多关于它的文章 - 这是了解 monad 如何工作的一个很好的起点。

Answer 3

1. 关闭。 return 在这里是多余的，您需要在 Something 类型构造函数中添加类型参数。 编辑：这段代码仍然是错误的。 >>= 的定义是循环的。有关详细信息，请参阅其他答案。

   data Something a = Something a
   
   instance Monad Something where
       return a = Something a
       m >>= f = do
           var <- m
           f var
   

2. 由于您对>>= 的定义在instance Monad Something where 下，所以>>= 的类型是Something a -> (a -> Something b) -> Something b。所以它可以看出f var 必须是Something b 类型。在这里谷歌的术语是“类型推断”

3. 是的。同样，这是类型推断。如果编译器不能推断出你想要的类型，它会告诉你。但通常可以。