如何在Scala中创建泛型类型的对象/单例？ [英] How to create object/singleton of generic type in Scala?

问题描述

在下面显示的代码中，如何将 EmptyTree 转换为object（Singleton）？

  trait树[T] {
 def contains（num：T）：Boolean 
 def inc（num：T）：Tree [T] 
} 
 
 $ b $ class EmptyTree [T <％Ordered [T]] extends Tree [T] {
 def contains（num：T）：Boolean = false 
 def inc（num ：T）：Tree [T] = {
 new DataTree（num，new EmptyTree，new EmptyTree）
} 
 override def toString =。 
 
 $ b $ class DataTree [T <％Ordered [T]]（val x：T，val left：Tree [T]，val right：Tree [T]）extends Tree [ T] {
 
 def contains（num：T）：Boolean = {
 if（num  else if（num> x ）right.contains（x）
 else true 
} 
 def inc（num：T）：Tree [T] = {
 if（num  else if（num> x）new DataTree（x，left，right.inc（num））
 else this 
} 
覆盖def toString ={+ left + x + right +}
} 
 
 
 val t = new DataTree（20，new EmptyTree [Int]， new EmptyTree [Int]）
 //> t：greeting.Test.DataTree [Int] = {.20。} 
 val p = t.inc（10）//> p：greeting.Test.Tree [Int] = {{.10。} 20。} 
 val a = p.inc（30）//> a：greeting.Test.Tree [Int] = {{.10。} 20 {.30。}} 
 val s = a.inc（5）//> s：greeting.Test.Tree [Int] = {{{.5。} 10.} 20 {.30。}} 
 val m = s.inc（11）//> m：greeting.Test.Tree [Int] = {{{.5。} 10 {.11。}} 20 {.30。}} 
  

解决方案

让我对Alexey的答案进行解密。以下是一些代码风格改进的完整实现：​​

首先定义您的特征并识别其协方差：

 def包含[U>：T：Ordering]（num：U）：Boolean 
 
 def inc [U >：T：Ordering]（num：U）：Tree [U] 
} 
  

下一步定义您的全部树子对象

  case对象EmptyTree extends Tree [Nothing] {
 def （U：Nothing：Ordering]（num：U）：Boolean = false 
 def inc [U>：Nothing：Ordering] （num，EmptyTree，EmptyTree）
覆盖def toString =。 
} 
  

现在更改您的一般情况下的实施：

  case class DataTree [T：Ordering]（x：T，left：Tree [T]，right：Tree [T]）extends Tree [T] {
 import Ordering.Implicits._ 
 def contains [U>：T：Ordering]（num：U）：Boolean = 
 if（num  $ else $ true 
 $ b def inc [U>：T：Ordering]（num：U）：Tree [U （x，left.inc（num），right）
 else if（num> x）DataTree（x，left，right.inc（num） ）
 else this 
 
 override def toString ={+ left + x + right +}
} 
  

你可能有点沮丧，因为我用 Ordering 替换了 Ordered / code>，但您应该知道视图范围已被弃用


In the code shown below, how can I convert EmptyTree to object (Singleton) ?

trait Tree[T] {
    def contains(num: T): Boolean
    def inc( num: T ): Tree[T]
  }


class EmptyTree[T <% Ordered[T] ] extends Tree[T] {
    def contains(num:T):Boolean = false
    def inc(num:T):Tree[T] = {
        new DataTree(num, new EmptyTree, new EmptyTree)
    }
    override def toString = "."
}

class DataTree[T <% Ordered[T] ](val x:T, val left:Tree[T], val right:Tree[T]) extends Tree[T] {

    def contains(num:T):Boolean = {
        if( num < x ) left.contains(x)
        else if ( num > x ) right.contains(x)
        else true
    }
    def inc(num:T):Tree[T] = {
        if(num < x ) new DataTree(x, left.inc(num), right)
        else if ( num > x ) new DataTree(x, left, right.inc(num))
        else this
    }
    override def toString = "{" + left + x + right + "}"
}


val t = new DataTree(20, new EmptyTree[Int], new EmptyTree[Int])
                                                //> t  : greeting.Test.DataTree[Int] = {.20.}
val p = t.inc(10)                               //> p  : greeting.Test.Tree[Int] = {{.10.}20.}
val a = p.inc(30)                               //> a  : greeting.Test.Tree[Int] = {{.10.}20{.30.}}
val s = a.inc(5)                                //> s  : greeting.Test.Tree[Int] = {{{.5.}10.}20{.30.}}
val m = s.inc(11)                               //> m  : greeting.Test.Tree[Int] = {{{.5.}10{.11.}}20{.30.}}

解决方案

Let me detalize Alexey's answer. Here is full implementation with some code style improvements:

First define your trait with aknowledgment of its covariance:

 trait Tree[+T] {
    def contains[U >: T : Ordering](num: U): Boolean

    def inc[U >: T : Ordering](num: U): Tree[U]
  }

Next define your subtype-of-all-trees object

  case object EmptyTree extends Tree[Nothing] {
    def contains[U >: Nothing : Ordering](num: U): Boolean = false
    def inc[U >: Nothing : Ordering](num: U): Tree[U] =
      DataTree(num, EmptyTree, EmptyTree)
    override def toString = "."
  }

Now change your general case implementation:

  case class DataTree[T: Ordering](x: T, left: Tree[T], right: Tree[T]) extends Tree[T] {
    import Ordering.Implicits._
    def contains[U >: T : Ordering](num: U): Boolean = 
      if (num < x) left.contains(x)
      else if (num > x) right.contains(x)
      else true

    def inc[U >: T : Ordering](num: U): Tree[U] = 
      if (num < x) DataTree(x, left.inc(num), right)
      else if (num > x) DataTree(x, left, right.inc(num))
      else this

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

You could be a little bit frustrated since I replaced your Ordered with Ordering, but you should know that view bounds are deprecated

这篇关于如何在Scala中创建泛型类型的对象/单例？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！