为了能真正理解Haskell中的Functor、Applicative、Monad、Monoid，以及它们到底有什么用，个人觉得还是有必要 了解 一些范畴论里面的概念的

函数 Function

函数表示特定类型之间的 态射

自函数 EndoFunction

自函数就是把类型映射到自身类型

identity :: Number -> Number

identity函数就是一个自函数的例子，它接收什么就返回什么

函子 Functor

函子与函数不同，函数描述的是类型之间的映射，而函子描述的是 范畴(category) 之间的映射

范畴

范畴是一组类型及其关系 态射 的集合。包括特定类型及其态射，比如: Int、 String、 Int -> String ;高阶类型及其态射，比如 List[Int]、 List[String]、 List[Int] -> List[String]

函子如何映射两个范畴

图中，范畴C1和范畴c2之间有映射关系，C1中Int映射到C2List[Int]，C1中String映射到C2List[String],C1中的关系态射Int -> String 也映射到 C2中的关系List[Int] -> List[String]态射上。

也就是说，一个范畴内部的所有元素可以映射为另一个范畴的元素，且元素间的关系也可以映射为另一范畴中的元素间的关系，则设为这两个范畴之间存在映射。所谓函子就是表示两个范畴之间的映射。

Haskell中，Functor是可以被map over的东西，List就是一个典型的instance。构造List[Int] 就是把Int提升到List[Int]，记作：Int -> List[Int] . 这表达了一个范畴的元素可以被映射为另一个范畴的元素

我们看下Haskell中map函数的定义：

map :: (a -> b) -> [a] -> [b]

把我们上面的Int String的例子代入,配合柯里化的概念可以得出：

map :: (Int -> String) -> (List[Int] -> List[String])

map的定义清晰的告诉我们： Int -> String 这个关系可以被映射为 List[Int] -> List[String] 这种关系。这就表达了元素间的关系可以映射为另外一个范畴元素间的关系

所以List就是一个Functor

自函子

自函数是把类型映射到自身类型，那么自函子就是把范畴映射到自身范畴。

上图就是一个将范畴映射到自身的自函子。从函子的定义出发，我们考察这个自函子，始终有List[Int] -> List[String] 和 List[Int] -> List[String] -> List[Int] -> List[String] 这两种映射。我们表述为：

类型List[Int] 映射到自己
态射f :: List[Int] -> List[String] 映射到自己

我们记作：

F(List[Int]) = List[Int]
F(f) = f
其中F是Functor

幺半群

先解释下群的概念：G为非空集合，如果在G上定义的二元运算*，满足：

(1) 封闭性：（Closure）：对于任意a，b∈G，有a*b∈G
(2) 结合律（Associativity）：对于任意a，b，c∈G，有（a*b）*c=a*（b*c）
(3) 幺元 （Identity）：存在幺元e，使得对于任意a∈G，e*a=a*e=a
(4) 逆元：对于任意a∈G，存在逆元a^-1，使得a^-1*a=a*a^-1=e

则称(G, *) 为群，简称G为群。

如果仅满足封闭性和结合律，则该G是一个 半群(Semigroup) ; 如果满足封闭性和结合律并且存在幺元，则该G是一个 幺半群(Monoid)。

接下来看下在自函子的范畴上，怎样结合幺半群的定义得出Monad

假设我们有个cube函数，它计算一个数的三次方：

cube :: Number -> Number

现在我们想在其返回值上添加一些调试信息，返回一个元组，第二个元素代表调试信息，函数签名为：

f :: Number -> (Number, String)

可以看到参数与返回值不一致。我们再看下幺半群规定的结合律。对于函数而言，结合律就是将函数以各种结合方式嵌套起来调用。我们将Haskell中的 . 函数看做这里的二元运算。

(.) :: (b -> c) -> (a -> b) -> a -> c

f . f

从函数签名可以看出右边f返回的是元组(Number, String)，而左侧的f接收的是Number。所以无法组合，他们彼此不兼容。

有什么办法能消除这种不兼容？结合前面所述，cube是一个自函数，元组(Number,String)在Hask范畴是一个自函子 （这个说法看起来并不准确，(?, String)才应该是一个自函子 ） , 理由如下：

F Number = (Number, String)
F Number -> Number = (Number,String) -> (Number,String)

如果输入和输出都是元组,结果会怎样呢？

fn :: (Number,String) -> (Number,String)
fn . fn

这样是可行的，在验证满足结合律之前，我们引入一个liftM函数来辅助将f提升成fn

liftM :: (Double -> (Double, String)) -> (Double,String) -> (Double, String)
liftM f (x,y) = case r of (n,s) -> (n, y ++ s)
    where r = f x 

没有验证，就当伪代码看吧

我们来实现元组自函子范畴上的结合律：

cube :: Number -> (Number, String)
cube x = (x * x * x, "cube was called.")

sine :: Number -> (Number, String)
sine x = (Math.sin x, "sine was called.")

f = ((liftM sine) . (liftM cube)) . (liftM cube)
f (3, "")
输出：(0.956, 'cube was called.cube was called.sine was called.')

f1 = (liftM sine) . ((liftM cube) . (liftM cube))
输出：(0.956, 'cube was called.cube was called.sine was called.')

这里f和f1代表的结合顺序产生了相同的结果，说明元组自函子范畴满足结合律。

那如何找到这样一个e，使得 a * e = e * a = a ,此处的 * 就是 .

unit :: Number -> (Number, String)
unit x = (x, "")

f = (liftM sine) . (liftM cube)

f . (liftM unit) = (liftM unit) . f = f

这里的 liftM unit 就是 e 了。

unit 个人理解应该就是类型构造器