函数式编程最好/最差解决哪些问题？

Question

我经常听说函数式编程解决了很多过程式/命令式编程中难以解决的问题。但我也听说它不擅长处理程序编程天生擅长的其他一些问题。

在我打开关于 Haskell 的书并深入研究函数式编程之前，我想至少了解一下我真正可以将它用于什么的基本概念（除了书中的示例）。那么，函数式编程擅长什么？有哪些不适合的问题？

更新

到目前为止，我已经得到了一些很好的答案。我等不及要开始学习 Haskell 了——我只需要等到我掌握 C :)

函数式编程之所以伟大的原因：

• 非常简洁明了 - 它可以用简短、清晰的语句表达复杂的想法。
• 比命令式语言更容易验证 - 在系统中的安全性至关重要的情况下很好。
• 函数的纯粹性和数据的不变性使并发编程更加合理。
• 非常适合编写脚本和编写编译器（但我很想知道原因）。
• 数学相关的问题解决得简单又漂亮。

函数式编程难以解决的领域：

• 值得商榷：网络应用程序（虽然我猜这取决于应用程序）。
• 桌面应用程序（虽然它可能取决于语言，但 F# 会擅长这不是吗？）。
• 任何对性能至关重要的事物，例如游戏引擎。
• 任何涉及大量程序状态的事物。

Answer 1

由于higher level functions (map, lfold, grep) 和type inference 的存在，函数式编程擅长简洁。

generic programming 也很出色，出于同样的原因，这进一步提高了用简短的语句表达复杂想法而不会混淆的能力。

我很欣赏这些属性，因为它们使interactive programming 合理。 （例如R、SML）。

我怀疑函数式编程也比其他编程方法更容易验证，这在安全关键系统（核电站和医疗设备）中是有利的。

Answer 2

我会说函数式编程适合解决问题，例如AI 问题、数学问题（这太容易了）、游戏引擎，但不太适合 GUI 和自定义控件开发或需要精美 UI 的桌面应用程序。我发现以以下方式思考很直观（尽管它可能过于笼统）：

            Back-end   Front-end
Low-level   C          C++
High-level  FP         VB, C#

Answer 3

函数式编程适合并行编程。您不依赖函数式编程的状态更改这一事实意味着各种处理器/内核不会相互影响。因此，能够很好地适应并行性的算法类型，如压缩、图形效果和一些复杂的数学任务，通常也很适合函数式编程。而多核 CPU 和 GPU 越来越受欢迎的事实也意味着对这类东西的需求将会增长。

Answer 4

它可能与函数式编程没有直接关系，但在数据结构的设计和实现中没有什么比联合更好的了。让我们比较两段等效的代码：

F#：

type 'a stack = Cons of 'a * stack |零 让 rec to_seq = 函数 |无 -> Seq.empty; |缺点（hd，tl）-> seq { yield hd;屈服！ to_seq tl } 让 rec 附加 x y = 将 x 与 |无 -> 是 | Cons(hd, tl) -> Cons(hd, append tl y) 让 x = Cons(1, Cons(2, Cons(3, Cons(4, Nil)))) 让 y = Cons(5, Cons(6, Cons(7, Cons(8, Nil)))) 让 z = 附加 x y to_seq z |> Seq.iter (fun x -> printfn "%i" x)

Java：

