在Scala中，为什么下限在这里不能正常工作？

Question

These codes compiles well:

  abstract class CodeTree

  case class Fork(left: CodeTree, right: CodeTree, chars: List[Char], weight: Int) extends CodeTree

  case class Leaf(char: Char, weight: Int) extends CodeTree


  def weight(tree: CodeTree): Int = tree match {
    case Fork(left, right, chars, weight) => weight
    case Leaf(char, weight) => weight
  }

  def insert_orderedCodeTreeList[T >: CodeTree](leaf: CodeTree, orderedCodeTrees: List[CodeTree]): List[T] = orderedCodeTrees match {
    case Nil => List(leaf)
    case head :: tail => {
      if (weight(leaf) <= weight(head)) leaf :: orderedCodeTrees
      else head :: insert_orderedCodeTreeList(leaf, tail)
    }
  }

But it will throw errors when I used it like this:

insert_orderedCodeTreeList[Leaf](Leaf(theChar, theInt), makeOrderedLeafList(tail))

type arguments [patmat.Huffman.Leaf] do not conform to method insert_orderedCodeTreeList's type parameter bounds [T >: patmat.Huffman.CodeTree]
[error]     case (theChar, theInt) :: tail => insert_orderedCodeTreeList[Leaf](Leaf(theChar, theInt), makeOrderedLeafList(tail))
[error]                                                                 ^
[error] one error found

As can be seen, the type parameter T uses CodeTree as lower bound, therefore, I think it might be OK to replace CodeTree with T in the parameter list of insert_orderedCodeTreeList :

  def insert_orderedCodeTreeList[T >: CodeTree](leaf: T, orderedCodeTrees: List[T]): List[T] = orderedCodeTrees match {
    case Nil => List(leaf)
    case head :: tail => {
      if (weight(leaf) <= weight(head)) leaf :: orderedCodeTrees
      else head :: insert_orderedCodeTreeList(leaf, tail)
    }
  }

However, the compiler complains about that:

[error]  found   : T
[error]  required: patmat.Huffman.CodeTree
[error]       if (weight(leaf) <= weight(head)) leaf :: orderedCodeTrees
[error]                                  ^

Does anyone have ideas about this?

Answer 1

After reading the document about bounds , I found the correct way is to write like this:

  def insert_orderedCodeTreeList[T <: CodeTree](leaf: T, orderedCodeTrees: List[T]): List[T] = orderedCodeTrees match {
    case Nil => List(leaf)
    case head :: tail => {
      if (weight(leaf) <= weight(head)) leaf :: orderedCodeTrees
      else head :: insert_orderedCodeTreeList(leaf, tail)
    }
  }