高阶函数有哪些有趣的用途？

Question

我目前正在学习函数式编程课程，我对高阶函数和一等公民函数的概念感到非常有趣。然而，我还想不出许多实际有用的、概念上令人惊奇的或只是简单有趣的高阶函数。 （除了典型且相当沉闷的 map、filter 等功能）。

你知道这样有趣的函数的例子吗？

也许是返回函数的函数、返回函数列表的函数（？）等等。

我很欣赏 Haskell 中的例子，这是我目前使用的语言学习 ：）

Answer 1

这是一个小的释义 代码 片段：

rays :: ChessPieceType -> [[(Int, Int)]]
rays Bishop = do
  dx <- [1, -1]
  dy <- [1, -1]
  return $ iterate (addPos (dx, dy)) (dx, dy)
...  -- Other piece types

-- takeUntilIncluding is an inclusive version of takeUntil
takeUntilIncluding :: (a -> Bool) -> [a] -> [a]

possibleMoves board piece = do
  relRay <- rays (pieceType piece)
  let ray = map (addPos src) relRay
  takeUntilIncluding (not . isNothing . pieceAt board)
    (takeWhile notBlocked ray)
  where
    notBlocked pos =
      inBoard pos &&
      all isOtherSide (pieceAt board pos)
    isOtherSide = (/= pieceSide piece) . pieceSide

这使用了几个“更高阶" 函数：

iterate :: (a -> a) -> a -> [a]
takeUntilIncluding  -- not a standard function
takeWhile :: (a -> Bool) -> [a] -> [a]
all :: (a -> Bool) -> [a] -> Bool
map :: (a -> b) -> [a] -> [b]
(.) :: (b -> c) -> (a -> b) -> a -> c
(>>=) :: Monad m => m a -> (a -> m b) -> m b

(.) 是 . 运算符，(>>=) 是 do - 符号“换行符”。

在 Haskell 中编程时，你只需使用它们。当您没有高阶函数时，您就会意识到它们有多么有用。

Answer 2

这是一种我还没有看到其他人提到过的模式，当我第一次了解到它时，它真的让我感到惊讶。考虑一个统计包，其中您有一个样本列表作为输入，并且您想要计算它们的一堆不同的统计数据（还有很多其他方法来激发这一点）。最重要的是，您有一个要运行的函数列表。你如何运行它们？

statFuncs :: [ [Double] -> Double ]
statFuncs = [minimum, maximum, mean, median, mode, stddev]

runWith funcs samples = map ($samples) funcs

这里发生了各种各样的高阶善良，其中一些已经在其他答案中提到过。但我想指出“$”功能。当我第一次看到“$”的这种用法时，我惊呆了。在此之前，除了作为括号的方便替代品之外，我并不认为它非常有用......但这几乎是神奇的......

Answer 3

一件有趣的事情，如果不是特别实用的话，就是教堂数字。这是一种仅使用函数来表示整数的方法。疯了，我知道。这是我制作的 JavaScript 实现。它可能比 Lisp/Haskell 实现更容易理解。 （但说实话，可能不是。JavaScript 并不是真正适合这种事情的。）

Answer 4

有人提到 Javascript 支持某些高阶函数，包括 Joel Spolsky 的一篇文章< /a>. Mark Jason Dominus 写了一整本书，名为 Higher–Order Perl；该书的源代码可以多种格式免费下载，包括 PDF。

至少从 Perl 3 开始，Perl 支持的功能更像是 Lisp，而不是 C，但直到 Perl 5 才完全支持闭包以及随之而来的所有功能。第一个 Perl 6 实现是用 Haskell 编写的，这对该语言的设计进展产生了很大的影响。

Perl 中函数式编程方法的示例出现在日常编程中，尤其是使用 map 和 grep 时：

@ARGV    = map { /\.gz$/ ? "gzip -dc < $_ |" : $_ } @ARGV;

@unempty = grep { defined && length } @many;

由于 sort 也允许闭包，因此 >map/sort/map 模式非常常见：

@txtfiles = map { $_->[1] }
            sort { 
                    $b->[0]  <=>     $a->[0]
                              ||
                 lc $a->[1]  cmp  lc $b->[1]
                              ||
                    $b->[1]  cmp     $a->[1]
            }
            map  { -s => $_ } 
            grep { -f && -T }
            glob("/etc/*");

或者

@sorted_lines = map { $_->[0] }
                sort {
                     $a->[4] <=> $b->[4] 
                             ||
                    $a->[-1] cmp $b->[-1]
                             ||
                     $a->[3] <=> $b->[3]
                             ||
                     ...
                }
                map { [$_ => reverse split /:/] } @lines;

reduce 函数使列表黑客变得容易而无需循环：

$sum = reduce { $a + $b } @numbers;

$max = reduce { $a > $b ? $a : $b } $MININT, @numbers;

还有更多，但这只是一种尝试。闭包可以轻松创建函数生成器，编写您自己的高阶函数，而不仅仅是使用内置函数。事实上，最常见的异常模型之一

try {
   something();
} catch {
   oh_drat();
};

不是内置的。然而，它几乎被简单地定义为一个带有两个参数的函数：第一个参数中的闭包和第二个参数中带有闭包的函数。

Perl 5 没有内置柯里化，尽管有一个模块。然而，Perl 6 内置了柯里化和一流的延续，还有更多。

Answer 5

好吧，您注意到 Haskell 没有 for 循环语法吗？没有 while 或 do 或 for。因为这些都只是高阶函数：

 map :: (a -> b) -> [a] -> [b]

 foldr :: (a -> b -> b) -> b -> [a] -> b

 filter :: (a -> Bool) -> [a] -> [a]

 unfoldr :: (b -> Maybe (a, b)) -> b -> [a]

 iterate :: (a -> a) -> a -> [a]

