我在阅读一些关于函数式编程的文章时，几次遇到了“Functor”这个术语，但作者通常假设读者已经理解了该术语。在网上搜索提供的是过度技术化的描述（参见维基百科文章）或者是极其模糊的描述（请参见此ocaml-tutorial网站下的Functors部分）。
可以有人友好地定义这个术语、解释它的用途，并可能提供一个如何创建和使用Functors的示例吗？
编辑：虽然我对该术语背后的理论感兴趣，但我对实现和概念的实际应用更感兴趣。
编辑2：看起来存在一些交叉用语：我特别指的是函数式编程中的Functors，而不是C++的函数对象。
“Functor”这个词来源于范畴论，是数学中非常普遍而抽象的一个分支。至少有两种不同的方式，被功能语言的设计者所借用。
In the ML family of languages, a functor is a module that takes one or more other modules as a parameter. It's considered an advanced feature, and most beginning programmers have difficulty with it.
As an example of implementation and practical use, you could define your favorite form of balanced binary search tree once and for all as a functor, and it would take as a parameter a module that provides:
The type of key to be used in the binary tree
A total-ordering function on keys
Once you've done this, you can use the same balanced binary tree implementation forever. (The type of value stored in the tree is usually left polymorphic—the tree doesn't need to look at values other than to copy them around, whereas the tree definitely needs to be able to compare keys, and it gets the comparison function from the functor's parameter.)
Another application of ML functors is layered network protocols. The link is to a really terrific paper by the CMU Fox group; it shows how to use functors to build more complex protocol layers (like TCP) on type of simpler layers (like IP or even directly over Ethernet). Each layer is implemented as a functor that takes as a parameter the layer below it. The structure of the software actually reflects the way people think about the problem, as opposed to the layers existing only in the mind of the programmer. In 1994 when this work was published, it was a big deal.
For a wild example of ML functors in action, you could see the paper ML Module Mania, which contains a publishable (i.e., scary) example of functors at work. For a brilliant, clear, pellucid explanation of the ML modules system (with comparisons to other kinds of modules), read the first few pages of Xavier Leroy's brilliant 1994 POPL paper Manifest Types, Modules, and Separate Compilation.
In Haskell, and in some related pure functional language, Functor is a type class. A type belongs to a type class (or more technically, the type "is an instance of" the type class) when the type provides certain operations with certain expected behavior. A type T can belong to class Functor if it has certain collection-like behavior:
The type T is parameterized over another type, which you should think of as the element type of the collection. The type of the full collection is then something like T Int, T String, T Bool, if you are containing integers, strings, or Booleans respectively. If the element type is unknown, it is written as a type parameter a, as in T a.
Examples include lists (zero or more elements of type a), the Maybe type (zero or one elements of type a), sets of elements of type a, arrays of elements of type a, all kinds of search trees containing values of type a, and lots of others you can think of.
The other property that T has to satisfy is that if you have a function of type a -> b (a function on elements), then you have to be able to take that function and product a related function on collections. You do this with the operator fmap, which is shared by every type in the Functor type class. The operator is actually overloaded, so if you have a function even with type Int -> Bool, then
fmap even
is an overloaded function that can do many wonderful things:
Convert a list of integers to a list of Booleans
Convert a tree of integers to a tree of Booleans
Convert Nothing to Nothing and Just 7 to Just False
In Haskell, this property is expressed by giving the type of fmap:
fmap :: (Functor t) => (a -> b) -> t a -> t b
where we now have a small t, which means "any type in the Functor class."
To make a long story short, in Haskell a functor is a kind of collection for which if you are given a function on elements, fmap will give you back a function on collections. As you can imagine, this is an idea that can be widely reused, which is why it is blessed as part of Haskell's standard library.
像往常一样，人们不断发明新的有用的抽象概念，你可能需要了解一下可应用函子，最好的参考资料可能是Conor McBride和Ross Paterson撰写的论文《带效果的可应用编程》（Applicative Programming with Effects）。
这里的其他答案已经很全面，但我会尝试用另一种方式来解释FP中functor的用法。可以将其类比为：
一个functor是类型为a的容器，当被应用于从a到b的映射函数时，会产生类型为b的容器。
与C++中抽象函数指针的用法不同，在这里functor并不是函数，而是在被应用于函数时表现一致的某种东西。
有三个不太相关的意思！
In Ocaml it is a parametrized module. See manual. I think the best way to grok them is by example: (written quickly, might be buggy)
module type Order = sig
type t
val compare: t -> t -> bool
end;;
module Integers = struct
type t = int
let compare x y = x > y
end;;
module ReverseOrder = functor (X: Order) -> struct
type t = X.t
let compare x y = X.compare y x
end;;
(* We can order reversely *)
module K = ReverseOrder (Integers);;
Integers.compare 3 4;; (* this is false *)
K.compare 3 4;; (* this is true *)
module LexicographicOrder = functor (X: Order) ->
functor (Y: Order) -> struct
type t = X.t * Y.t
let compare (a,b) (c,d) = if X.compare a c then true
else if X.compare c a then false
else Y.compare b d
end;;
(* compare lexicographically *)
module X = LexicographicOrder (Integers) (Integers);;
X.compare (2,3) (4,5);;
module LinearSearch = functor (X: Order) -> struct
type t = X.t array
let find x k = 0 (* some boring code *)
end;;
module BinarySearch = functor (X: Order) -> struct
type t = X.t array
let find x k = 0 (* some boring code *)
end;;
(* linear search over arrays of integers *)
module LS = LinearSearch (Integers);;
LS.find [|1;2;3] 2;;
(* binary search over arrays of pairs of integers,
sorted lexicographically *)
module BS = BinarySearch (LexicographicOrder (Integers) (Integers));;
BS.find [|(2,3);(4,5)|] (2,3);;
现在，您可以快速添加许多可能的订单，以形成新订单的方式，并轻松地对它们进行二进制或线性搜索。泛型编程厉害。
In functional programming languages like Haskell, it means some type constructors (parametrized types like lists, sets) that can be "mapped". To be precise, a functor f is equipped with (a -> b) -> (f a -> f b). This has origins in category theory. The Wikipedia article you linked to is this usage.
class Functor f where
fmap :: (a -> b) -> (f a -> f b)
instance Functor [] where -- lists are a functor
fmap = map
instance Functor Maybe where -- Maybe is option in Haskell
fmap f (Just x) = Just (f x)
fmap f Nothing = Nothing
fmap (+1) [2,3,4] -- this is [3,4,5]
fmap (+1) (Just 5) -- this is Just 6
fmap (+1) Nothing -- this is Nothing
所以，这是一种特殊类型的类型构造函数，与Ocaml中的functor无关！
在OCaml中，它是一个参数化模块。
如果您了解C ++，可以将OCaml函数对象视为模板。C ++仅具有类模板，而函数对象可在模块范围内工作。
函数对象的一个示例是 Map.Make；module StringMap = Map.Make (String);; 构建了一个与字符串键映射一起使用的地图模块。
您无法仅通过多态来实现类似于 StringMap 的功能；您需要对键做出一些假设。String 模块包含关于全序字符串类型的操作（比较等），函数对象将连接到 String 模块包含的操作上。您可以使用面向对象编程进行类似的操作，但这会产生方法间接开销。
它同构于Ints类。F作为值构造函数，将Int映射到F Int，一个等价的代数结构。它是一个函子。另一方面，在这里你不能免费使用fmap。这就是模式匹配的作用。
函子对于“以代数上的兼容方式”将事物与代数元素相连非常有用。
对于这个问题的最佳答案可以在Brent Yorgey的“Typeclassopedia”中找到。
Monad Reader杂志的这个问题包含了什么是函子的精确定义以及其他概念的许多定义和图表。(Monoid、Applicative、Monad和其他概念都被解释并与函子相关联)。
http://haskell.org/sitewiki/images/8/85/TMR-Issue13.pdf
从Functor的Typeclassopedia摘录： “一个简单的直觉是，Functor表示某种‘容器’，以及能够统一地将函数应用于容器中的每个元素的能力。”O'Reilly的OCaml书籍上有一个非常不错的例子，该书籍可在Inria网站上找到（很遗憾，在撰写本文时该网站无法访问）。我在Caltech使用的这本书中发现了一个非常相似的例子：Introduction to OCaml (pdf link)。相关章节是函数对象（functors）（本书第139页，PDF文档第149页）。
在此书中，他们创建了一个名为MakeSet的函数对象，用于创建一个数据结构，包含列表和添加元素、确定元素是否在列表中以及查找元素的函数。用于判断集合中元素是否存在的比较函数已被参数化（这使得MakeSet成为一个函数对象而不是模块）。
他们还编写了一个模块来实现比较函数，以便进行不区分大小写的字符串比较。
使用该函数对象和实现比较的模块，他们可以在一行代码中创建一个新模块：
module SSet = MakeSet(StringCaseEqual);;
创建一个使用不区分大小写比较的数据结构模块的集合。如果你想创建一个使用区分大小写比较的集合，那么你只需要实现一个新的比较模块而不是一个新的数据结构模块。
Tobu将functors与C ++中的模板进行比较，我认为这很恰当。
考虑到其他答案和我现在要发布的内容，我认为这是一个相当重载的词，但无论如何...
关于Haskell中'functor'一词的含义的提示，请询问GHCi：
Prelude> :info Functor
class Functor f where
fmap :: forall a b. (a -> b) -> f a -> f b
(GHC.Base.<$) :: forall a b. a -> f b -> f a
-- Defined in GHC.Base
instance Functor Maybe -- Defined in Data.Maybe
instance Functor [] -- Defined in GHC.Base
instance Functor IO -- Defined in GHC.Base
fmap 与 map 相一致，对于Maybe，fmap f (Just x) = Just (f x)，fmap f Nothing = Nothing等。
Functor类型类子节和Functors、Applicative Functors和Monoids部分在Learn You a Haskell for Great Good中提供了一些有用的示例。 （总结：很多地方都可以使用！:-)）“Functor是一个将对象和态射进行映射的函数，它保留了范畴的组合性和恒等性。”
那么我们先来定义一下什么是范畴？
它是一堆对象！
在一个圆圈里画几个点（现在只有两个点，一个是‘a’，另一个是‘b’），然后给这个圆圈起个名字叫做A（Category）。
那么范畴都包含哪些内容呢？
对象之间的组合以及每个对象的恒等函数。
因此，在应用Functor之后，我们需要映射这些对象并保留其组合性。
让我们想象一下，‘A’是我们的范畴，其中有对象['a', 'b']，并且存在一个态射a -> b。
现在，我们需要定义一个能够将这些对象和态射映射到另一个范畴'B'的Functor。
假设这个Functor叫做'Maybe'。
data Maybe a = Nothing | Just a
所以，类别'B'看起来像这样。
请再画一个圆圈，这次用'Maybe a'和'Maybe b'代替'a'和'b'。
一切似乎都很好，所有对象都被映射了。
'a'变成了'Maybe a'，'b'变成了'Maybe b'。
但问题是我们还必须映射从'a'到'b'的态射。
这意味着'A'中的态射a -> b应该映射到'Maybe a' -> 'Maybe b'的态射。
a -> b的态射称为f，则'Maybe a' -> 'Maybe b'的态射称为'fmap f'。
现在让我们看看函数'f'在'A'中是如何工作的，并看看我们是否可以在'B'中复制它。
'A'中'f'的函数定义：
f :: a -> b
f接受a并返回b
在'B'中，'f'的函数定义为：
f :: Maybe a -> Maybe b
f接受一个Maybe a类型的参数，并返回一个Maybe 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'。
这就是 Functor！
我理解ML函子和Haskell函子，但缺乏将它们联系在一起的洞察力。从范畴论的角度来看，这两者之间有什么关系?
注意：我不懂ML，请原谅并纠正任何相关错误。
我们先假设我们都熟悉“范畴”和“函子”的定义。
一个简明的答案是，“Haskell函子”是（自）函子F: Hask -> Hask，而“ML函子”是函子G：ML -> ML'。
这里，“Hask”是由Haskell类型和它们之间的函数组成的范畴，类似地，“ML”和“ML'”是由ML结构定义的范畴。
注意：有一些技术问题需要解决才能使Hask成为一个范畴，但有办法解决这些问题。
从范畴论的角度来看，这意味着Hask-函子是Haskell类型的映射F：
data F a = ...
除此之外，还有一张 Haskell 函数的映射表 fmap：
instance Functor F where
fmap f = ...
机器学习基本上是相同的，不过我不知道是否有官方的fmap抽象概念，因此让我们定义一个：
signature FUNCTOR = sig
type 'a f
val fmap: 'a -> 'b -> 'a f -> 'b f
end
f将ML类型映射，而fmap将ML函数映射，因此functor StructB (StructA : SigA) :> FUNCTOR =
struct
fmap g = ...
...
end
is a functor F: StructA -> StructB.
fmap映射了函数。涉及到两种不同的映射方式，这种思考方式将有助于理解范畴论（更为一般化）。我的意思是，了解基本的范畴论有助于我们理解Haskell中的所有范畴论知识（如函数子、单子等），这很有趣。 - Ludovic Kuty