哪些功能特性值得为它们带来的好处感到困惑？

在使用Haskell和F＃学习了函数式编程之后，OOP范例似乎在类，接口和对象方面倒退了。我的同事可以理解FP的哪些方面？是否有任何FP风格值得与我的老板谈谈对我的团队进行再培训，以便我们可以使用它们？

FP的可能方面：

• 不变性
• 部分应用和咖喱
• 一流的功能（功能指针/功能对象/策略模式）
• 惰性评估（和Monad）
• 纯功能（无副作用）
• 表达式（相对于语句-每行代码都会产生一个值，而不是引起副作用，或者除了引起副作用之外）
• 递归
• 模式匹配

它是一种免费的所有人，我们可以在编程语言支持的范围内做任何事情吗？还是有更好的指南？

函数式编程与面向对象的编程是不同的范例（不同的思维方式和关于程序的不同思考方式）。您已经开始意识到，这里考虑问题及其解决方案的方式（面向对象）不止一种。还有其他的（想到程序和通用编程）。您如何应对这些新知识，是否接受和将这些新工具和方法整合到您的技能中，将决定您是否成长并成为更完整，更有技能的开发人员。

我们所有人都经过培训，能够处理一定水平的复杂性并感到满意。我喜欢称其为人的身高限制（从Watership Down，您可以算出多少）。扩大您的思维，考虑更多选项的能力以及拥有更多解决和解决问题的工具的能力是一件很棒的事情。但这是一个变化，它使您脱离舒适区。

您可能会遇到的一个问题是，您对跟随“一切都是对象”人群的满足感将降低。当您与可能不了解（或不想了解）为什么软件开发的功能性方法可以很好地解决某些问题的人员一起工作时，您可能需要提高耐心。就像通用编程方法可以很好地解决某些问题一样。

祝好运！

函数式编程在日常的代码编写中提供了非常实用，务实的生产力：某些功能有利于简洁，这很棒，因为编写的代码越少，执行的故障就越少，所需的维护也越少。

作为一个数学家，我发现花哨的功能性东西很吸引人，但是在设计应用程序时通常很有用：这些结构可以在程序结构中编码程序的许多不变量，而不必用变量表示这些不变量。

我最喜欢的组合可能看起来微不足道，但是我认为它对生产率有很高的影响。这种组合是部分应用程序和Currying 函数以及一流的函数，我不会重新标记它们，因此再也不会写for循环：而是将循环体传递给迭代或映射函数。我最近被录用为C ++职位，但有趣的是，我完全失去了编写for循环的习惯 ！

递归和模式匹配的结合消除了该访问者设计模式的需要。只需比较一下您需要为布尔表达式的评估器编程的代码：在任何函数式编程语言中，这应该是大约15行代码，在OOP中，正确的做法是使用该Visitor设计模式，这将变成一个玩具示例。一篇广泛的论文。优势是显而易见的，我不感到任何不便。

您可能必须限制自己在工作中使用的知识的哪些部分，为了享受正常生活的好处，超人必须伪装成克拉克·肯特。但是，了解更多信息永远不会伤害您。就是说，函数式编程的某些方面适合于面向对象的商店，而其他方面可能值得与老板讨论，以便您可以提高商店的平均知识水平并因此编写更好的代码。

FP和OOP不互斥。看Scala。有些人认为这是最糟糕的，因为它是不纯FP，但出于同样的原因，有些人认为它是最好的。

以下是与OOP结合使用的一些方面：

• 纯函数（无副作用）-我所知道的每种编程语言都支持此功能。它们使您的代码更容易理解，应在可行时使用。您不必将其称为FP。只是称其为良好的编码习惯。

• 不变性：字符串可以说是最常用的Java对象，并且是不变的。我在博客上介绍了不可变的Java对象和不可变的Java集合。其中一些可能适用于您。

• 一流的功能（函数指针/功能对象/策略模式）-自1.1版以来，Java有了一个笨拙的变体版本，其中大多数API类（并且有数百种）实现了Listener接口。可运行的可能是最常用的功能对象。头等函数需要更多的工作来使用本机不支持它们的语言进行编码，但是当它们简化代码的其他方面时，有时值得付出额外的努力。

• 递归对于处理树很有用。在OOP商店中，这可能是递归的主要适当用法。如果出于大多数OOP语言默认没有堆栈空间的原因而没有其他原因，那么最好在OOP中使用递归来娱乐，这是一个好主意。

• 表达式（相对于语句-代码的每一行都会产生一个值，而不是引起副作用，或者除了引起副作用外）-C，C ++和Java中唯一的求值运算符是Ternary运算符。我在博客上讨论了适当的用法。您可能会发现自己编写了一些高度可重用和评估的简单函数。

