Haskell 通过值替换得到错误的结果

我有以下功能：

meh :: (Functor m, Monad m) => [a] -> (a -> m b) -> m [b]
meh [] _ = return []
meh (x:xs) f = do
  x' <- f x
  fmap ((:) x') (meh xs f)

但我确实希望

[只有3个，只有4个，只有5个]

为了找出问题所在，我做了以下工作：

meh [3,4,5] (\x -> Just x) = Just [3,4,5]

meh (3:[4,5])] (\x -> Just x) =
  Just 3 <- (\3 -> Just 3)
  fmap ((:) (Just 3)) (meh [4,5] (\x -> Just x))

meh (4:[5])] (\x -> Just x) =
  Just 4 <- (\4 -> Just 4)
  fmap ((:) (Just 4)) (meh [5] (\x -> Just x))

meh ([5])] (\x -> Just x) =
  Just 5 <- (\5 -> Just 5]
  fmap ((:) (Just 5)) (meh [] (\x -> Just x))

meh [] _ = return []  


--all the way back
meh ([5])] (\x -> Just x) = fmap ((:) (Just 5)) []
meh (4:[5])] (\x -> Just x) = fmap ((:) (Just 4)) [Just 5] <- result [Just 4, Just 5]
meh (3:[4,5])] (\x -> Just x) = fmap ((:) (Just 3)) [Just 4, Just 5] <- result [Just 4, Just 5]
meh [3,4,5] (\x -> Just x) = [Just 3,Just 4, Just 5]

---

我的问题是，我的替换错在哪里了？我得到了错误的结果

根据类型，一切正常

meh :: (Functor m, Monad m) => [a] -> (a -> m b) -> m [b]

如果您期望的是

[只有3个，只有4个，只有5个]

您可能需要以下内容：

meh :: (Functor m, Monad m) => [a] -> (a -> m b) -> [m b]

或者只是

meh :: (Functor m) => [a] -> (a -> m b) -> [m b]

因为如果您不打算连接值，就不需要monad实例

meh' :: (Functor m, Monad m) => [a] -> (a -> m b) -> [m b]
meh' [] _ = []
meh' (x:xs) f =
  (f x) : (meh' xs f)

调用

meh'[3,4,5]Just

返回

[Just 3,Just 4,Just 5]

调用

meh[3,4,5]Just

返回

Just[3,4,5]

谈论替换（从空列表开始）：

meh[].=Just[]

，因为

meh[].=return[]

返回一个包装成一元结构的空列表（在本例中，

可能是

monad）

meh（5:[]）（\x->Just x）=do
x'正好x）5
fmap（（：）x'）（meh[]（\x->仅x））

---

在这一步中，

x'只需x）5

将

x'

绑定到

5

。这就是为什么

meh[5]Just

转换成

fmap（（：）5）（Just[]）

等于

Just[5]

，而不是

fmap（（：）（Just 5））[]

，它实际上等于

[Just 5]
，正如我在您的类型签名之前所评论的那样：
如果检查
[Just 1，Just 2，…]
的类型，则类似于
[mb]
而不是
m[]

此外，您不能将功能简化为：

meh :: (Functor m, Monad m) => [a] -> (a -> m b) -> [m b]
meh l f = fmap f l

给你一个

此步骤中您的替换错误：

x'
meh:：（Functor m，Monad m）=>[a]->（a->mb）->m[b]
您的函数返回a
m[b]
而不是a
[mb]
（Functor m，Monad m）
是冗余的；您只需要放置
Monad m
，因为
Functor
是
Monad
的要求。
meh' :: (Functor m, Monad m) => [a] -> (a -> m b) -> [m b]
meh' [] _ = []
meh' (x:xs) f =
  (f x) : (meh' xs f)

meh (5:[]) (\x -> Just x) = do
  x' <- (\x -> Just x) 5
  fmap ((:) x') (meh [] (\x -> Just x))

meh :: (Functor m, Monad m) => [a] -> (a -> m b) -> [m b]
meh l f = fmap f l