函数式编程和非函数式编程

Question

在我大学的第二年，我们“教”了 Haskell，我对它几乎一无所知，对函数式编程更是一无所知。

什么是函数式编程，为什么和/或我想在哪里使用它而不是非函数式编程，我认为 C 是一种非函数式编程语言是否正确？

Answer 1

函数式语言的一个关键特性是一等函数的概念。 这个想法是您可以将函数作为参数传递给其他函数并将它们作为值返回。

函数式编程涉及编写不改变状态的代码。 这样做的主要原因是连续调用一个函数会产生相同的结果。 您可以使用支持一流函数的任何语言编写函数代码，但有些语言（如 Haskell）不允许您更改状态。 事实上，您根本不应该产生任何副作用（如打印文本）——这听起来可能完全没用。

相反，Haskell 采用了一种不同的 IO 方法：monads。 这些对象包含由解释器的顶层执行的所需 IO 操作。 在任何其他级别，它们只是系统中的对象。

函数式编程有哪些优势？ 函数式编程允许以较少的潜在错误进行编码，因为每个组件都是完全隔离的。 此外，使用递归和一等函数允许简单的正确性证明，这通常反映了代码的结构。

Answer 2

什么是函数式编程

今天常用的“函数式编程”有两种不同的定义：

较旧的定义（源自 Lisp）是函数式编程是关于使用一等函数进行编程，即函数被视为任何其他值，因此您可以将函数作为参数传递给其他函数，并且函数可以在其返回值中返回函数。 这最终导致使用高阶函数，例如map和reduce （您可能听说过mapReduce作为 Google 大量使用的单个操作， mapReduce ，它是一个近亲！）。 .NET 类型System.Func和System.Action使高阶函数在 C# 中可用。 尽管柯里化在 C# 中不切实际，但接受其他函数作为参数的函数很常见，例如Parallel.For函数。

较年轻的定义（由 Haskell 流行）是，函数式编程也是关于最小化和控制副作用，包括变异，即编写通过组合表达式解决问题的程序。 这通常被称为“纯函数式编程”。 这是通过对称为“纯功能数据结构”的数据结构的截然不同的方法实现的。 一个问题是，将传统的命令式算法转换为使用纯函数式数据结构通常会使性能下降 10 倍。 Haskell 是唯一幸存的纯函数式编程语言，但这些概念已经通过 .NET 上的Linq等库渗透到主流编程中。

我想在哪里使用它而不是非函数式编程

到处。 C# 中的 Lambdas 现在已经展示了主要的好处。 C++11 有 lambda。 现在没有理由不使用高阶函数。 如果您可以使用像 F# 这样的语言，您还将受益于类型推断、自动泛化、柯里化和部分应用（以及许多其他语言功能！）。

我认为 C 是一种非函数式编程语言是否正确？

是的。 C 是一种过程语言。 但是，您可以通过在 C 中使用函数指针和void *来获得函数式编程的一些好处。

Answer 3

最近在 CoDe Mag 上发表的关于F#“101”的这篇文章可能值得一看。

此外，达斯汀·坎贝尔( Dustin Campbell) 有一个很棒的博客，在那里他发布了许多关于他在快速上 F# 方面的冒险经历的文章。

我希望你觉得这些有用:)

编辑：

另外，补充一点，我对函数式编程的理解是，一切都是函数或函数的参数，而不是实例/有状态对象。有时间！ :)

Answer 4

John the Statistician 的示例代码没有展示函数式编程，因为当你进行函数式编程时，关键是代码没有赋值（ record = thingConstructor(t)是赋值），并且它没有localMap.put(record) （ localMap.put(record)是一个有副作用的语句）。 does is fully captured by its arguments and its return value.由于这两个约束，所做的一切都完全由其参数和返回值捕获。 如果您想使用 C++ 模拟函数式语言，请按照其外观的方式重写 Statistician 的代码：

RT getOrCreate(const T thing, 
                  const Function<RT<T>> thingConstructor, 
                  const Map<T,RT<T>> localMap) {
    return localMap.contains(t) ?
        localMap.get(t) :
        localMap.put(t,thingConstructor(t));
}

), and every statement is an expression.作为无副作用规则的结果，每条语句都是返回值的一部分（因此return），并且每条语句都是一个表达式。 statement behaves like C++'s ?: operator.在强制执行函数式编程的语言中，隐含了return关键字，并且语句的行为类似于 C++ 的?:运算符。

