过程性语言倾向于跟踪状态(使用变量)，并倾向于按步骤序列执行。纯函数式语言不跟踪状态，使用不可变值，并倾向于作为一系列依赖项执行。在许多情况下，调用堆栈的状态所保存的信息与过程代码中存储在状态变量中的信息相同。

递归是函数式编程的一个经典例子。

我相信过程式/函数式/目标式编程是关于如何处理问题的。

The first style would plan everything in to steps, and solves the problem by implementing one step (a procedure) at a time. On the other hand, functional programming would emphasize the divide-and-conquer approach, where the problem is divided into sub-problem, then each sub-problem is solved (creating a function to solve that sub problem) and the results are combined to create the answer for the whole problem. Lastly, Objective programming would mimic the real world by create a mini-world inside the computer with many objects, each of which has a (somewhat) unique characteristics, and interacts with others. From those interactions the result would emerge.

每种编程风格都有自己的优点和缺点。因此，做一些诸如“纯编程”(即纯粹的程序设计——顺便说一下，没有人会这样做，这有点奇怪——或纯粹的函数式或纯粹的目标)是非常困难的，如果不是不可能的话，除了一些专门设计来展示编程风格优势的基本问题(因此，我们称那些喜欢纯粹的人为“weenie”:D)。

Then, from those styles, we have programming languages that is designed to optimized for some each style. For example, Assembly is all about procedural. Okay, most early languages are procedural, not only Asm, like C, Pascal, (and Fortran, I heard). Then, we have all famous Java in objective school (Actually, Java and C# is also in a class called "money-oriented," but that is subject for another discussion). Also objective is Smalltalk. In functional school, we would have "nearly functional" (some considered them to be impure) Lisp family and ML family and many "purely functional" Haskell, Erlang, etc. By the way, there are many general languages such as Perl, Python, Ruby.

基本上这两种风格，就像阴阳。一个是有组织的，而另一个是混乱的。在某些情况下，函数式编程是显而易见的选择，而在其他情况下，过程式编程是更好的选择。这就是为什么至少有两种语言最近推出了新版本，包含了这两种编程风格。(Perl 6和d2)

#程序:#

例程的输出并不总是与输入直接相关。 每件事都有特定的顺序。 例程的执行可能有副作用。 倾向于强调以线性方式实现解决方案。

##Perl 6 ##

sub factorial ( UInt:D $n is copy ) returns UInt {

  # modify "outside" state
  state $call-count++;
  # in this case it is rather pointless as
  # it can't even be accessed from outside

  my $result = 1;

  loop ( ; $n > 0 ; $n-- ){

    $result *= $n;

  }

  return $result;
}

2 # # # # D

int factorial( int n ){

  int result = 1;

  for( ; n > 0 ; n-- ){
    result *= n;
  }

  return result;
}

#功能:#

通常递归。 对于给定的输入总是返回相同的输出。 计算的顺序通常是不确定的。 必须是无状态的。即任何手术都不能有副作用。 很适合并行执行 倾向于强调分而治之的方法。 可具有惰性求值的特性。

哈斯克尔# # # # (摘自维基百科);

fac :: Integer -> Integer

fac 0 = 1
fac n | n > 0 = n * fac (n-1)

或者在一行中:

fac n = if n > 0 then n * fac (n-1) else 1

##Perl 6 ##

proto sub factorial ( UInt:D $n ) returns UInt {*}

multi sub factorial (  0 ) { 1 }
multi sub factorial ( $n ) { $n * samewith $n-1 } # { $n * factorial $n-1 }

2 # # # # D

pure int factorial( invariant int n ){
  if( n <= 1 ){
    return 1;
  }else{
    return n * factorial( n-1 );
  }
}

#注:#

阶乘实际上是一个常见的示例，它展示了在Perl 6中创建新的操作符有多么容易，就像创建子例程一样。这个特性在Perl 6中根深蒂固，以至于Rakudo实现中的大多数操作符都是以这种方式定义的。它还允许您将自己的多个候选操作符添加到现有操作符。

sub postfix:< ! > ( UInt:D $n --> UInt )
  is tighter(&infix:<*>)
  { [*] 2 .. $n }

say 5!; # 120␤

这个例子还展示了范围创建(2..$n)和列表缩减元操作符([OPERATOR] list)与数字中缀乘法操作符的结合。(*) 它还表明，您可以在签名中放入——> UInt，而不是在签名后返回UInt。

(你可以用2开始范围，因为乘法“运算符”在不带任何参数的情况下调用时将返回1)

我在这里没有看到真正强调的一点是，现代函数语言(如Haskell)实际上更多地关注流控制的第一类函数，而不是显式递归。您不需要像上面那样在Haskell中递归地定义阶乘。我想是这样的

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

是一个完美的惯用结构，在精神上更接近于使用循环，而不是使用显式递归。

@Creighton:

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

prouduct list = foldr 1 (*) list

或者仅仅是:

product = foldr 1 (*)

惯用语的阶乘

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

很简单

fac n = product [1..n]

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

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

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

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

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