@Creighton:

在Haskell中有一个叫做product的库函数:

prouduct list = foldr 1 (*) list

或者仅仅是:

product = foldr 1 (*)

惯用语的阶乘

fac n = foldr 1 (*)  [1..n]

很简单

fac n = product [1..n]

函数式语言(理想情况下)允许您编写一个数学函数，即接受n个参数并返回一个值的函数。如果程序被执行，这个函数将根据需要在逻辑上求值

另一方面，过程式语言执行一系列连续的步骤。(有一种将顺序逻辑转换为函数逻辑的方法，称为连续传递样式。)

因此，纯函数式程序总是对输入产生相同的值，求值的顺序没有很好的定义;这意味着像用户输入或随机值这样的不确定值很难用纯函数式语言建模。

就像这个答案中的其他内容一样，这是一种概括。这个属性，在需要计算结果的时候计算，而不是在调用它的时候按顺序计算，被称为“懒惰”。并不是所有的函数式语言都是懒惰的，懒惰也不仅仅局限于函数式编程。相反，这里给出的描述提供了一个“心理框架”，用于思考不同的编程风格，这些风格不是不同的、相反的类别，而是流动的想法。

进一步阐述康拉德的评论:

因此，纯函数式程序总是对输入产生相同的值，求值的顺序没有很好的定义;

因此，函数式代码通常更容易并行化。由于函数(通常)没有副作用，并且它们(通常)只是作用于它们的参数，因此许多并发问题都消失了。

当您需要能够证明您的代码是正确的时，也可以使用函数式编程。这在过程式编程中要困难得多(在函数式编程中不容易，但仍然容易)。

免责声明:我已经很多年没有使用函数式编程了，直到最近才开始重新研究它，所以我在这里可能不完全正确。：）

过程式编程将语句序列和条件构造划分为单独的块，称为过程，这些块通过参数化(非函数式)值。

函数式编程与此类似，只是函数是一类值，因此它们可以作为参数传递给其他函数，并作为函数调用的结果返回。

注意，在这个解释中，函数式编程是过程式编程的泛化。然而，少数人将“函数式编程”解释为没有副作用，这与除Haskell之外的所有主要函数式语言都完全不同，但无关紧要。

这里没有一个答案显示了惯用的函数式编程。递归阶乘的答案很适合在FP中表示递归，但大多数代码不是递归的，所以我不认为这个答案是完全具有代表性的。

假设你有一个字符串数组，每个字符串表示一个整数，比如“5”或“-200”。您希望根据内部测试用例检查这个输入字符串数组(使用整数比较)。两种解决方案如下所示

程序上的

arr_equal(a : [Int], b : [Str]) -> Bool {
    if(a.len != b.len) {
        return false;
    }

    bool ret = true;
    for( int i = 0; i < a.len /* Optimized with && ret*/; i++ ) {
        int a_int = a[i];
        int b_int = parseInt(b[i]);
        ret &= a_int == b_int;  
    }
    return ret;
}

功能

eq = i, j => i == j # This is usually a built-in
toInt = i => parseInt(i) # Of course, parseInt === toInt here, but this is for visualization

arr_equal(a : [Int], b : [Str]) -> Bool =
    zip(a, b.map(toInt)) # Combines into [Int, Int]
   .map(eq)
   .reduce(true, (i, j) => i && j) # Start with true, and continuously && it with each value

虽然纯函数式语言通常是研究语言(因为现实世界喜欢免费的副作用)，但现实世界的过程式语言在适当的时候会使用更简单的函数式语法。

这通常是用Lodash这样的外部库实现的，或者是用Rust这样的新语言内置的。函数式编程的繁重工作是通过map、filter、reduce、currying、partial等函数/概念完成的，最后三个你可以查阅以进一步理解。

齿顶高

In order to be used in the wild, the compiler will normally have to work out how to convert the functional version into the procedural version internally, as function call overhead is too high. Recursive cases such as the factorial shown will use tricks such as tail call to remove O(n) memory usage. The fact that there are no side effects allows functional compilers to implement the && ret optimization even when the .reduce is done last. Using Lodash in JS, obviously does not allow for any optimization, so it is a hit to performance (Which isn't usually a concern with web development). Languages like Rust will optimize internally (And have functions such as try_fold to assist && ret optimization).

如果你有机会，我建议你买一份Lisp/Scheme，然后用它来做一些项目。最近流行起来的大多数思想都是在几十年前用Lisp表达的:函数式编程、延续(作为闭包)、垃圾收集，甚至XML。

所以这将是一个很好的方法来开始所有这些当前的想法，以及一些其他的，比如符号计算。

您应该知道函数式编程擅长什么，不擅长什么。它并不是什么都好。有些问题最好用副作用来表达，同样的问题会根据提问的时间给出不同的答案。