函子是对象和态射的映射，它保留了一个类别的组成和身份。

让我们定义什么是类别?

是一堆东西! 在a内部画几个点(现在是两个点，一个是“a”，另一个是“b”) 圆圈，并命名为圆圈A(类别)。

这个类别包含什么?

对象之间的组合和每个对象的恒等函数。

因此，在应用Functor之后，我们必须映射对象并保存组合。

让我们想象‘A’是我们的范畴，它有对象[' A'， 'b']，并且存在一个态射A -> b

现在，我们必须定义一个函子，它可以将这些对象和态射映射到另一个类别“B”。

假设这个函子叫做Maybe

data Maybe a = Nothing | Just a

B类是这样的。

请再画一个圆，但这次用“也许a”和“也许b”代替“a”和“b”。

一切看起来都很好，所有的对象都被映射了

“a”变成了“也许a”，“b”变成了“也许b”。

但问题是我们也要把态射从a映射到b。

这意味着' a'中的态态a -> b应该映射到'可能a' -> '可能b'

来自a -> b的形态称为f，然后来自'Maybe a' -> 'Maybe b'的形态称为'fmap f'

现在让我们看看函数f在A中做了什么，看看我们能否在B中复制它

A中f的函数定义:

f :: a -> b

F取a并返回b

f在B中的函数定义:

f :: Maybe a -> Maybe b

f取也许a，返回也许b

让我们看看如何使用fmap将函数'f'从'A'映射到'B'中的函数'fmap f'

fmap的定义

fmap :: (a -> b) -> (Maybe a -> Maybe b)
fmap f Nothing = Nothing
fmap f (Just x) = Just(f x)

那么，我们在这里做什么?

我们将函数“f”应用于类型为“a”的“x”。“Nothing”的特殊模式匹配来自于Functor Maybe的定义。

因此，我们将对象[a, b]和形态[f]从类别' a '映射到类别' b '。

那是富克托！

简单地说，函子或函数对象是可以像函数一样调用的类对象。

在c++中:

这就是写函数的方法

void foo()
{
    cout << "Hello, world! I'm a function!";
}

这就是写函子的方法

class FunctorClass
{
    public:
    void operator ()
    {
        cout << "Hello, world! I'm a functor!";
    }
};

现在你可以这样做:

foo(); //result: Hello, World! I'm a function!

FunctorClass bar;
bar(); //result: Hello, World! I'm a functor!

这样做的好处是可以将state保存在类中——想象一下，如果您想询问一个函数被调用了多少次。没有办法以简洁、封装的方式做到这一点。对于函数对象，它就像任何其他类一样:你有一些实例变量，你在operator()中增加它，还有一些方法来检查这个变量，一切都很整齐。

在函数式编程中，错误处理是不同的。抛出和捕获异常是命令式代码。不是使用try/catch块，而是围绕可能抛出错误的代码创建一个安全框。这是函数式编程中的基本设计模式。包装器对象用于封装可能错误的值。包装器的主要目的是提供一种使用被包装对象的“不同”方式

 const wrap = (val) => new Wrapper(val);

包装可以保护对值的直接访问，以便对它们进行操作 安全而不可改变。因为我们不能直接得到它，所以提取它的唯一方法就是使用恒等函数。

identity :: (a) -> a

这是恒等函数的另一个用例:从封装的类型中功能地提取数据。

Wrapper类型使用映射来安全地访问和操作值。在本例中，我们将恒等函数映射到容器上，以从容器中提取值。使用这种方法，可以在调用函数之前检查是否为null，或者检查是否为空字符串、负数等等。

 fmap :: (A -> B) -> Wrapper[A] -> Wrapper[B]

Fmap，首先打开容器，然后将给定函数应用于它的值，最后将值关闭到相同类型的新容器中。这种类型的函数称为函子。

Fmap在每次调用时返回容器的新副本。 函子没有副作用 函子必须是可组合的

实际上，functor是指在c++中实现调用操作符的对象。在ocaml中，我认为函子指的是将一个模块作为输入并输出另一个模块的东西。

在OCaml中，它是一个参数化模块。

如果您了解c++，可以将OCaml函子视为模板。c++只有类模板，函数子在模块规模上工作。

函数子的一个例子是Map.Make;module StringMap =映射。使(字符串);;构建一个使用字符串键映射的映射模块。

你不能通过多态性实现StringMap这样的东西;你需要对这些键做一些假设。String模块包含对完全有序字符串类型的操作(比较等)，函子将链接到String模块包含的操作。你可以用面向对象编程做一些类似的事情，但是你会有方法间接开销。

函数子是一个具有映射方法的对象。

JavaScript中的数组实现了map，因此是函子。承诺、流和树通常在函数式语言中实现map，当它们这样做时，它们被认为是函子。函子的map方法获取它自己的内容，并使用传递给map的转换回调对它们进行转换，并返回一个新的函子，该函子包含作为第一个函子的结构，但带有转换后的值。

src: https://www.youtube.com/watch?v=DisD9ftUyCk&feature=youtu.be&t=76