functor 是什么？
在阅读Tensorflowy源码时看到了这个，后来明白这是个命名空间，但查了一下原来functor并不简单，以后很可能会用到，特此转载记下。
下面是转载的作者原文：
引子
有一次在美团面试的时候，第二轮面试官问道：“听说过functor吗？”，妈呀，6年了，竟然没听说过这个概念，今天就学习了一会，哎，天不遂人愿，老天弄人啊，其实这个东西我们大家都不止一次的在使用它。举个例子（注意for_each的第三个参数）：
[cpp] view plain copy
// for_each example  
#include <iostream>     // std::cout  
#include <algorithm>    // std::for_each  
#include <vector>       // std::vector  
  
void myfunction (int i) {  // function:  
    std::cout << ' ' << i;  
}  
  
struct myclass {           // function object type:  
    void operator() (int i) {std::cout << ' ' << i;}  
} myobject;  
  
int main () {  
    std::vector<int> myvector;  
    myvector.push_back(10);  
    myvector.push_back(20);  
    myvector.push_back(30);  
      
    std::cout << "myvector contains:";  
    for_each (myvector.begin(), myvector.end(), myfunction);  
    std::cout << '\n';  
      
    // or:  
    std::cout << "myvector contains:";  
    for_each (myvector.begin(), myvector.end(), myobject);  
    std::cout << '\n';  
      
    return 0;  
}  
是的，这就是functor的思想。
补充一下functor的实现（各个人实现可能不一样哦，不同的库，不同的语言也可能不一样哦），仅供参考：
[cpp] view plain copy
template<class InputIterator, class Function>  
  Function for_each(InputIterator first, InputIterator last, Function fn)  
{  
  while (first!=last) {  
    fn (*first);  
    ++first;  
  }  
  return fn;      // or, since C++11: return move(fn);  
}  
什么是functor？
 functor的英文解释为something that performs a function，即其行为类似函数的东西。C++中的仿函数是通过在类中重载()运算符实现，使你可以像使用函数一样来创建类的对象。
为什么使用仿函数（functor）
迭代和计算逻辑分离
    使用仿函数可以使迭代和计算分离开来。因而你的functor可以应用于不同场合，在STL的算法中就大量使用了functor.
参数可设置
    可以很容易通过给仿函数（functor）设置参数，来实现原本函数指针才能实现的功能.
有状态
    与普通函数另一个区别是仿函数（functor）是有状态的.
性能
    我们看一下代码：
1
std::transform(in.begin(), in.end(), out.begin(), add_x(1));
    编译器可以准确知道std::transform需要调用哪个函数（add_x::operator）。这意味着它可以内联这个函数调用。而如果使用函数指针，编译器不能直接确定指针指向的函数，而这必须在程序运行时才能得到并调用。
    一个例子就是比较std::sort 和qsort ，STL的版本一般要快5-10倍。

functor就是一个重载了 operator()的类，用这个类生成的实例就像一个函数。（functor就是一个作为函数用的类），在c++11后可以用lambda函数实现同样的功能。

参考链接：stackoverflow

// this is a functor
struct add_x {
  add_x(int x) : x(x) {}
  int operator()(int y) const { return x + y; }

private:
  int x;
};

// 这也是一个functor
struct inc{
  int operator()(int _i) { return _i + 1;}
};

// Now you can use it like this:
add_x add42(42); // create an instance of the functor class
int i = add42(8); // and "call" it
assert(i == 50); // and it added 42 to its argument, 检查i是否等于50

std::vector<int> in; // assume this contains a bunch of values)
std::vector<int> out(in.size());
// Pass a functor to std::transform, which calls the functor on every element 
// in the input sequence, and stores the result to the output sequence
// add_x(1), 相当于创建了 add_x add1(1)
// add1 相当于一个函数，传入一个int参数， 这个int 会加上 1
std::transform(in.begin(), in.end(), out.begin(), add_x(1)); 
//相当于
inc i_1;
std::transform(in.begin(), in.end(), out.begin(), i_1); 
// 效果和下面这句相同
std::transform(in.begin(), in.end(), out.begin(), [](int x){ return x + 1;});
assert(out[i] == in[i] + 1); // for all i

Functor
class Functor (f :: * -> *) where
  fmap :: (a -> b) -> f a -> f b
  (<$) :: a -> f b -> f a
  (<$) =  fmap . const

(<$>) :: Functor f => (a -> b) -> f a -> f b
(<$>) = fmap

($>) :: Functor f => f a -> b -> f b
($>) = flip (<$)

void :: Functor f => f a -> f ()
void x = () <$ x
Functor（函子）是一个类型类，它是一种广义的能被映射的容器或计算环境。

将一个 a->b 的函数映射到一个 a 类型 的 Functor 之上会得到一个 b 类型的 Functor。
Functor的法则
fmap id ≡ id
fmap (f . g) ≡ fmap f . fmap g
[] 是 Functor
instance Functor [] where
    -- fmap : (a -> b) -> [a] -> [b]
    fmap = map
Prelude> :k []
[] :: * -> *
Prelude> fmap (+2) [1,2,3]
[3,4,5]
Prelude> (+2) <$> [1,2,3]
[3,4,5]
Prelude> 3 <$ [1,2,3]
[3,3,3]
Prelude Data.Functor> [1,2,3] $> 3
[3,3,3]
Prelude Data.Functor> void [1,2,3]
[(),(),()]
证明[]符合Functor法则：
1. fmap id ≡ id
fmap id [a] ≡ [id a] ≡ [a]
id [a] ≡ [a]
2. fmap (f . g) ≡ fmap f . fmap g
fmap (f . g) [a] ≡ [(f . g) a] ≡ [f (g a)]
(fmap f . fmap g) [a] ≡ fmap f (fmap g [a]) ≡ fmap f [g a] ≡ [f (g a)]

