不是为了与前面的理论或数学答案相矛盾，但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

这里的其他答案是完整的，但我将尝试另一种解释FP使用函子。我们来做个类比:

函子是类型为A的容器，当它受到从A→b映射的函数的作用时，将产生类型为b的容器。

与c++中使用的抽象函数指针不同，这里函子不是函数;相反，它是一种在受到某个函数影响时表现一致的东西。

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

在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()中增加它，还有一些方法来检查这个变量，一切都很整齐。

这个问题的最佳答案在布伦特·约吉(Brent Yorgey)的《type eclassopedia》中找到。

这一期的单子阅读器包含了一个精确的定义，什么是一个函子以及许多其他概念的定义以及一个图表。(Monoid, Applicative, Monad和其他概念被解释和看到与函子的关系)。

http://haskell.org/sitewiki/images/8/85/TMR-Issue13.pdf

摘自Functor的Typeclassopedia: 一个简单的直觉是，一个Functor代表一个容器 类中的每个元素统一应用函数的能力 容器”

但实际上，所有类型的类目都是强烈推荐的，因为它们出奇地简单。在某种程度上，你可以看到这里的类型类与object中的设计模式是平行的，因为它们为给定的行为或能力提供了词汇表。

干杯

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

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

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

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

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

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

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