精华内容
下载资源
问答
  • functor

    2018-05-23 14:41:19
    functor 是什么?在阅读Tensorflowy源码时看到了这个,后来明白这是个命名空间,但查了一下原来functor并不简单,以后很可能会用到,特此转载记下。引子有一次在美团面试的时候,第二轮面试官问道:“听说过functor...
    functor 是什么?
    在阅读Tensorflowy源码时看到了这个,后来明白这是个命名空间,但查了一下原来functor并不简单,以后很可能会用到,特此转载记下。
    下面是转载的作者原文:

    引子

    有一次在美团面试的时候,第二轮面试官问道:“听说过functor吗?”,妈呀,6年了,竟然没听说过这个概念,今天就学习了一会,哎,天不遂人愿,老天弄人啊,其实这个东西我们大家都不止一次的在使用它。举个例子(注意for_each的第三个参数):

    [cpp]  view plain  copy
    1. // for_each example  
    2. #include <iostream>     // std::cout  
    3. #include <algorithm>    // std::for_each  
    4. #include <vector>       // std::vector  
    5.   
    6. void myfunction (int i) {  // function:  
    7.     std::cout << ' ' << i;  
    8. }  
    9.   
    10. struct myclass {           // function object type:  
    11.     void operator() (int i) {std::cout << ' ' << i;}  
    12. } myobject;  
    13.   
    14. int main () {  
    15.     std::vector<int> myvector;  
    16.     myvector.push_back(10);  
    17.     myvector.push_back(20);  
    18.     myvector.push_back(30);  
    19.       
    20.     std::cout << "myvector contains:";  
    21.     for_each (myvector.begin(), myvector.end(), myfunction);  
    22.     std::cout << '\n';  
    23.       
    24.     // or:  
    25.     std::cout << "myvector contains:";  
    26.     for_each (myvector.begin(), myvector.end(), myobject);  
    27.     std::cout << '\n';  
    28.       
    29.     return 0;  
    30. }  

    是的,这就是functor的思想。

    补充一下functor的实现(各个人实现可能不一样哦,不同的库,不同的语言也可能不一样哦),仅供参考:

    [cpp]  view plain  copy
    1. template<class InputIterator, class Function>  
    2.   Function for_each(InputIterator first, InputIterator last, Function fn)  
    3. {  
    4.   while (first!=last) {  
    5.     fn (*first);  
    6.     ++first;  
    7.   }  
    8.   return fn;      // or, since C++11: return move(fn);  
    9. }  

    什么是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

    2019-10-02 15:07:23
    #include <iostream> #include <math.h> using namespace std; class Pow { public: double operator()(double x, int y) { double xx = x; for (int i =...
    #include <iostream>
    #include <math.h>
    using namespace std;
    
    class Pow
    {
       public:
          double operator()(double x, int y)
          {
         double xx = x;
    for (int i = 0; i < y-1; i++) x *=xx; return x; } }; int main() { int a = 5; cout << pow(a, 2) << endl; Pow mypow; cout << "mypow:" << mypow(a, 2); return 0; }

     

       for (auto itr = vi.begin(); itr != vi.end(); ++itr)
       {
          cout << *itr << endl;
       }
    

     

    for (auto i:vi)
    {
       cout << i << endl;   
    }

     

    转载于:https://www.cnblogs.com/aelite/p/11306579.html

    展开全文
  • Functor Law #2 (Composition): fmap (f . g) = fmap f . fmap g Applicative Functor Law #1 (Identity): pure id <*> x = x Applicative Functor Law #2 (Homomorphism): pure f <*> pure x =
  • C++ functor

    千次阅读 2017-08-02 15:08:13
    functor就是一个重载了 operator()的类,用这个类生成的实例就像一个函数。(functor就是一个作为函数用的类),在c++11后可以用lambda函数实现同样的功能。参考链接:stackoverflow// this is a functor struct add...

    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函子

    2021-07-02 14:24:39
    定义:是一个容器,也是个普通容器,实现了map函数,在遍历每个值得时候生成新的对象。 这是无副作用地、不可变的访问和...interface Functor<T> { (arg: T): T, of: any, prototype: object, } // 创建.

    定义:是一个容器,也是个普通函数,实现了flapMap接口(map函数),在遍历每个值得时候生成新的对象。
    这个过程是无副作用地、不可变的访问和修改操作。包裹不安全的值,提升代码健壮性。避免程序异常中断。
    隔离不纯、合并判空逻辑、避免异常、支持函数组合

    Functor函子

    /**
     * 不能使用箭头函数
     * 箭头函数没有constructor和prototype
     * @constructor
     */
    interface Functor<T> {
        (arg: T): T,
    
        of: any,
        prototype: object,
    }
    
    // 创建一个容器
    const Functor = function <Functor>(val) {
        this.value = val;
    }
    // 添加of接口,省略new去创建
    Functor.of = function (val) {
        // @ts-ignore
        return new Functor(val);
    }
    // 实现map接口
    Functor.prototype.map = function (fn) {
        return Functor.of(fn(this.value));
    }
    
    const v = Functor.of(2);
    const t = Functor.of({a: 1});
    const r = Functor.of([1, 2]);
    
    console.log(v, t, r);
    // Functor { value: 2 } Functor { value: { a: 1 } } Functor { value: [ 1, 2 ] }
    console.log(v.map((x)=> {
        return x * x
    }).map((x)=> {
        return x + x;
    }));
    // Functor { value: 8 }
    

    Maybe

    集中管理无效数据的检查,可合并判空,避免异常,(增加了判空逻辑)但是无法详细的给出错误的位置

    /**
     * 创建一个MayBe容器
     * @param val
     * @constructor
     */
    const MayBe = function <Functor>(val) {
    	this.value = val;
    };
    // 添加of接口,省略new去创建
    MayBe.of = function (val) {
    	// @ts-ignore
    	return new MayBe(val);
    };
    
    /**
     * 定义isNothing函数 判断数据是否为空
     */
    MayBe.prototype.isNothing = function () {
    	return this.value !== undefined && this.value !== null;
    };
    /**
     * 重写map函数
     * @param fn
     */
    MayBe.prototype.map = function (fn) {
    	return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this.value));
    };
    
    // 测试代码
    const n = MayBe.of(null).map((v) => {
    	return v * 1;
    }).map((v) => {
    	return v;
    });
    console.log(n); // MayBe { value: null }
    

    Either函子

    可从故障中恢复,并给出具体的错误位置(增加了异常捕获),可延迟抛出异常,使代码可正常执行​

    /**
     * Either函子
     */
    // 创建一个Either容器
    const Either = function <Functor>(val) {
    	this.value = val;
    };
    // 添加of接口,省略new去创建
    Either.of = function (val) {
    	// @ts-ignore
    	return new Either(val);
    };
    
    // 创建一个Nothing容器 包裹错误信息
    const Nothing = function <Functor>(val) {
    	this.value = val;
    };
    // 添加of接口,省略new去创建
    Nothing.of = function (val) {
    	// @ts-ignore
    	return new Nothing(val);
    };
    // 定义map接口
    Nothing.prototype.map = function (fn) {
    	return this;
    };
    
    Either.Nothing = Nothing;
    /**
     * 定义map接口
     * @param fn
     */
    Either.prototype.map = function (fn) {
    	try {
    		return Either.of(fn(this.value));
    	} catch (e) {
    		return Either.Nothing.of(e);
    	}
    };
    
    // 测试代码
    const e = Either.of(undefined).map((v) => {
    	return v.length / 0;
    }).map((v) => {
    	return v;
    });
    console.log(e); // Nothing {
    // value: TypeError: Cannot read property 'length' of undefined
    // at ...
    
    // 以下代码 会打印出来 不会中断程序执行
    console.log(4444); // 4444
    console.log(6666); // 6666
    
    展开全文
  • matlab开发-functor

    2019-08-28 01:02:15
    matlab开发-functor。功能手柄的自动组合
  • 函子functor笔记

    2021-07-29 11:39:29
    Functor 函子 1. 作用 控制副作用,异常处理,异步操作 副作用是指: 让函数变得不纯的因素 2. 什么是函子: 函子是一个对象 函子是一个容器: 值(对内) + 处理值的函数map(fn)(对外) map(fn)参数...
  • 仿函数(functor).pdf

    2021-08-10 13:51:08
    仿函数(functor).pdf
  • Functor
  • haskell Functor

    2014-11-17 09:08:19
    Functor 这个 typeclass,基本上就代表可以被 map over 的事物。听到这个词你可能会联想到 List,因为 map over list 在 Haskell 中是很常见的操作。你没想错,List 的确是属于 Functor 这个 typeclass。
  • Scala Cats - Functor

    2020-11-30 23:25:32
    cats - FunctorFunctor不同的角度用 Functor 来管理效果(effect)Functor 的组合参考 Functor Functor 是用来表示抽象化出可以调用 map 方法的结构 的 类型类. 这种结构比如说有 List, Option, 和 Future. 实现了 ...
  • functor 本文最初是我们使用RxJava进行React式编程的附录。 但是,尽管与React式编程非常相关,但对monad的介绍却不太适合。 因此,我决定将其取出并作为博客文章单独发布。 我知道,“ 我对单子的自己的,一半正确...
  • Functor 是一个带注释的函数(即具有命名输入和输出参数的 function_handle)。 使用 functor.compose 和/或 functor.combine 可以将函子的集合自动组合成新的函子我有时发现这对重构、调试和设计更大的程序很有用。...
  • Functor& Monad解读

    2019-10-03 14:06:45
    trait Functor[F[_]] Functor:代表整体封装; F[_]:代表封装后的目标域。 A、B:代表普通的对象;f:代表对象间转换的函数。 Functor[F[_]] :映射的结果和源在同一个范畴内; Functor的代码表示 trait ...
  • 根据定义, Functor只是第一类方法,但这些在 Ruby 中非常常见,包括Method 、 UnboundMethod和Proc类。 所以对于 Ruby,我们将 Functor 定义为一个高阶函数。 本质上,函子可以根据应用于它的操作来改变其行为。 ...
  • Haskell学习-functor

    2018-08-16 09:24:00
    原文地址:Haskell学习-functor 什么是Functor functor 就是可以执行map操作的对象,functor就像是附加了语义的表达式,可以用盒子进行比喻。functor 的定义可以这样理解:给出a映射到b的函数和装了a的盒子,结果会...
  • Functor与fmap

    2015-11-06 11:41:30
    Functor俗称仿函数或者函子,他是一个类型类,我们先看看他的结构 scala> :kind Functor scalaz.Functor's kind is X[F[A]] 可以看出它是一个类型构造器的构造器,但是不像List等序列(强调的是容器),我们这里X并不是像...
  • c++仿函数 functor

    2018-07-22 15:54:54
    c++仿函数 functor
  • C++ STL: functor

    2021-03-23 22:30:56
    0 前言 最近上C++选修,又看了看STL源码,就整理一下吧。...将该操作设计成一个仿函数(class),再将该functor产生一个对象,将这个对象作为算法的一个参数 functor class need to overload operator() grea
  • 一个Functor /“函数对象”库,提供实现operator()的类。 对标准所提供内容的实质性改进(IMHO),包括组成,算术表达式,“转换”操作,命名约定等。
  • Functor (函子)

    2020-11-01 20:40:39
    什么是 Functor 容器:包含值和值的变形关系(这个变形关系就是函数) 函子:是一个特殊的容器,通过一个普通的对象来实现,该对象具有 map 方法,map 方法可以运 行一个函数对值进行处理(变形关系) Functor ...
  • C++仿函数(Functor)

    2021-08-05 10:23:05
    C++仿函数(Functor) 在Qt编程的时候,时常看到有的参数可以传递一个名为Functor的模板类。如QObject::connect及QtConcurrent::run都有这个Functor的存在。 Functor其实就是一个类名,只不过这个类重载了operator()...
  • 函子(Functor)

    2021-04-20 10:48:36
    函子: 是一个特殊的容器,...// Functor // 定一个类 class Container{ constructor(value){ this._value= value } // 向外提供方法 map(fn){ return new Container(fn(this._value)) } } let r= new Containe.
  • js Functor Copy

    2016-07-25 13:40:00
    utm_medium=referral本处仅仅个人存档学习,如有侵权,请联系我删除...Functor仿函数(Functor)是C++里面一个重要的概念,简而言之就是使用重载了operator()运算符的对象模仿函数的行为,带来的收益是仿函数可以携...
  • [原文链接](http://blog.leichunfeng.com/blog/2015/11/08/functor-applicative-and-monad/) Functor、Applicative 和 Monad Nov 8th, 2015 10:53 am Functor、Applicative 和 Monad 是函数式编程语言中三个

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,428
精华内容 4,171
关键字:

functor