and return it, instead of modifying the original , the way a normal C++ or Java program would.此外，一切都是不变的，所以localMap.put必须创建的新副本，并返回它，而不是修改原始途中正常的C ++或将Java程序。 根据 localMap 的结构，副本可以重新使用指向原始的指针，从而减少必须复制的数据量。

函数式编程的一些优点包括函数式程序更短，更容易修改函数式程序（因为没有考虑隐藏的全局效应），并且更容易使程序正确第一名。

但是，函数式程序往往运行缓慢（因为它们必须进行所有复制），并且它们与处理内存地址、小端字节序的其他程序、操作系统进程或操作系统的交互往往不佳字节块和其他特定于机器的非功能位。 非互操作性的程度往往与功能纯度的程度和类型系统的严格程度成反比。

更流行的函数式语言有非常非常严格的类型系统。 在 OCAML 中，您甚至不能混合整数和浮点数学，或使用相同的运算符（+ 用于添加整数，+. 用于添加浮点数）。 这可能是优势也可能是劣势，这取决于您对类型检查器捕获某些类型错误的能力的重视程度。

函数式语言也往往具有非常大的运行时环境。 Haskell 是一个例外（GHC 可执行文件几乎和 C 程序一样小，无论是在编译时还是运行时），但 SML、Common Lisp 和 Scheme 程序总是需要大量内存。

Answer 5

是的，您认为 C 是一种非函数式语言是正确的。 C 是一种过程语言。

Answer 6

我更喜欢使用函数式编程来节省自己的重复工作，通过制作一个更抽象的版本然后使用它来代替。 让我举个例子吧。 在 Java 中，我经常发现自己创建映射来记录结构，从而编写 getOrCreate 结构。

SomeKindOfRecord<T> getOrCreate(T thing) { 
    if(localMap.contains(thing)) { return localMap.get(thing); }
    SomeKindOfRecord<T> record = new SomeKindOfRecord<T>(thing);
    localMap = localMap.put(thing, record);
    return record; 
}

这种情况经常发生。 现在，我可以用函数式语言编写

RT<T> getOrCreate(T thing, 
                  Function<RT<T>> thingConstructor, 
                  Map<T,RT<T>> localMap) {
    if(localMap.contains(thing)) { return localMap.get(thing); }
    RT<T> record = thingConstructor(thing);
    localMap = localMap.put(thing,record);
    return record; 
}

而且我再也不用写一个新的了，我可以继承它。 但我可以做得比继承更好，我可以在这个东西的构造函数中说

getOrCreate = myLib.getOrCreate(*,
                                SomeKindOfRecord<T>.constructor(<T>), 
                                localMap);

（其中 * 是一种“让这个参数保持打开状态”的符号，这是一种柯里化）

然后本地 getOrCreate 完全相同，如果我在一行中写出整件事，没有继承依赖。

Answer 7

如果您正在寻找有关 F# 的好文章

Expert F#由 Don Syme 共同编写。 F#的创造者。 他专门研究 .NET 中的泛型，以便他可以创建 F#。

F# 以 OCaml 为模型，因此任何 OCaml 文本也将帮助您学习 F#。

Answer 8

我发现什么是函数式编程？ 有用

函数式编程是关于编写纯函数，关于尽可能去除隐藏的输入和输出，以便我们的代码尽可能多地描述输入和输出之间的关系。

when参数when喜欢显式

public Program getProgramAt(TVGuide guide, int channel, Date when) {
  Schedule schedule = guide.getSchedule(channel);

  Program program = schedule.programAt(when);

  return program;
}

超过

public Program getCurrentProgram(TVGuide guide, int channel) {
  Schedule schedule = guide.getSchedule(channel);

  Program current = schedule.programAt(new Date());

  return current;
}

函数式语言积极反对副作用。 副作用是复杂性，复杂性是错误，而错误是魔鬼。 函数式语言也将帮助您对抗副作用。