为什么 smalltalk 不是函数式编程语言？

Question

随着对函数式编程语言的重新兴趣，我看到了 Smalltalk 和 FPL 之间的一些相似之处，即闭包（Smalltalk 中的 BlockClosures） 然而，Smalltalk 不是 FPL？

需要什么来考虑它？

Answer 1

函数式编程语言没有公认的定义。

如果您将函数式语言定义为支持一流函数的语言，那么是的，Smalltalk *是*一种函数式语言。

如果您还考虑支持不变性、代数数据类型、模式匹配、部分应用等因素，那么不，Smalltalk *不是*一种函数式语言。

---

我鼓励您阅读以下相关博文（以及它们下面的 cmets）：

• Scala is not a functional language

• Erlang is not functional

• Reddit discussion on "Erlang is not functional"

Answer 2

Smalltalk 可能不是一种“纯函数式语言”（不管它是什么）。然而，Smalltalk 的自然使用通常会产生函数式代码。 （我猜 Scala 人会称之为“对象功能”。）

例如，Squeak 的 Point 类有一个函数式 API：像 1@1 translateBy: 1@1 这样的方法会返回带有新状态的新 Point，而不是改变内部状态。 （这使得 Point 实际上是不可变的，因为改变对象内部状态的唯一方法是通过像 #instVarAt: 这样的反射机制。）

在 Smalltalk 中使用高阶函数（如地图、过滤器、折叠等）是很正常的。鉴于这些已融入 Collections API，编写以函数方式使用 Collections 的代码通常比不编写代码更容易。

很多人对“函数式编程语言”有太多定义，以至于“Foo 是一种 FPL”这个问题就像“Foo 是一种面向对象的语言”一样无用。

话虽如此，这是我的两分钱：函数式编程语言是一种自然并且惯用采用函数式技术的语言：一流的函数，避免可变状态、无副作用函数、高阶函数。

根据该描述，Smalltalk 是一种函数式编程语言。它将一阶函数称为“方法”或“块”，具体取决于它们是命名的还是匿名的。对象将状态存储在实例变量中。高阶函数只是将块作为参数的方法。

话虽如此，是的，您可以以非功能性方式编写 Smalltalk。它确实允许可变状态。这是否会阻止 Smalltalk 被称为函数式语言？如果是这样，这些语言都不是功能性的：Common Lisp、Erlang（通过进程字典共享状态、ets/dets）。

所以，简而言之，Smalltalk 是一个 FPL，因为：

• 函数是一等实体（准确地说，是 Smalltalk 中的对象 - CompiledMethods 或 BlockClosures）。
• Smalltalk 支持闭包（它称它们为块）。
• Smalltalk 允许人们以一种自然、惯用的方式进行函数式编写。

并且Smalltalk 不是 FPL，因为：

• 作为程序员，您必须确保您的数据结构（对象）是不可变的（通过让 setter/mutators 返回具有突变状态的对象的副本）。
• 作为程序员，您必须确保您的方法（函数）没有副作用。

（一些 Smalltalks 显然支持不可变对象。我的经验仅限于 Squeak，它不支持 VM 级别的不可变性。）

编辑：除了通过在对象上定义方法外，我不理解 igouy 对命名函数定义的需求。但无论如何，我们开始吧：

Smalltalk at: #func put: [:x | x + 1].
func value: 1.

Answer 3

使用面向对象范式进行编程是通过将问题域实体识别和建模为对象来创建程序，然后使它们彼此协作以解决每个问题实例。 使用函数范式编程将问题建模为数学问题，并创建一个数学函数（通过组合其他函数），为每个问题实例计算问题解决方案。

在我看来，函数式编程语言是一种为使用函数式编程范式解决的问题提供解决方案的语言，该语言可以完全按照它的想法表达该解决方案。如果您需要“转换”解决方案的某些部分以使其适合语言可以表达的内容，那么它并不完全支持您过去思考解决方案的范式。

Smalltalk 在大多数情况下可以表达使用面向对象编程范式创建的所有解决方案，但它不能原始地表达使用函数式编程范式创建的许多解决方案。这就是为什么我不认为它是 FPL。 尽管最初无法表达 FPL 可以表达的所有解决方案，但 Smalltalk 具有极强的可扩展性，您可以将其扩展为能够表达 FPL 可以表达的所有解决方案。

Answer 4

Smalltalk 是一种纯粹的面向对象语言，其中几乎所有代码基本上都是对象交换消息。函数式编程面向函数调用和函数之间的组合，以创建更复杂的行为（避免数据的状态，而不是对象在任何面向对象语言中具有的内部状态）。

Answer 5

纯函数式语言通常具有不可变变量，使它们更像数学意义上的变量。

Answer 6