Maybe 是 Functor
instance  Functor Maybe  where
    -- fmap : (a -> b) -> (Maybe a) -> (Maybe b)
    fmap _ Nothing       = Nothing
    fmap f (Just a)      = Just (f a)
Prelude> :k Maybe
Maybe :: * -> *
Prelude> fmap (+2) (Just 3)
Just 5
Prelude> (+2) <$> (Just 3)
Just 5
Prelude> fmap (+2) Nothing
Nothing
Prelude> 2 <$ Just 3
Just 2
证明Maybe符合Functor法则：
1. fmap id ≡ id
fmap id Nothing ≡ Nothing
id Nothing ≡ Nothing
fmap id (Just a) ≡ Just (id a) ≡ Just a
id (Just a) ≡ Just a
2. fmap (f . g) ≡ fmap f . fmap g
fmap (f . g) Nothing ≡ Nothing
(fmap f . fmap g) Nothing ≡ fmap f (fmap g Nothing) ≡ fmap f Nothing ≡ Nothing
fmap (f . g) (Just a) ≡ Just ((f . g) a) ≡ Just (f (g a))
(fmap f . fmap g) (Just a) ≡ fmap f (fmap g (Just a)) ≡ fmap f (Just (g a)) ≡ Just (f (g a))

((->) r) 是 Functor
instance Functor ((->) r) where
    -- fmap : (a -> b) -> ((->) r a) -> ((->) r b)
    -- fmap : (a -> b) -> (r -> a) -> (r -> b)
    fmap = (.)
Prelude> fmap (+2) (*3) 4
14
Prelude> (+2) <$> (*3) $ 4
14
Prelude> 2 <$ (*3) $ 4
2
fmap (+2) (*3) 4 = 4*3+2 = 14
Either a 是 Functor
data  Either a b  =  Left a | Right b
instance Functor (Either a) where
    fmap _ (Left x) = Left x
    fmap f (Right y) = Right (f y)
Prelude> :k (Either String)
(Either String) :: * -> *
Prelude> fmap (replicate 3) (Right "blah")
Right ["blah","blah","blah"]
Prelude> replicate 3 <$> Right "blah"
Right ["blah","blah","blah"]
Prelude> fmap (replicate 3) (Left "foo")
Left "foo"
Prelude> "hello" <$ Right "blah"
Right "hello"
Prelude> "hello" <$ Left "foo"
Left "foo"

((,) a) 是 Functor
instance Functor ((,) a) where
    fmap f (x,y) = (x, f y)
Prelude> :k ((,)String)
((,)String) :: * -> *
Prelude> fmap (*3) (1,2)
(1,6)

typeclass Functor代表可以被
 map over 的事物。List, Maybe 都是Functor. 需要是一个参数的类型构造子或函数。 
  需要满足functor
 law：(满足定理的好处， 用定律来推论类型的行为， 不用看 fmap 的实现)

 如果我们对 functor 做 map id，那得到的新的
 functor 应该要跟原来的一样。如果写得正式一点，他代表 fmap
 id = id
先将两个函数合成并将结果 map over 一个 functor 的结果，应该跟先将第一个函数 map over
 一个 functor， 

再将第二个函数 map over 那个 functor 的结果是一样的。正式地写下来的话就是fmap
 (f . g) = fmap f . fmap g。

（或 fmap (f . g) F = fmap f (fmap g F)）




class Functor f where 
    fmap :: (a -> b) -> f a -> f b
instance Functor [] where 
    fmap = map
instance Functor Maybe where 
    fmap f (Just x) = Just (f x) 
    fmap f Nothing = Nothing
data Either a b = Left a | Right b


instance Functor (Either a) where 
    fmap f (Right x) = Right (f x) 
    fmap f (Left x) = Left x


instance Functor ((->) r) where   
    fmap f g = (\x -> f (g x))
instance Functor ((->) r) where   
    fmap = (.)
fmap :: (a -> b) -> (r -> a) -> (r ->
 b)



说明；如果一个 type constructor 要是 Functor 的
 instance，那他的 kind 必须是 * ->
 *，这代表他必须刚好接受一个 type 当作 type parameter。像是 Maybe 可以是
 Functor 的一个 instance，因为他接受一个 type parameter，来做成像是 Maybe
 Int，或是 Maybe
 String。如果一个 type constructor 接受两个参数，像是 Either，我们必须给他两个
 type parameter。所以我们不能这样写：instance
 Functor Either where，但我们可以写 instance
 Functor (Either a) where，如果我们把 fmap 限缩成只是 Either
 a 的，那他的型态就是fmap
 :: (b -> c) -> Either a b -> Either a c。
 
     对于是一个参数的函数的类型： (->) r  是描述类型。 原来看到 (*3)， 一直以为 r是需要在输入的参数，是不对的。(->) 的Kind 如下，是一个两个参数的运算符。  (->)
 r  是一个整体， 表示 (->) 已经接受一个参数， 他的Kind 应该是  ＊-> * 的类型。

> :k (->)
(->) :: * -> * -> *