正如其他人所说，函数式编程有特定的模式。我认为摆脱设计模式的问题与其说是转换到功能的问题，不如说是语言特性的问题。

看看Scala是如何废除“单例模式”的:只需声明一个对象而不是一个类。 另一个特性，模式匹配，有助于避免笨重的访问者模式。对比如下: Scala的模式匹配=类固醇访问者模式

Scala和f#一样，是OO-functional的融合。我不了解f#，但它可能有这些特性。

闭包是在函数式语言中出现的，但不需要被限制在函数式语言中。它们有助于使用委托模式。

还有一个观察结果。这段代码实现了一个模式:它是如此经典，如此基本，以至于我们通常不认为它是一个“模式”，但它确实是:

for(int i = 0; i < myList.size(); i++) { doWhatever(myList.get(i)); }

像Java和c#这样的命令式语言已经采用了本质上是一个函数结构来处理这个问题:“foreach”。

OOP和GoF模式处理状态。OOP对现实进行建模，使代码库尽可能接近现实的给定需求。GoF设计模式是为解决原子现实问题而确定的模式。它们以语义的方式处理状态问题。

因为在真正的函数式编程中不存在状态，所以应用GoF模式没有意义。功能设计模式与GoF设计模式是不同的。与现实相比，每个功能设计模式都是人为的，因为函数是数学的构造，而不是现实。

函数缺乏时间的概念，因为无论当前时间是多少，它们总是返回相同的值，除非时间是函数参数的一部分，这使得处理“未来的请求”非常困难。混合语言混合了这些概念，使得这些语言不是真正的函数式编程语言。

Functional languages are rising only because of one thing: the current natural restrictions of physics. Todays processors are limited in their speed of processing instructions due to physical laws. You see a stagnation in clock frequency but an expansion in processing cores. That's why parallelism of instructions becomes more and more important to increase speed of modern applications. As functional programming by definition has no state and therefore has no side effects it is safe to process functions safely in parallel.

GoF模式并没有过时。它们至少对真实世界的需求建模是必要的。但是如果你使用函数式编程语言，你必须将它们转换成它们的混合等价物。最后，如果使用持久性，就没有机会只编写函数式程序。对于程序的混合元素，仍然需要使用GoF模式。对于任何其他纯功能性的元素，没有必要使用GoF模式，因为没有状态。

因为GoF模式对于真正的函数式编程不是必需的，这并不意味着不应该应用SOLID原则。SOLID原则超越了任何语言范式。

你引用的那篇博客文章有点言过其实了。FP并没有消除对设计模式的需求。术语“设计模式”在FP语言中并没有广泛用于描述相同的事情。但它们确实存在。函数式语言有很多最佳实践规则，比如“当你遇到问题X时，使用看起来像Y的代码”，这基本上就是设计模式。

然而，大多数特定于oop的设计模式在函数式语言中几乎是不相关的，这是正确的。

我不认为说设计模式一般只是为了弥补语言中的缺陷而存在是特别有争议的。 如果另一种语言可以简单地解决同样的问题，那么另一种语言就不需要设计模式了。这种语言的用户甚至可能没有意识到这个问题的存在，因为，好吧，这在那种语言中不是问题。

下面是“四人帮”对这个问题的看法:

The choice of programming language is important because it influences one's point of view. Our patterns assume Smalltalk/C++-level language features, and that choice determines what can and cannot be implemented easily. If we assumed procedural languages, we might have included design patterns called "Inheritance", "Encapsulation," and "Polymorphism". Similarly, some of our patterns are supported directly by the less common object-oriented languages. CLOS has multi-methods, for example, which lessen the need for a pattern such as Visitor. In fact, there are enough differences between Smalltalk and C++ to mean that some patterns can be expressed more easily in one language than the other. (See Iterator for example.)

(以上内容摘自《设计模式导论》一书第4页第3段)

功能的主要特点 编程包括以下函数 一流的价值观，咖喱， 不可变值等等。似乎不是这样 在我看来，OO设计模式是显而易见的 有接近这些吗 特性。

What is the command pattern, if not an approximation of first-class functions? :) In an FP language, you'd simply pass a function as the argument to another function. In an OOP language, you have to wrap up the function in a class, which you can instantiate and then pass that object to the other function. The effect is the same, but in OOP it's called a design pattern, and it takes a whole lot more code. And what is the abstract factory pattern, if not currying? Pass parameters to a function a bit at a time, to configure what kind of value it spits out when you finally call it.

所以，是的，在FP语言中，一些GoF设计模式是多余的，因为存在更强大、更容易使用的替代方案。

当然，仍然有一些设计模式是FP语言无法解决的。FP与单例的等价是什么?(暂时不考虑单例对象通常是一种糟糕的模式。)

这也是双向的。正如我所说，FP也有它的设计模式;人们只是通常不这么认为而已。

