一些玩弄ghci中的仿函数和monad的人让我得到了一个我希望更好理解其类型和行为的价值。
\x -> join . x的类型为(Monad m) => (a -> m (m b)) -> (a -> m b)，\y -> y . (flip fmap)的类型为(Functor f) => ((a -> b) -> f b) -> (f a -> c)。
ghci版本8.2.2允许定义h = join . (flip fmap)。
为什么
h的类型为((A -> B) -> A) -> (A -> B) -> B？
特别是，为什么仿函数和monad约束消失了？这真的是正确和预期的行为吗？作为后续行动，我还想问：
为什么评估
h (\f -> f u) (\x -> x + v)整数u和v会在每种情况下给出u + 2v？
答案 0 :(得分：8)
简而言之：由于类型扣除，Haskell知道m和f实际上是部分实例化的箭头。
让我们做数学。函数join . (flip fmap)基本上是你给定的lambda表达式\x -> join . x，其参数为(flip fmap)，所以：
h = (\x -> join . x) (flip fmap)
现在lambda表达式的类型为：
(\x -> join . x) :: Monad m => (a -> m (m b)) -> (a -> m b)
现在，参数flip fmap的类型为：
flip fmap :: Functor f => f c -> ((c -> d) -> f d)
（我们这里使用c和d代替a和b，以避免两个可能不同类型之间的混淆。）
这意味着flip fmap的类型与lambda表达式的参数的类型相同，因此我们知道：
Monad m => a -> m (m b)
~ Functor f => f c -> ((c -> d) -> f d)
---------------------------------------
a ~ f c, m (m b) ~ ((c -> d) -> f d)
所以我们现在知道a与f c具有相同的类型（这是代字号~的含义）。
但我们必须做一些额外的计算：
Monad m => m (m b)
~ Functor f => ((c -> d) -> f d)
--------------------------------
m ~ (->) (c -> d), m b ~ f d
因此我们知道m与(->) (c -> d)相同（基本上这是我们知道输入类型的函数，这里是(c -> d)，输出类型是类型参数m。
这意味着m b ~ (c -> d) -> b ~ f d，这意味着f ~ (->) (c -> d)和b ~ d。另外一个结果是，自a ~ f c以来，我们知道a ~ (c -> d) -> c
所以列出我们得到的东西：
f ~ m
m ~ (->) (c -> d)
b ~ d
a ~ (c -> d) -> c
所以我们现在可以＆＃34;专攻＆＃34;我们的lambda表达式和flip fmap函数的类型：
(\x -> join . x)
:: (((c -> d) -> c) -> (c -> d) -> (c -> d) -> d) -> ((c -> d) -> c) -> (c -> d) -> d
flip fmap
:: ((c -> d) -> c) -> (c -> d) -> (c -> d) -> d
和flip fmap的类型现在与lambda表达式的参数类型完全匹配。因此(\x -> join . x) (flip fmap)的类型是lambda表达式类型的结果类型，即：
(\x -> join . x) (flip fmap)
:: ((c -> d) -> c) -> (c -> d) -> d
但是现在我们当然还没有获得这个功能的实现。然而，我们已经向前迈进了一步。
由于我们现在知道m ~ (->) (c -> d)，我们知道应该查找arrow instance of a monad：
instance Monad ((->) r) where f >>= k = \ r -> k (f r) r
因此，对于给定函数f :: r -> a，作为左操作数，函数k :: a -> (r -> b) ~ a -> r -> b作为操作数，我们构造一个新函数，将变量x映射到k f已应用于x和x。因此，它是一种对输入变量x执行某种预处理的方法，然后在考虑预处理和原始视图的情况下进行处理（这是 解释a人类读者可以使用）。
现在join :: Monad m => m (m a) -> m a是implemented as：
join :: Monad m => m (m a) -> m a join x = x >>= id
因此，对于(->) r monad，这意味着我们将其实现为：
-- specialized for `m ~ (->) a
join f = \r -> id (f r) r
由于id :: a -> a（标识函数）返回其参数，我们可以进一步将其简化为：
-- specialized for `m ~ (->) a
join f = \r -> (f r) r
或清洁：
-- specialized for `m ~ (->) a
join f x = f x x
因此它基本上被赋予一个函数f，然后将该参数两次应用于该函数。
此外，我们知道箭头类型的Functor实例为defined as：
instance Functor ((->) r) where fmap = (.)
所以它基本上被用作＆＃34;后处理器＆＃34;关于函数的结果：我们构造了一个新的函数，它将使用给定的函数进行后处理。
现在我们已经将该函数专用于给定的Functor / Monad，我们可以将实现派生为：
-- alternative implementation
h = (.) (\f x -> f x x) (flip (.))
或使用更多lambda表达式：
h = \a -> (\f x -> f x x) ((flip (.)) a)
我们现在可以进一步专注于：
h = \a -> (\f x -> f x x) ((\y z -> z . y) a)
-- apply a in the lambda expression
h = \a -> (\f x -> f x x) (\z -> z . a)
-- apply (\z -> z . a) in the first lambda expression
h = \a -> (\x -> (\z -> z . a) x x)
-- cleaning syntax
h a = (\x -> (\z -> z . a) x x)
-- cleaning syntax
h a x = (\z -> z . a) x x
-- apply lambda expression
h a x = (x . a) x
-- remove the (.) part
h a x = x (a x)
所以h基本上需要两个参数：a和x，然后执行函数应用程序，其中a为函数，x为参数，输出再次传递给x函数。
您使用的样本用法：
h (\f -> f u) (\x -> x + v)
或更好：
h (\f -> f u) (+v)
所以我们可以这样分析：
h (\f -> f u) (+v)
-> (+v) ((\f -> f u) (+v))
-> (+v) ((+v) u)
-> (+v) (u+v)
-> ((u+v)+v)
因此我们将u+v添加到v。
答案 1 :(得分：1)
>>> 可以更轻松地类型排队
a -> b >>>
b -> c ::
a -> c
在这里，我们有
join . flip fmap == flip fmap >>> join
flip fmap :: Functor f => f a -> ((a -> b) -> f b )
join :: Monad m => (m (m b)) -> m b
----------------------------------------------------------
flip fmap >>> join ::
(Functor f, Monad m) => f a -> m b , ((a -> b) ->) ~ m, f ~ m
::
(Functor f, Monad f) => f a -> f b , f ~ ((a -> b) ->)
:: ((a -> b) -> a) -> ((a -> b) -> b)
简单，机械，世俗。
要看它做什么，组合风格定义通常最容易解决，
(join . flip fmap) f g x =
join (flip fmap f) g x = -- join f x = f x x
(`fmap` f) g g x = -- f `fmap` g = f . g
(g . f) g x
g (f g) x
所以我们毕竟不需要x（或者我们呢？）。函数的join和fmap定义在边距中给出。我们已到达
(join . flip fmap) f g = g (f g) -- f :: (a -> b) -> a, g :: a -> b
-- f g :: a , g (f g) :: b
另一种方式是从类型开始，按照modus ponens的规则，
((a -> b) -> a) (a -> b) -- f g
---------------------------
(a -> b) a -- g (f g)
---------------------------------------
b