interface IStack<T> extends Iterable<T>
{
    IStack<T> Push(T value);
    IStack<T> Pop();
    T Peek();
    boolean IsEmpty();
}
final class EmptyStack<T> implements IStack<T>
{
    public boolean IsEmpty() { return true; }
    public IStack<T> Push(T value) { return Stack.cons(value, this); }
    public IStack<T> Pop() { throw new Error("Empty Stack"); }
    public T Peek() { throw new Error("Empty Stack"); }
    public java.util.Iterator<T> iterator()
    {
        return new java.util.Iterator<T>()
        {
            public boolean hasNext() { return false; }
            public T next() { return null; }
            public void remove() { }
        };
    }
}
final class Stack<T> implements IStack<T>
{
    public static <T> IStack<T> cons(T hd, IStack<T> tl) { return new Stack<T>(hd, tl); }
    public static <T> IStack<T> append(IStack<T> x, IStack<T> y)
    {
        return x.IsEmpty() ? y : new Stack(x.Peek(), append(x.Pop(), y));
    }
    private final T hd;
    private final IStack<T> tl;
    private Stack(T hd, IStack<T> tl)
    {
        this.hd = hd;
        this.tl = tl;
    }
    public IStack<T> Push(T value) { return new <T> Stack(value, this); }
    public IStack<T> Pop() { return this.tl; }
    public T Peek() { return this.hd; }
    public boolean IsEmpty() { return false; }
    public java.util.Iterator<T> iterator()
    {
        final IStack<T> outer = this;
        return new java.util.Iterator<T>()
        {
            private IStack<T> current = outer;
            public boolean hasNext() { return !current.IsEmpty(); }
            public T next()
            {
                T hd = current.Peek();
                current = current.Pop();
                return hd;
            }
            public void remove() { }
        };
    }
}
public class Main
{
    public static void main(String[] args)
    {
        IStack<Integer> x = Stack.cons(1, Stack.cons(2, Stack.cons(3, Stack.cons(4, new EmptyStack()))));
        IStack<Integer> y = Stack.cons(5, Stack.cons(6, Stack.cons(7, Stack.cons(8, new EmptyStack()))));
        IStack<Integer> z = Stack.append(x, y);

        for (Integer num : z)
        {
            System.out.printf("%s ", num);
        }
    }
}

Answer 5

我发现函数式编程适合的一些问题：

• 并发
• 编译器
• 脚本

我个人认为不太适合的问题：

• Web 应用程序（但这可能只是我，Hacker News 例如在 LISP 中实现）
• 桌面应用程序
• 游戏引擎
• 你在很多州之间传递的东西

Answer 6

我发现 Haskell 非常适合做任何与数学相关的事情。并不是说这是一个真正的专业项目，而是我用它制作了一个数独求解器和扑克分析器。拥有一个在数学上可证明的程序很棒。

就它不适合的任何事情而言，性能是优先考虑的事情。您对所使用的算法的控制较少，因为它更具声明性而不是命令性。

Answer 7

我不同意 FP 不能用于 Web 应用程序。我知道 Paul Grahm 和 Robert Morris 创立了使用 Lisp 交付 Web 应用程序的 Viaweb。我认为随着您更接近硬件（设备驱动程序、内核等），人们希望尽可能使用低级语言。这是因为如果使用更多的抽象，那么在出现错误时更难调试。查看 Joel Spolsky 的文章“泄漏抽象定律”。

Answer 8

实际上，我喜欢使用纯函数式代码来解决需要管理大量状态的问题。这些语言倾向于为显式处理状态提供最佳机制，因为它们不允许您隐式执行。在小范围内隐式管理状态似乎更容易，但是一旦状态开始变得复杂，您就会遇到麻烦，而无法通过 FP 方式来保证正确性。

Answer 9

我发现使用矩阵数学来解决数学问题的函数式编程的简单性绝对是美妙的，看看这些类型的问题在 Scheme 中是如何解决的！

Answer 10

我会说函数式编程对于低级的东西、操作系统内核、设备驱动程序等都会有问题。

我说的是“有麻烦”，而不是“不能用”（因为图灵等价，任何东西都可以用于任何事情）。

一个有趣的问题是这个问题是否是函数式编程的基础（因为物理设备具有状态），或者我们是否可以想象面向系统的函数式编程语言/环境。例如，BitC 只是部分功能（它在很大程度上依赖于可变性）。

Answer 11

函数式和面向对象的范式具有正交强度。 您可以说函数式编程强调动词和面向对象的名词编程。 或者，更实际地说： 面向对象使添加新数据变得简单，而函数式编程使添加新工具变得简单。 两者都需要更改代码以实现另一个目标。 您想阅读http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.18.4525&rep=rep1&type=pdf（综合面向对象和函数式设计以促进重用