haskell - 有什么直觉可以理解在 Monad 中加入两个函数吗？

Question

join与 bind 一起定义将组合的数据结构展平为单个结构。

从类型系统的角度来看，(+) 7 :: Num a => a -> a可以认为是 Functor , (+) :: Num a => a -> a -> a可以认为是 Functor的 Functor ，如何获得一些关于它的直觉，而不是仅仅依赖类型系统？为什么join (+) 7 === 14 ?

虽然可以通过函数绑定(bind)过程手动步进得到最终结果，但如果能给出一些直觉就好了。

这是来自 NICTA练习。

-- | Binds a function on the reader ((->) t).
--
-- >>> ((*) =<< (+10)) 7
-- 119
instance Bind ((->) t) where
  (=<<) ::
    (a -> ((->) t b))
    -> ((->) t a)
    -> ((->) t b)
  (f =<< a) t =
    f (a t) t

-- | Flattens a combined structure to a single structure.
--
-- >>> join (+) 7
-- 14
join ::
  Bind f =>
  f (f a)
  -> f a
join f =
  id =<< f

*Course.State> :t join (+)
join (+) :: Num a => a -> a
*Course.State> :t join
join :: Bind f => f (f a) -> f a
*Course.State> :t (+)
(+) :: Num a => a -> a -> a

Answer 1

how to get some intuition about it instead of just relying on type system?

我宁愿说依赖类型系统是建立特定直觉的好方法。 join的类型是:

join :: Monad m => m (m a) -> m a

专攻 (->) r ， 它成为了:

(r -> (r -> a)) -> (r -> a)

现在让我们尝试定义 join对于功能:

-- join :: (r -> (r -> a)) -> (r -> a)
join f = -- etc.

我们知道结果必须是 r -> a功能:

join f = \x -> -- etc.

但是，我们对 r 的内容一无所知。和 a类型是，因此我们对 f :: r -> (r -> a) 一无所知。和 x :: r .我们的无知意味着我们实际上只能对它们做一件事:通过 x作为一个论点，两者都是 f和 f x :

join f = \x -> f x x

因此， join for 函数两次传递相同的参数，因为这是唯一可能的实现。当然，那个实现只是一个适当的单子(monad) join因为它遵循单子(monad)定律:

join . fmap join = join . join
join . fmap return = id
join . return = id

验证这可能是另一个不错的练习。