16

从这里链接的问题中，我在 Scala 中找到了 Union 的这个实现：

def union(a: Set, b: Set): Set = i => a(i) || b(i)

Set 是一个类型的函数：

type Set = Int => Boolean

现在我明白了，在 Scala 中，一个函数在这里从 Int 映射到 Boolean，我进一步了解了这个语句是如何执行的：

a(i) || b(i)

但我不明白这里的“我”是什么。它从何而来？当它找到集合之间的匹配时，它返回true，如果确实如此，我在哪里过滤它？

4

4 回答 4

18

从返回的Set（只是一个函数）union接受一些整数作为参数；您必须给它一个任意名称，以便您可以在函数体中引用它。如果您像这样编写函数可能更有意义：

def union(a: Set, b: Set): Set = {
  (i) => a(i) || b(i)
}

如果你这样写它可能更有意义：

def union(a: Set, b: Set): Set = {
  // The union of two sets is a new function that takes an Int...
  def theUnion(i: Int): Boolean = {
    // and returns true if EITEHR of the other functions are true
    a(i) || b(i)
  }

  // Now we want to return the NEW function
  theUnion
}

同样，i是任意的，可以用任何变量替换：

def union(a: Set, b: Set): Set = item => a(item) || b(item)

[更新]

因为我们将集合表示为函数，所以不需要迭代来查看它们是否包含数字。例如，这是一个包含以下任意数字的集合-5：

val belowNegFive: Set = (i) => i < -5

当我们用数字调用该函数时，它会告诉我们该数字是否在集合中。请注意，我们从未真正告诉它集合中的具体数字：

scala> belowNegFive(10)
res0: Boolean = false

scala> belowNegFive(-100)
res1: Boolean = true

scala> belowNegFive(-1)
res2: Boolean = false

这是另一个包含 和 之间的任意数字的50集合100：

val fiftyToHundred: Set = (i) => i >= 50 && i <= 100

scala> fiftyToHundred(50)
res3: Boolean = true

scala> fiftyToHundred(100)
res4: Boolean = true

scala> fiftyToHundred(75)
res5: Boolean = true

scala> fiftyToHundred(49)
res6: Boolean = false

现在，集合的并集belowNegFive和fiftyToHundred将包含任何低于或-5 介于和 之间50的数字100。我们可以通过返回一个新函数来轻松地在代码中表示这一点，如果其他两个函数中的任何一个返回 true，则该函数本身返回true。

scala> val unionOfBoth: Set = (i) => belowNegFive(i) || fiftyToHundred(i)
unionOfBoth: Int => Boolean = <function1>

scala> unionOfBoth(-10)
res7: Boolean = true

scala> unionOfBoth(50)
res8: Boolean = true

scala> unionOfBoth(0)
res9: Boolean = false

您问题中的union函数只是将这种模式普遍应用于任何两组的一种方式。

于 2013-10-06T02:39:28.837 回答
11

假设我们有一个名为SoSet给定的对象

object SoSet {
    type Set = Int => Boolean
    val a : Set = ???
    val b : Set = ???
    def isItem(item : Int) = a(item) || b(item)
}

的签名isItem由Int => Booleanwhich is a给出Set。到目前为止，一切都很好。

但现在我们只想返回函数 isItem（即 a Set）。

所以让我们union为此定义函数（现在没有参数。我们稍后会添加它）。

object SoSet {
    //..   
     def union : Set = isItem // returns the function isItem
}

现在让我们将其重构isItem为匿名函数。

object SoSet {
    //..   
    def union : Set = {
      (item : Int) => a(item) || b(item)
    }
}

让我们Set a and b从object SoSet到 的参数def union。重构item为i.

object SoSet { 
   type Set = Int => Boolean
   def union(a : Set, b : Set) : Set = (i : Int) => a(i) || b(i)
}

更新 

 val s1 = Set(1, 2, 3)                           
 val s2 = Set(2, 3, 4)     
 val s3 = union(s1, s2) //  returns the function..  Int => Boolean = <function1>
 s3(2)  // invokes the function & checks if 2 is present in the union
于 2013-10-06T10:07:01.567 回答
1

当它找到集合之间的匹配时，它返回true，如果确实如此，我在哪里过滤它？

union在两个集合之间找不到匹配项，它会创建一个包含两个集合值的新集合。例子：

val a = (i) => i == 2 // a contains 2 as a(2) == True
val b = (i) => i == 5 // b contains 5 as b(5) == True
val u = union(a, b)   // u contains 2 and 5 as u(2) == True and u(5) == True

所以“过滤”只是在途中发生。这个函数不会遍历每个集合，过滤掉特定的东西，它只是返回两个函数的组合，然后可以稍后执行以查询实际值。

查询联合值的示例：

val a = (i) => i == 2
val b = (i) => i == 5
val u = union(a, b)

for(i <- 1 to 10 if u(i)) yield i     // returns Vector(2, 5)

是的，这不是在集合中存储值的最佳方式，因为您必须通过猜测来检查值，但它是演示组合函数如何在不编写非常复杂的代码的情况下添加复杂功能的好方法。

于 2013-10-06T12:45:05.670 回答
0

您可以像这样实现联合函数：

def union[A](set1: Set[A], set2:Set[A]):Set[A] = {
    set1.foldLeft(set2)((set, elem) => set + elem)
}

或者

def union[A](set1: Set[A], set2:Set[A]):Set[A] = {
    set1.flatMap(elem => set2 + elem)
}

这些将是通用的，因此您可以将其用于任何类型的集合

于 2018-10-31T14:17:07.553 回答