Scala中的类和替换

有人能给我解释一下方法

union

在这个代码中是如何工作的吗？我可以看到它在函数中调用自己，但除此之外，我不知道它做什么。打印

t2联合t3

产生

{{{-1.}2.}3{{.4.}5{.7.}}

object Mp6 {  
  def main(args: Array[String]): Unit = {
    val t1 = Empty
    val t2 = t1 incl 3 incl 5 incl 4 incl 7
    val t3 = t2 incl 2 incl 4 incl -1

    println(t1)
    println(t2)
    println(t1 contains 5)
    println(t2 contains 5)
    println(t2 contains 5)

    println(t2 union t3)
  }
}

abstract class IntSet {
  def incl(x: Int): IntSet
  def contains(x: Int): Boolean
  def union(other: IntSet): IntSet
}

object Empty extends IntSet {
  def contains(x: Int): Boolean = false
  def incl(x: Int): IntSet = new NonEmpty(x, Empty, Empty)  
  def union(other: IntSet): IntSet = other
  override def toString = "."
}

class NonEmpty(elem: Int, left: IntSet, right: IntSet) extends IntSet {
  def contains(x: Int): Boolean =
    if (x < elem) left contains x
    else if (x > elem) right contains x
    else true

  def incl(x: Int): IntSet =
    if (x < elem) new NonEmpty(elem, left incl x, right)
    else if (x > elem) new NonEmpty(elem, left, right incl x)
    else this

  def union(other: IntSet): IntSet = {
    val set = left.union(right.union(other))
    set.incl(elem)
  }

  override def toString = "{" + left + elem + right + "}"
}

对象Mp6{
def main（参数：数组[字符串]）：单位={
val t1=空
val t2=t1包括3包括5包括4包括7
val t3=t2，包括2，包括4，包括-1
println（t1）
println（t2）
println（t1包含5个）
println（t2包含5个）
println（t2包含5个）
println（t2和t3）
}
}
抽象类集合{
def incl（x:Int）：IntSet
def包含（x:Int）：布尔值
def接头（其他：IntSet）：IntSet
}
对象空扩展IntSet{
def contains（x:Int）：布尔值=false
def incl（x:Int）：IntSet=new非空（x，Empty，Empty）
def接头（其他：IntSet）：IntSet=其他
覆盖def toString=“”
}
类NonEmpty（elem:Int，left:IntSet，right:IntSet）扩展了IntSet{
def包含（x:Int）：布尔值=
如果（xelem）右侧包含x，则为else
否则是真的
def incl（x:Int）：IntSet=
如果（x元素）新非空（元素，左，右，包括x）
除此之外
def联合（其他：IntSet）：IntSet={
val集合=左.联轴节（右.联轴节（其他））
成套设备，包括（要素）
}
override def toString=“{”+左+元素+右+“}”
}

这是一个排序整数集的实现，它使用不添加重复项的二进制排序树进行备份。因此，并集只是执行一个保留整数顺序的集合论并集。

好吧，你基本上是在要求解释求值的替换模型是如何工作的。如上所述，您的代码片段非常类似于Martin Odersky（Scala的创建者）编写的

IntSets

的实现，因此我将使用他的课程笔记中的符号。我假设您已经快速阅读了替换模型规则。如果没有，那么这是一个很好的起点

我给你一个提示：为了方便起见，假设

val t1=new NonEmpty（1，Empty，Empty）

和

val t2=new NonEmpty（2，Empty，new NonEmpty（3，Empty，Empty））

。这意味着

t1:NonEmpty={.1.}

和

t2:NonEmpty={.2{.3.}

。现在让我们计算表达式

t1 union t2

t1 union t2 = new NonEmpty(1, Empty, Empty) union new NonEmpty(2, Empty, new NonEmpty(3, Empty, Empty))
            → [1/elem, Empty/left, Empty/right] [new NonEmpty(2, Empty, new NonEmpty(3, Empty, Empty))/other] [new NonEmpty(1, Empty, Empty)/this] (left union (right union other)) incl elem 
            = (Empty union (Empty union new NonEmpty(2, Empty, new NonEmpty(3, Empty, Empty)))) incl 1
            ...

---

您现在可以完成评估了吗？

看起来很像来自Coursera，而荣誉代码是说不要共享其中的代码？很抱歉，我是从我们的讲师那里得到这个代码的，我不知道他是从哪里得到的。@Paul:这看起来像是一个非常标准的集合OO编码，例如，与William R.Cook在年使用的非常类似“关于理解数据抽象，重温“好吧，除非Coursera在其他地方也用过，否则它看起来有点可疑！”！不管怎样，你对工会的理解到底停留在哪里？我认为，出于教学目的，最好不要从一开始就解释一切think@JörgWMittag，是的，是的。设计不是问题，问题在于类、val、方法名和布局与Coursera几乎相同。这真是一个巧合。这难道不会导致创建许多空集的实例吗？或者我应该忽略所有空集的实例，从而导致：=new NonEmpty（2，Empty，new NonEmpty（3，Empty，Empty））incl 1=if（1<2）newNonEmpty（2，newNonEmpty（1，Empty，Empty），new NonEmpty（3，Empty））={{{{.1.}2{.3.}对不起，我的文本格式刚刚从堆栈溢出开始。您是如何使其在注释中看起来像代码块的？回想一下，

空联合其他

始终提供

其他

，因此

（空联合（空联合新非空（2，空，新非空（3，空，空）））incl 1

计算结果为

新非空（2，空，新非空（3，空，空））incl 1

。是的，您的最终结果是正确的。关于代码格式，请看一下。