在投票最多的答案下，网友Wei Hu问道:

我理解ml -函子和haskell -函子，但缺乏 将它们联系在一起的洞察力。这两者之间是什么关系 二，在分类理论的意义上?

注:本人不懂ML，如有错误请见谅。

让我们首先假设我们都熟悉“范畴”和“函子”的定义。

一个紧凑的答案是，“haskell -函子”是(endo-)函子F: Hask -> Hask，而“ML-函子”是函子G: ML- > ML'。

这里，Hask是由Haskell类型和它们之间的函数组成的类别，类似地，ML和ML'是由ML结构定义的类别。

注意:将Hask作为一个类别存在一些技术问题，但有一些方法可以绕过它们。

从范畴论的角度来看，这意味着hask -函子是Haskell类型的映射F:

data F a = ...

伴随着Haskell函数的map fmap:

instance Functor F where
    fmap f = ...

ML是差不多的，尽管我不知道有一个规范的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

是一个函子F: StructA -> StructB。

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

有三种不同的意思，没有太大的联系!

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中的函子关系不大!

在命令式语言中，它是指向函数的指针。

在Inria网站上的O'Reilly OCaml书中有一个很好的例子(不幸的是，在写这篇文章时，它被删除了)。我在加州理工学院使用的这本书中找到了一个非常相似的例子:OCaml介绍(pdf链接)。相关的部分是关于函子的章节(书中139页，PDF中149页)。

在书中，他们有一个名为MakeSet的函子，它创建了一个由列表组成的数据结构，以及添加元素、确定元素是否在列表中以及查找元素的函数。用于确定它是否在集合中的比较函数已被参数化(这是使MakeSet成为函子而不是模块的原因)。

它们还有一个实现比较函数的模块，这样就可以进行不区分大小写的字符串比较。

使用函子函数和实现比较的模块，它们可以在一行中创建一个新模块:

module SSet = MakeSet(StringCaseEqual);;

这将为使用不区分大小写比较的一组数据结构创建一个模块。如果您想创建一个使用区分大小写比较的集合，那么您只需要实现一个新的比较模块，而不是一个新的数据结构模块。

Tobu将函子与c++中的模板进行了比较，我认为这是非常恰当的。

不是为了与前面的理论或数学答案相矛盾，但Functor也是一个对象(在面向对象编程语言中)，它只有一个方法，并且可以有效地用作函数。

Java中的Runnable接口就是一个例子，它只有一个方法:run。

考虑这个例子，首先在Javascript中，它有一级函数:

[1, 2, 5, 10].map(function(x) { return x*x; });

输出: [1,4,25,100]

map方法接受一个函数并返回一个新数组，其中每个元素都是将该函数应用于原始数组中相同位置的值的结果。

要在Java中使用Functor做同样的事情，你首先需要定义一个接口，比如:

public interface IntMapFunction {
  public int f(int x);
}

然后，如果你添加一个集合类，它有一个映射函数，你可以这样做:

myCollection.map(new IntMapFunction() { public int f(int x) { return x * x; } });

这使用了IntMapFunction的一个内嵌子类来创建一个Functor，它是前面JavaScript示例中的函数的OO等效。

使用函子可以在OO语言中应用函数式技术。当然，一些OO语言也直接支持函数，所以这不是必需的。

参考:http://en.wikipedia.org/wiki/Function_object

你回答了不少不错的问题。我将加入:

函子，在数学意义上，是代数上一种特殊的函数。它是将一个代数映射到另一个代数的最小函数。“极简性”用函子定律来表示。

有两种方式来看待这个问题。例如，列表是某些类型的函子。也就是说，给定类型为“a”的代数，您可以生成包含类型为“a”的列表的兼容代数。(例如:将一个元素带到包含它的单元素列表的映射:f(a) = [a])同样，兼容性的概念是由函子定律表示的。

另一方面,鉴于函子f / a型,(也就是说,f是应用函子的结果f的代数a型),从g和功能:- > b,我们可以计算一个新的函子f = (fmap g)映射f a到f b。简而言之,fmap是f的一部分映射“函子零件”“函子零件”,和g函数的一部分,“代数”映射到“代数部分”。它接受一个函数，一个函子，一旦完成，它也是一个函子。

看起来不同的语言使用不同的函子概念，但事实并非如此。它们只是在不同的代数上使用函子。OCamls有一个模块代数，这个代数上的函子允许您以一种“兼容”的方式将新声明附加到模块。

Haskell函子不是类型类。它是一个具有满足类型类的自由变量的数据类型。如果您愿意深入挖掘数据类型的精髓(没有自由变量)，您可以通过底层代数将数据类型重新解释为函子。例如:

数据F = F Int

是整型类的同构。F，作为一个值构造函数，是一个将Int映射到F Int的函数，一个等价的代数。它是一个函子。另一方面，这里的fmap不是免费的。这就是模式匹配的作用。

函子很适合以一种代数相容的方式将事物“附加”到代数元素上。