采用整数的 monad 的简单示例

Question

我正在编写一个基于 Monads 的解释 (https://www.youtube.com/watch?v=ZhuHCtR3xq8) 组成函数 f 和 g 的 Monad。解释停在一个关键部分：要组合一个函数（比如 f）a -> ma 和另一个（比如 g）a -> ma，你需要一种将 ma 转换为 a 的方法，以便从 monad 中取出东西容器（否则你怎么能将 f 的输出输入到 g 中？？），这没有得到解决。

假设我们有 f 和 g 映射一个 Integer 并返回一个 Maybe：

f :: Int -> Maybe Int
f = \x -> (Just x)

g :: Int -> Maybe Int
g = \x -> (Just x)

我想制作一个允许我组合 f 和 g 的 Monad，以便可以评估 (g o f)(x)（意思是 f(g(x))）。为此，我们需要一种将Maybe Int（f 的输出）转换为Int 的方法，以便将其发送到g。当Maybe 容器中有值时，我们只需提取该值。当 g 的输出为 Nothing 时，我们可以考虑值 0（我知道 g 的输出不能是上述 g 的 Nothing，但假设另一个 f 可以）。

这是我尝试定义执行此操作的 Monad MyMonad 的失败尝试：

f :: Int -> Maybe Int
f = \x -> (Just x)

g :: Int -> Maybe Int
g = \x -> (Just x)

data MyMonad a = Maybe a

instance Monad MyMonad where
  return x = MyMonad x
  Just x >>= (\x -> MyMonad (Just x))
  Nothing >>= (\x -> MyMonad (Just 0))

有人可以澄清这里有什么问题吗？从教程中很难知道在函数内部进行模式匹配的正确方法是什么（在这里处理 Just vs. Nothing 的情况）并梳理实例化 Monad 的所有不同语法。这个例子没有帮助 (https://wiki.haskell.org/All_About_Monads#Maybe_a_monad)：在引入 bind >>= 之后，sheep 例子甚至没有使用它，而是使用了一个组合器。

Answer 1

当您第一次开始学习 monad 时，最容易学习的称为 Identity monad。看起来这就是你真正想要实现的，但是你把Maybe这个词卡在某个地方，它把所有东西都扔掉了。 （也就是说，或者您实际上正在尝试实现 Maybe monad，但您尚未在任何地方定义 Just 或 Nothing。）

如果MyMonad 类似于Identity monad，那么正确的定义应该是：

f :: Int -> MyMonad Int
f = \x -> MyIdentity x

g :: Int -> MyMonad Int
g = \x -> MyIdentity x

data MyMonad a = MyIdentity a

instance Monad MyMonad where
    return x = MyIdentity x     -- return = \x -> MyIdentity x
    (MyIdentity x) >>= f = f x  -- (>>=) = \(MyIdentity x) f -> f x

如果MyMonad 类似于Maybe monad，那么正确的定义应该是：

f :: Int -> MyMonad Int
f = \x -> MyJust x

g :: Int -> MyMonad Int
g = \x -> MyJust x

data MyMonad a = MyNothing | MyJust a

instance Monad MyMonad where
    return x = MyJust x
    (MyJust x) >>= f = f x
    MyNothing  >>= f = MyNothing

（注意，要编译这些，您还需要为Functor 和Applicative 定义一个实例。）

附：要使用 lambda 表示法为 Maybe monad 定义 >>=，您需要一个 case 表达式：

(>>=) = \m f -> case m of
    MyJust x  -> f x
    MyNothing -> MyNothing

Answer 2

我认为您正在寻找 fish (>=>) 运算符（我在某些地方看到它被称为 fish，但名称并不严重）。如果我没记错的话，你想组合两个函数，每个函数都取一个二进制值来返回一个单值。所以让我们找到我们的合成函数的类型

(a -> m b) -> (b -> m c) -> (a -> mc)

恰好是>=> in Control.Monad。

所以

f :: Int -> Maybe Int
f = \x -> (Just x)

g :: Int -> Maybe Int
g = \x -> (Just x)

f >=> g $ 10
Just 10

或

f :: Int -> [Int]
f = \x -> replicate x x

g :: Int -> [Maybe Int]
g = \x -> [Just x]
f >=> g $ 10
[Just 10,Just 10,Just 10,Just 10,Just 10,Just 10,Just 10,Just 10,Just 10,Just 10]

您还有另一条鱼<=< 向左游，这是>=> 的翻转版本。