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 调用我上面定义的 return

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

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

return 会调用 return我在 monad 实例中定义并将 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 表示法，因为它只会调用 Monad 函数 return 和 >>=。所以你必须在没有任何 monad 函数的情况下写出来，无论是 do 符号还是调用 >>= 或 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 表示法或 >>= 并没有语法上的错误。问题在于 >>= 是递归定义的，因此当您尝试使用它时，程序会进入无限循环。

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

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

Answer 2

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

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

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

Desugars 为

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

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

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

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

(Something a) >>= f = f a

This is the Identity Monad - 有很多关于它的文章 - 这是理解 monad 的一个很好的起点工作。

Answer 3

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

   data Something a = Something a
   
   实例 Monad 某事在哪里
       返回 a = 某个东西 a
       m>>=f=do
           var<-m
           变量
   

2. 由于 >>= 的定义位于 instance Monad Something where 下，> ;>= 的类型是 Something a -> (a -> 某物 b) ->一些b。因此它可以判断 f var 必须是 Something b 类型。这里谷歌搜索的术语是“类型推断”

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