压缩集合上的 Scala 函数文字和占位符语法

Question

我目前正在学习 Scala，并且一直难以在 zipped 集合上使用占位符语法。例如，我想从 l2[i] >= l1[i] 的项目中过滤压缩数组。我如何使用显式函数文字或占位符语法来做到这一点？我试过：

scala> val l = List(3, 0, 5) zip List(1, 2, 3)
l: List[(Int, Int)] = List((3,1), (4,2), (5,3))

scala> l.filter((x, y) => x > y)
<console>:9: error: missing parameter type
Note: The expected type requires a one-argument function accepting a 2-Tuple.
      Consider a pattern matching anonymous function, `{ case (x, y) =>  ... }`
              l.filter((x, y) => x > y)
                        ^
<console>:9: error: missing parameter type
              l.filter((x, y) => x > y)

scala> l.filter((x:Int, y:Int) => x > y)
<console>:9: error: type mismatch;
     found   : (Int, Int) => Boolean
     required: ((Int, Int)) => Boolean
                  l.filter((x:Int, y:Int) => x > y)

尝试占位符语法：

scala> l.filter(_ > _)
      <console>:9: error: missing parameter type for expanded function ((x, x) => x.$greater(x))
  Note: The expected type requires a one-argument function accepting a 2-Tuple.
  Consider a pattern matching anonymous function, `{ case (x, x) =>  ... }`
        l.filter(_ > _)
            ^
<console>:9: error: missing parameter type for expanded function ((x: <error>, x) => x.$greater(x))
        l.filter(_ > _)

所以它似乎需要一个函数 Pair:

scala> l.filter(_._1 > _._2)
<console>:9: error: missing parameter type for expanded function ((x, x) => x._1.$greater(x._2))
Note: The expected type requires a one-argument function accepting a 2-Tuple.
      Consider a pattern matching anonymous function, `{ case (x, x) =>  ... }`
              l.filter(_._1 > _._2)
                       ^
<console>:9: error: missing parameter type for expanded function ((x: <error>, x) => x._1.$greater(x._2))
              l.filter(_._1 > _._2)

那我做错了什么？ match 是唯一的一种方式吗？感谢您的帮助。

Answer 1

使用这个：

l.filter { case (x, y) => x > y }

或

l.filter(x => x._1 > x._2)

同样在 Scala 中类型信息 does not flow 从函数的主体到它的参数。

Answer 2

正如您发现 filter 而不是 List 需要一个只有一个参数的函数（在您的例子中是 Tupple2 又名 "Pair"）：

def filter(p: (A) => Boolean): List[A]

而这个(x, y) => x > y表示一个有两个参数的函数(A, B) => Boolean。所以你使用 _1 和 _2 的方向是正确的，但是每次使用 _ 都代表一个新参数，所以 _._1 > _._2 实际上等同于 (x, y) => x._1 > y._2。因此，如果您想多次使用相同的参数，则不能使用下划线：

l.filter(p => p._1 > p._2)

另一种可能性是使用模式匹配来扩展 Tupple2:

l.filter{ case (x, y) => x > y }

或者，您可以使用 zipped，它将 return 一个 Tuple2Zipped 并且它的过滤器接受一个带有两个参数的函数（下面的简化签名）：

def filter(f: (El1, El2) => Boolean): (List[El1], List[El2])

您可以这样使用zipped：

scala> val l = (List(3, 0, 5), List(1, 2, 3)) zipped
l: scala.runtime.Tuple2Zipped[Int,List[Int],Int,List[Int]] = scala.runtime.Tuple2Zipped@8dd86903

scala> l.filter(_ > _)
res1: (List[Int], List[Int]) = (List(3, 5),List(1, 3))

scala> l.filter(_ > _).zipped.toList
res2: List[(Int, Int)] = List((3,1), (5,3))

Tuple2Zipped 的 filter return 是一对列表而不是一对列表，因此要转换为第二种形式，您可以使用 .zipped.toList。

压缩集合上的 Scala 函数文字和占位符语法

Scala function literals and placeholder syntax on zipped collections

functional-programming

scala

function-literal

pattern-matching