• 延迟评估（和Monad）-主要限于OOP中的延迟初始化。没有语言功能来支持它，您可能会发现一些有用的API，但是编写自己的API却很困难。而是最大程度地使用流-有关示例，请参见Writer和Reader接口。

• 部分应用和咖喱化-没有一流的功能不切实际。

• 模式匹配-在OOP中通常不建议使用。

总而言之，我认为工作不应该是万能的，您可以在其中完成编程语言所支持的任何工作，而该语言所能支持的极限。我认为您的同事的可读性应该是您对要出租的代码的试金石。我最想让您感到满足的地方是开始进行一些工作上的教育，以拓宽您的同事的视野。

除了功能编程和面向对象的编程外，还有声明性编程（SQL，XQuery）。学习每种样式可以帮助您获得新的见解，并且您将学习选择适合该工作的工具。

但是，是的，用一种语言编写代码可能非常令人沮丧，并且知道如果您正在使用其他内容，那么对于特定的问题域，您的工作效率可能会更高。但是，即使您使用的是Java之类的语言，也可以将FP中的概念应用到Java代码中，尽管采用的是回旋方式。例如，Guava框架就是其中的一部分。

作为程序员，我认为您永远都不应停止学习。就是说，学习FP污染您的OOP技能非常有趣。我倾向于将学习OOP看作是学习如何骑自行车。您永远不会忘记该怎么做。

当我了解FP的来龙去脉时，我发现自己在数学上进行了更多的思考，并且对编写软件的方法有了更好的了解。那是我的亲身经历。

随着您获得更多的经验，核心编程概念将更难失去。因此，我建议您在FP上放轻松，直到OOP概念完全被您牢记。FP是一个确定的范式转换。祝好运！

已经有很多好的答案，因此我将解决您的部分问题；也就是说，我谨代表您提出问题的前提，因为OOP和功能部件不是互斥的。

如果使用C ++ 11，则语言/标准库中内置了许多此类功能编程功能，这些功能可以与OOP很好地协同（很好）。当然，我不确定您的老板或同事对TMP的接受程度如何，但是重点是您可以以某种形式或以其他非功能性/ OOP语言（例如C ++）获得许多这些功能。

使用具有编译时间递归的模板取决于您的前三点，

• 不变性
• 递归
• 模式匹配

由于模板值是不可变的（编译时常量），因此任何迭代都使用递归完成，而分支则使用（或多或少）模式匹配来完成，并以过载解析的形式进行。

至于其他要点，使用std::bind和std::function给您提供部分函数应用程序，并且函数指针是该语言的内置函数。可调用对象是功能对象（以及部分功能应用程序）。请注意，所谓可调用对象，是指定义其的对象operator ()。

惰性求值和纯函数会有点困难；对于纯函数，可以使用仅按值捕获的lambda函数，但这是不理想的。

最后，这是在部分函数应用程序中使用编译时递归的示例。这是一个有些人为的例子，但它说明了上面的大多数观点。它将递归地将给定元组中的值绑定到给定函数，并生成（可调用的）函数对象

#include <iostream>
#include <functional>

//holds a compile-time index sequence
template<std::size_t ... >
struct index_seq
{};

//builds the index_seq<...> struct with the indices (boils down to compile-time indexing)
template<std::size_t N, std::size_t ... Seq>
struct gen_indices
  : gen_indices<N-1, N-1, Seq ... >
{};

template<std::size_t ... Seq>
struct gen_indices<0, Seq ... >
{
    typedef index_seq<Seq ... > type;
};


template <typename RType>
struct bind_to_fcn
{
    template <class Fcn, class ... Args>
    std::function<RType()> fcn_bind(Fcn fcn, std::tuple<Args...> params)
    {
        return bindFunc(typename gen_indices<sizeof...(Args)>::type(), fcn, params);
    }

    template<std::size_t ... Seq, class Fcn, class ... Args>
    std::function<RType()> bindFunc(index_seq<Seq...>, Fcn fcn, std::tuple<Args...> params)
    {
        return std::bind(fcn, std::get<Seq>(params) ...);
    }
};

//some arbitrary testing function to use
double foo(int x, float y, double z)
{
    return x + y + z;
}

int main(void)
{
    //some tuple of parameters to use in the function call
    std::tuple<int, float, double> t = std::make_tuple(1, 2.04, 0.1);                                                                                                                                                                                                      
    typedef double(*SumFcn)(int,float,double);

    bind_to_fcn<double> binder;
    auto other_fcn_obj = binder.fcn_bind<SumFcn>(foo, t);
    std::cout << other_fcn_obj() << std::endl;
}