但是你可能遇到过单子。如果不是“处理全局状态”的设计模式，它们是什么?这个问题在面向对象语言中是如此简单，以至于没有相应的设计模式存在。

我们不需要“增加静态变量”或“从套接字读取”的设计模式，因为这就是你要做的。

说一个单子是一种设计模式，就像说整数和它们的常规操作和零元素是一种设计模式一样荒谬。不，单子是一种数学模式，不是设计模式。

在(纯)函数式语言中，副作用和可变状态是不可能的，除非你使用单子“设计模式”，或任何其他允许相同事情的方法来解决它。

此外，在函数式语言中 支持OOP(如f#和 OCaml)，在我看来很明显 使用这些语言的程序员 是否会使用相同的设计模式 发现对所有其他OOP都可用 语言。事实上，现在我使用f# 和OCaml每天，没有 两者之间的显著差异 我在这些语言中使用的模式vs 我写字时使用的模式 Java。

也许是因为你的思维仍然是强制性的?很多人一生都在处理命令式语言，当他们尝试函数式语言时，很难放弃这个习惯。(我在f#中看到过一些非常有趣的尝试，实际上每个函数都只是一串“let”语句，基本上就像你使用了一个C程序，并将所有分号替换为“let”。:))

但另一种可能是，您还没有意识到您正在解决的问题很琐碎，这将需要OOP语言中的设计模式。

当您使用curry，或将一个函数作为参数传递给另一个函数时，请停下来想一想在OOP语言中如何做到这一点。

这种说法有道理吗 函数式编程消除了 需要面向对象设计模式?

是的。：） 当您使用FP语言工作时，您不再需要特定于oop的设计模式。但是您仍然需要一些通用的设计模式，如MVC或其他非oop特定的东西，并且您需要一些新的特定于fp的“设计模式”。所有语言都有其缺点，而设计模式通常是我们围绕它们工作的方式。

无论如何，您可能会发现尝试使用“更干净”的FP语言是很有趣的，比如ML(我个人最喜欢的语言，至少在学习的目的上是这样的)，或者Haskell，在这些语言中，当您面对新事物时，您没有OOP的拐杖可以依靠。

不出所料，有些人反对我将设计模式定义为“修补语言中的缺陷”，所以我的理由如下:

如前所述，大多数设计模式都特定于一种编程范式，有时甚至是一种特定的语言。通常，它们解决的问题只存在于该范例中(参见FP的单子，或OOP的抽象工厂)。

为什么在FP中不存在抽象工厂模式?因为它试图解决的问题并不存在。

因此，如果OOP语言中存在FP语言中不存在的问题，那么很明显这是OOP语言的缺点。这个问题是可以解决的，但是你的语言不能这样做，而是需要你编写一堆样板代码来解决它。理想情况下，我们希望我们的编程语言能够神奇地解决所有问题。任何仍然存在的问题原则上都是语言的缺陷。；）

在2013年的新书《函数式编程模式- In Scala and Clojure》中，作者Michael.B。Linn在很多情况下对GoF模式进行了比较和替换，并讨论了较新的功能模式，如“尾递归”、“记忆化”、“惰性序列”等。

这本书在亚马逊上有售。作为一个拥有几十年OO背景的人，我发现这本书内容丰富，令人鼓舞。

恕我说一句，函数式编程最重要的特点是，你只用表达式来编程——表达式中的表达式，表达式中的表达式，所有的表达式都计算到最后，最终的表达式“计算时使机器变热”。

以我之见，面向对象编程的最重要的特征是，您正在使用具有内部状态的对象进行编程。在纯函数中不能有内部状态——面向对象的编程语言需要语句来实现。(函数式编程中没有语句。)

你是在拿苹果和橘子作比较。面向对象编程的模式不适用于函数编程，因为函数式编程是使用表达式进行编程，而面向对象编程是使用内部状态进行编程。

正如其他人所说，函数式编程有特定的模式。我认为摆脱设计模式的问题与其说是转换到功能的问题，不如说是语言特性的问题。

看看Scala是如何废除“单例模式”的:只需声明一个对象而不是一个类。 另一个特性，模式匹配，有助于避免笨重的访问者模式。对比如下: Scala的模式匹配=类固醇访问者模式

Scala和f#一样，是OO-functional的融合。我不了解f#，但它可能有这些特性。

闭包是在函数式语言中出现的，但不需要被限制在函数式语言中。它们有助于使用委托模式。

还有一个观察结果。这段代码实现了一个模式:它是如此经典，如此基本，以至于我们通常不认为它是一个“模式”，但它确实是:

for(int i = 0; i < myList.size(); i++) { doWhatever(myList.get(i)); }

像Java和c#这样的命令式语言已经采用了本质上是一个函数结构来处理这个问题:“foreach”。