Scala错误类型不匹配

Question

I'm trying to find another way of avoiding a type mismatch error that looks more correct than the one I'm using right now.

Considering the list and the function, respectively:

var l = List[Int]()

def append[U](cmd: U) = {
        l = l :+ cmd
}

When interpreting the code above, I'm getting the following error:

<console>:10: error: type mismatch;
 found   : List[Any]
 required: List[Int]
                   l = l :+ cmd
                         ^

The way I fixed it, was by modifying the append function to work like this:

  def append[U](cmd: U) = {
    l = (l :+ cmd).asInstanceOf[List[Int]]
  }

Is there a way of defining the append function without the use of asInstanceOf?

Trying to be clearer, the goal was to create the class below

abstract class Cstruct{
  type T
  var value: T
  def append[U](value:U)
}

Cstruct should be built in a way that would be possible to define new classes that extends Cstruct but use different data structures for the value T. Like Cseq that uses a List of any type of elements, but should be possible to create a similar one using a Set or a Map.

class Cseq[U] (v: U) extends Cstruct{
  type T = List[U]
  var value: T = List[U](v)
  override def append[U](cmd: U) = {
    value = (value :+ cmd).asInstanceOf[T]
  }
}

Answer 1

You get that error because your type variable U has no constraints, it could be any type - yet you try to add a value of type U to a list of Int .

Your fix is not type-safe. It will allow you to attempt to add for example a String to a List[Int] . The asInstanceOf makes the compile error go away, but you'll get a ClassCastException at runtime if you add a wrong type of object to the list.

Why does your method have a type parameter at all? If the list is always a List[Int] , then it should just take an Int instead of an U :

def append(cmd: Int) = {
  l = l :+ cmd
}

edit - You can do this:

abstract class Cstruct[U] {
  type T
  var value: T
  def append(value: U)
}

class Cseq[U](v: U) extends Cstruct[U] {
  type T = List[U]
  var value: T = List[U](v)

  override def append(cmd: U) =
    value = value :+ cmd
}

Note that in your own definition of Cseq[U] , the U in override def append[U] is a different type parameter than the one defined at class Cseq[U] . It just happens to have the same name U .