高阶函数取代了控制结构语言中内置语法的需要，这意味着几乎每个 Haskell 程序都使用这些函数 - 使它们非常有用！

它们是实现良好抽象的第一步，因为我们现在可以将自定义行为插入通用骨架函数中。

特别是，monad之所以成为可能，是因为我们可以链接在一起并操作函数来创建程序。

事实上，当生活处于一阶状态时，它是相当无聊的。只有当你拥有更高的阶数时，编程才会变得有趣。

Answer 6

面向对象编程中使用的许多技术都是缺乏高阶函数的解决方法。

这包括许多在函数式编程中普遍存在的设计模式。例如，访问者模式是实现折叠的相当复杂的方法。解决方法是创建一个带有方法的类，并传入该类的元素作为参数，以代替传入函数。

策略 模式是另一个方案示例，该方案经常将对象作为参数传递，以代替实际预期的函数。

类似地，依赖注入通常涉及一些笨拙的方案来传递函数代理，而简单地传递函数通常会更好直接作为参数。

所以我的答案是，高阶函数通常用于执行与 OO 程序员执行的相同类型的任务，但直接使用，并且样板代码少得多。

Answer 7

当我了解到函数可以成为数据结构的一部分时，我真正开始感受到它的力量。这是一个“消费者 monad”（技术问题：(i ->) 上的免费 monad）。

data Coro i a
    = Return a
    | Consume (i -> Coro i a)

因此，Coro 可以立即产生一个值，或者根据某些输入成为另一个 Coro。例如，这是一个 Coro Int Int：

Consume $ \x -> Consume $ \y -> Consume $ \z -> Return (x+y+z)

它消耗三个整数输入并返回它们的总和。您还可以让它根据输入有不同的行为：

sumStream :: Coro Int Int
sumStream = Consume (go 0)
    where
    go accum 0 = Return accum
    go accum n = Consume (\x -> go (accum+x) (n-1))

这会消耗一个 Int，然后在产生它们的总和之前消耗更多的 Int。这可以被认为是一个接受任意多个参数的函数，其构造没有任何语言魔法，只是高阶函数。

数据结构中的函数是一个非常强大的工具，在我开始使用 Haskell 之前，它并不属于我的词汇范围。

Answer 8

查看论文 'Even High-Order Functions for Parsing 或 Why Will任何人都想
使用六阶函数？' 作者：Chris Okasaki。它是使用 ML 编写的，但这些想法同样适用于 Haskell。

Answer 9

Joel Spolsky 写了一篇著名文章，展示了如何Map-Reduce 使用 Javascript 的高阶函数进行工作。对于任何提出这个问题的人来说，这都是必读的。

Answer 10

Haskell 随处使用的柯里化也需要高阶函数。本质上，接受两个参数的函数相当于接受一个参数的函数并返回另一个接受一个参数的函数。当你在 Haskell 中看到这样的类型签名时：

f :: A -> B -> C

...(->) 可以被解读为右关联，表明这实际上是一个返回函数的高阶函数输入 B -> C：

f :: A -> (B -> C)

两个参数的非柯里化函数将具有如下类型：

f' :: (A, B) -> C

因此，每当您在 Haskell 中使用部分应用程序时，您都在使用高阶函数。

Answer 11

Martín Escardó 提供了一个有趣的高阶函数示例:

equal :: ((Integer -> Bool) -> Int) -> ((Integer -> Bool) -> Int) -> Bool

给定两个泛函 f, g :: (Integer -> Bool) -> Int，然后 equal f g 决定 f 和 g 是否（扩展地）相等，即使 f< /code> 和 g 没有有限域。事实上，余域 Int 可以替换为任何具有可判定相等性的类型。

Escardó 给出的代码是用 Haskell 编写的，但相同的算法应该适用于任何函数式语言。

您可以使用 Escardó 描述的相同技术以任意精度计算任何连续函数的定积分。

Answer 12

您可以做的一件有趣且有点疯狂的事情是使用函数模拟面向对象的系统并将数据存储在函数的范围内（即在闭包中）。它是高阶的，因为对象生成器函数是返回对象的函数（另一个函数）。

我的 Haskell 相当生疏，所以我不能轻易给你一个 Haskell 示例，但这里有一个简化的 Clojure 示例，希望能够传达这个概念：

(defn make-object [initial-value]
  (let [data (atom {:value initial-value})]
      (fn [op & args]
        (case op 
          :set (swap! data assoc :value (first args))
          :get (:value @data)))))

用法：

(def a (make-object 10))

(a :get)
=> 10

(a :set 40)

(a :get)
=> 40

相同的原理在 Haskell 中也适用（除了你可能需要更改 set 操作）返回一个新函数，因为 Haskell 是纯函数式的）

Answer 13

我特别喜欢高阶记忆化：（

memo :: HasTrie t => (t -> a) -> (t -> a)

给定任何函数，返回该函数的记忆化版本。受限于函数的参数必须能够编码到 trie 中的事实。）

这来自 < a href="http://hackage.haskell.org/package/MemoTrie" rel="nofollow">http://hackage.haskell.org/package/MemoTrie

Answer 14

这里有几个例子： http://www.haskell.org/haskellwiki/Higher_order_function

我会还推荐这本书：http://www.cs.nott.ac.uk/~gmh/book.html 这是对所有 Haskell 的精彩介绍，涵盖了高阶函数。

高阶函数通常使用累加器，因此可以在从较大列表中形成符合给定规则的元素列表时使用。