一种语言不会通过命名函数而成为函数式语言——根据这个定义，C 将是函数式的！更重要的是数学意义上的功能语义，结果仅取决于参数（特别是：没有副作用）。根据这个定义，可以由 setter 修改的对象与函数式编程风格相反。但是，正如已经指出的那样，如果您禁止副作用，即使对象也可以用于功能样式（矩形示例）。 而且，顺便说一句。具有方法的对象和在私有状态的闭包中定义的一组函数之间存在二元性（有关详细信息，请参阅 SICP）。他们可以互相模拟：

(def (make_foo initVal1 ... initValN)
   (let ((instVar1 initVal1) ... (instVarN initValN))
      (define (method1 args) ...)
      ...
      (define (methodN args) ...)
      (define (lookup selector)
          (cond ((eq? selector 'method1) method1)
             ...
             ((eq? selector 'methodN) methodN)
             (true doesNotUnderstandCode)))
      lookup)) ; returns the lookup function (provides "access into the closure") !

(defMacro (method1 receiver.args)
    ((receiver selector) args))

(define foo (make_foo 1 2 ...))
(method1 foo ...)

以上是“纯”功能对象的模拟，在语义上与很多 Smalltalk 代码相同！但是，要实现 setter 方法，您必须添加一个执行 (set!instVar newValue) 的方法。而且，因为设置！是非功能性的，破坏了方案的“功能性”。

总结：看语义，而不是来源，卢克！

Answer 7

谢谢大家的回答。

我会在这里添加我的，这基本上是我（可能错过）对你的理解。

我认为调用 OO 或 FP 的标准是使用语言构建“东西”的方式；我的意思是，使用的心理范式不是做它的难易程度。

例如，如链接所示，在 Scala 中输入某些内容可能比在 OCaml 中更难，但这并不会降低 FPL（可能不完整或不纯，但绝对是功能性的）；因为 Scala 的目标是使用函数作为主要构建块，而不是对象。

另一方面，如果风格或目的是使用其他工件，那么用一种语言编写函数并不容易。例如，Smalltalk 使得编写匿名块或提供可插入的排序比较器变得非常容易，但这根本不会使其具有任何功能，因为重点是使用对象和传递消息。闭包只是一种对这些消息（不是函数）进行编码的机制，即使它们看起来就像函数一样。

混乱来了，因为 OO 和 FP 是正交的（正如 Rahul 通过 twitter 所说），所以，它看起来像 Smalltalk 中的编码消息，看起来很像 Scala 中的匿名函数。但是做类似的事情并不会将一种范式的语言转换为另一种范式。

更糟糕的是，Scala 还使用了 OO 范式，以使主流（Java、C++、C#）程序员更容易实现跳跃，如果你看到，它比其他任何一个都取得了更大的成功FPL 做到了。当然，这要感谢 Java（恕我直言，如果 Clojure 取得任何成功，原因与 JVM 完全相同）

总结：一种编程语言可以根据它用来构建“事物”的范式进行分类。有些语言是纯粹的，例如 [Smalltalk：OO，Haskell：Functional，C：Procedural]，或者是混合语言，例如 Scala 或多范式，例如 C++、Ruby、Python。

你可以用另一种语言编写一种风格，但这并不能使它成为那种风格的语言。就像用 Lisp 模拟对象并不能使它成为 OO 一样，也不能在 Java 中使用函数使其成为函数式。

要回答这个问题，要被认为是功能性的，Smalltalk 需要使用函数作为构建块，因为它使用对象而不是这样。

Answer 8

我看到了两者之间的一些相似之处 Smalltalk 和 FPL，即闭包

还有一个更基本的相似之处 - 每条 Smalltalk 消息总是返回一个值。

但是现在看看Design Principles Behind Smalltalk

[Smalltalk] 发送名称 所需的操作，以及任何 参数，作为给数字的消息， 理解为 接收者最清楚如何执行 所需的操作。

这是否描述了您认为的函数式编程？

@Frank Shearar - 描述 Erlang 也。 Erlang 现在不能正常工作了吗？

Erlang 有点像一种嵌合体——顺序编程基于函数，而并发编程基于进程之间的消息传递。因此，Erlang 不是多范式或混合，因为其他语言允许使用不同的样式来实现相同的目的——它使用不同的样式来实现不同的目的。

Answer 9

需要考虑什么 这样？

• 一种声明函数的方式，而不是一种在类中声明方法的方式

• 一种围绕函数而非对象构建程序的方法

@Missing Faktor - 但在这个例子中不是命名的 功能？

|func v|
func := [:x | x + 1].
v := func value: 5.

否 func 是一个局部变量。您已将 an anonymous function 绑定到局部变量 func。

|func v|
func := [:x | x + 1].
func := 2.
v := func value: 5.

要查看区别，请查看this Erlang example，它同时显示了匿名函数和命名函数。