什么是高阶函数的一些有趣用途？

Question

我目前正在做一个函数式编程课程，我很高兴作为一等公民的高阶函数和函数的概念。但是，我还不能想到许多实际上有用的，概念上的惊人的，或者仅仅是简单有趣的高阶函数。 （除了典型的而非沉闷的map,filter等功能）。

你知道这些有趣功能的例子吗？

也许函数返回函数，函数返回的功能列表（？）等

我很感激在Haskell，这是我目前正在学习:)

Answer 1

那么，你注意到Haskell没有语法循环？否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] 

高阶函数替换需要在控制结构的语言烤语法，这意味着几乎每一个哈斯克尔程序使用这些功能 - 这使他们非常有用！

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

尤其是，monads只有可能，因为我们可以链接在一起，并操纵功能，创建程序。

事实是，当生命是一阶时，生活是相当无聊的。一旦你有更高的订单，编程只会变得有趣。

Answer 2

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

我也推荐这本书：http://www.cs.nott.ac.uk/~gmh/book.html这是一个很好的介绍所有的哈斯克尔和涵盖更高阶的功能。

高阶函数经常使用累加器，所以在形成符合给定规则的元素列表时，可以使用累加器从一个更大的列表中使用。

Answer 3

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

f :: A -> B -> C 

...的(->)可以解读为右结合，可见这实际上是一个高阶函数返回B -> C类型的函数：

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

的两个参数，一个非咖喱功能将改为有型是这样的：

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

因此，任何时候你用在Haskell部分应用程序，你正在使用更高阶的函数。

Answer 4

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

我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中工作（除了您可能需要更改设置操作以返回一个新函数，因为Haskell是纯功能的）

Answer 5

检查出pa根据Chris Okasaki的'Even Higher-Order Functions for Parsing or Why Would Anyone Ever Want To Use a Sixth-Order Function?'。它使用ML编写，但这些想法同样适用于Haskell。

Answer 6

当我学会了一个函数可以成为数据结构的一部分的时候，我真的开始感受到这种力量。这是一个“消费者monad”（技术可能性：免费monad (i ->)）。

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

所以一个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，然后消耗了产生它们的和以前更多的INTS。这可以被认为是一个函数，它可以采用任意多个参数，而不需要任何语言魔法，而只需要更高阶的函数。

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

Answer 7

这里有一个小意译code片段：

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 -notation“断行运营商”。

在Haskell中编程时，只需使用它们。如果你没有更高级的功能，那么当你意识到它们有多么非常有用时。

Answer 8

面向对象编程中使用的许多技术是缺少高阶函数的变通方法。

这包括在函数式编程中无处不在的design patterns的数字。例如，访客模式是实现fold的一种相当复杂的方式。解决方法是使用方法创建一个类，并将该类的元素作为参数传入，作为传递函数的替代方法。

strategy模式是一个方案的另一个例子，该方案经常将对象作为参数传递，以替代实际打算使用的函数。

类似地dependency injection通常会涉及一些笨拙的方案来传递函数的代理函数，因为通常直接将函数直接作为参数传递会更好。

所以我的答案是高阶函数通常用于执行面向对象编程人员执行的相同类型的任务，但直接而且使用更少的样板。

Answer 9

Joel Spolsky写了一个famous essay演示Map-Reduce如何使用Javascript的高阶函数工作。任何提出这个问题的人都必须阅读。

Answer 10

有趣的是，如果不是特别实用，有一件事是Church Numerals。这是一种只用函数表示整数的方法。疯狂，我知道。 < shamelessPlug>这是我制作的implementation in JavaScript。它可能比Lisp/Haskell实现更容易理解。 （但可能不是，说实话，JavaScript并不是真正意义上的这种东西。）</shamelessPlug>

Answer 11

这里有一种模式，我还没有看到其他人提到，但第一次真的让我感到吃惊我了解了它。考虑一个统计软件包，其中有一个样本列表作为输入，并且您想计算一系列不同的统计数据（还有很多其他方法可以用来激发这一点）。底线是你有一个你想运行的功能列表。你如何运行它们？

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

runWith funcs samples = map ($samples) funcs 

有各种各样的高阶善良在这里进行，其中一些已在其他答案中提到。但我想指出'$'功能。当我第一次看到'$'的使用时，我被吹走了。在此之前，我从来没有认为这是不是作为一个方便的替代括号中是非常有用的其他...但是这几乎是不可思议......

Answer 12

我高阶记忆化的特定风扇：

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

（考虑任何函数，返回功能的事实，该函数的参数必须能够被编码到特里有限公司的memoized版本）。

这是http://hackage.haskell.org/package/MemoTrie

Answer 13

有人提到，JavaScript支持某些高阶功能，包括an essay from Joel Spolsky。马克杰森多米诺斯写了一本名为Higher–Order Perl的全书;本书的源代码可以免费下载到各种精细格式，包括PDF。

自从至少Perl 3以来，Perl支持的功能更多地让人联想到Lisp而不是C，但直到Perl 5完全支持闭包以及所有后续的功能才可用。第一个Perl 6实现的ne是用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(); 
}; 

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

Perl 5没有currying内置，虽然有一个模块。不过，Perl 6具有内置的柯里化和一流的延续，还有更多。

Answer 14

马丁Escardó提供an interesting example of a higher-order function：

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

给定两个函f, g :: (Integer -> Bool) -> Int，然后equal f g决定是否f和g是（外延上）等于或不，即使f和g没有一个有限区域。事实上，共域，Int，可以用任何可判定的等式来替换。

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

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