标签: higher-order-functions

假设我有

val foo : Seq[Double] = ...
val bar : Seq[Double] = ...

我希望产生一个seq,其中baz(i)= foo(i)+ bar(i).我能想到的一种方法是

val baz : Seq[Double] = (foo.toList zip bar.toList) map ((f: Double, b : Double) => f+b)

然而,这感觉既丑陋又低效 - 我必须将seqs转换为列表(使用惰性列表进行爆炸),创建此临时元组列表,仅映射它并让它进行GCed.也许溪流解决了懒惰的问题,但无论如何,这感觉就像不必要的丑陋.在lisp中,map函数将映射多个序列.我会写的

(mapcar (lambda (f b) (+ f b)) foo bar)

并且不会在任何地方创建临时列表.在Scala中是否存在map-over-multiple-lists函数,或者zip是否与解构相结合实际上是"正确"的方法？

在Scala中进行功能编程时,我遇到了这个问题:

你可以在foldRight方面正确折叠左边吗？反过来怎么样？

在作者提供的解决方案中,他们提供了如下实现:

def foldRightViaFoldLeft_1[A,B](l: List[A], z: B)(f: (A,B) => B): B = 
    foldLeft(l, (b:B) => b)((g,a) => b => g(f(a,b)))(z)

  def foldLeftViaFoldRight[A,B](l: List[A], z: B)(f: (B,A) => B): B = 
    foldRight(l, (b:B) => b)((a,g) => b => g(f(b,a)))(z)

有人可以帮助我追踪这个解决方案并让我理解这实际上是如何实现foldl实现的折叠,反之亦然？

谢谢

我目前正在做一个函数式编程课程,我对高阶函数和函数作为一等公民的概念感到很开心.但是,我还不能想到许多实用的,概念上令人惊奇的,或者只是简单有趣的高阶函数.(除了典型的和相当乏味map,filter等函数).

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

也许返回函数的函数,返回函数列表的函数(？)等.

我很欣赏Haskell中的例子,这是我目前正在学习的语言:)

我想让void enqueue(Callback<T> callback);方法调用代码块更具表现力,这是我通常所拥有的

request.enqueue(object : Callback<MyModel> {
      override fun onFailure(call: Call<MyModel>?, t: Throwable?) {
           //
      }

      override fun onResponse(call: Call<MyModel>?, response: Response<MyModel>?) {
           //
      }
 })

而我想要的意思是,更改此代码阻止更清晰的方式并删除那些覆盖,对象,回调关键字并执行类似的操作:

request.enqueue({throwable, response -> })

我认为可以使用扩展和高阶函数以某种方式进行改进.有谁知道怎么做？

我想重复应用一个函数,simplify'直到结果"稳定"(即simplify'(x) == x):

simplify :: Expr -> Expr
simplify expr =
    let iterations = iterate simplify' expr
        neighbours = zip iterations (tail iterations)
        simplified = takeWhile (\(a, b) -> a /= b) neighbours
    in  snd $ last ((expr, expr) : simplified)

simplify' :: Expr -> Expr

这似乎是我常见的问题.有更优雅的解决方案吗？

更新:我找到了一个更简单的解决方案,但我仍然在寻找更优雅的解决方案:)

simplify expr =
    let next = simplify' expr
    in  if next == expr
        then expr
        else simplify next

我正在寻找一个像这样的数组函数:

$myArray = array(
  'apple'=>'red',
  'banana'=>'yellow',
  'lettuce'=>'green',
  'strawberry'=>'red',
  'tomato'=>'red'
);
$keys = array(
  'lettuce',
  'tomato'
);

$ret = sub_array($myArray, $keys);

$ ret是:

array(
  'lettuce'=>'green',
  'tomato'=>'red'
);

一个没有问题,我自己写下来,我想避免foreach循环并采用内置函数或内置函数的组合.在我看来,这是一个通用的和常见的数组操作 - 如果循环是唯一的选择,我会感到惊讶.

我有这样一个数组:

array("a" => 2, "b" => 4, "c" => 2, "d" => 5, "e" => 6, "f" => 2)

现在我想通过某种条件过滤该数组,只保留值等于2的元素,并删除值为2的所有元素.

所以我期望的结果数组是:

array("a" => 2, "c" => 2, "f" => 2)

_{注意:我想保留原始数组中的键.}

我怎么能用PHP做到这一点？任何内置功能？

我对TypeScript感到非常兴奋.如何设置函数参数的类型？

function twoMoreThanYou(calculateANumber: Function):number {
    return calculateANumber(4) + 2;
}

function double(n:number):number {
    return n*2;
}

console.log("TWO MORE", twoMoreThanYou(double))

我怎么打字calculateANumber更好？我想指定它必须是一个带数字的函数并返回一个数字.

然后,我可以为该类型创建一个"界面"或一些简写,这样我可以使我的高阶函数签名更具可读性吗？

我对flatMap有点困惑(添加到Swift 1.2)

假设我有一些可选类型的数组,例如

let possibles:[Int?] = [nil, 1, 2, 3, nil, nil, 4, 5]

在Swift 1.1中,我会做一个过滤器,然后是这样的地图:

let filtermap = possibles.filter({ return $0 != nil }).map({ return $0! })
// filtermap = [1, 2, 3, 4, 5]

我一直尝试使用flatMap这样做:

var flatmap1 = possibles.flatMap({
    return $0 == nil ? [] : [$0!]
})

和

var flatmap2:[Int] = possibles.flatMap({
    if let exercise = $0 { return [exercise] }
    return []
})

我更喜欢最后一种方法(因为我不必强制解包$0!...我害怕这些并且不惜一切代价避免它们)除了我需要指定数组类型.

是否有一个替代方法可以根据上下文计算出类型,但是没有强制解包？

我有一个我想要映射的范围,但我收到了错误

“Cannot invoke 'map' with an argument list of type '((_) -> _)'”

这是代码的样子

    let patterns = (0...5).map { verseNum in
        let verseNumberStartPattern = "\"verse-num\">\(verseNum)</span>(?:\\s?<span>)?(.*?)<"
        let chapterStartPattern = "\"chapter-num\">\\s\(parsedVerse.chapterStart)\\s</span>"
        if verseNum == 1 {
            return chapterStartPattern + "(.*?)<"
        } else {
            return chapterStartPattern + "(?:.*?)" + verseNumberStartPattern
        }
    }

如果我取出闭包内的所有内容并返回"",那么编译器就不会抱怨.但是,即使我添加一行而不是返回空字符串,编译器也会抱怨,例如:

    let patterns = (0...5).map { verseNum in
        let verseNumberStartPattern = "\"verse-num\">\(verseNum)</span>(?:\\s?<span>)?(.*?)<"
        return ""
    }

我在这里错过了什么吗？