object Test {
  def main(args: Array[String]) {
    val list: List[Double] = List(1.0, 2.0, 3.0, 4.0)
    val none = None

    case class Test()

    val test = Test()

    def f(x: Any) = x match {
        case _: Some[Test] => println("_ matched")
        case None => println("None matched")
    }

    f(list)
    f(none)
    f(test)
  }
}

尝试编译上面的代码会导致"擦除"编译时警告.

   $>scalac Test.scala
    Test.scala:11: warning: non-variable type argument Test in type pattern
 Some[Test] is unchecked since it is eliminated by erasure
            case _: Some[Test] => println("_ matched")
                    ^
    one warning …

我想知道,为什么这不起作用:

  def example(list: List[Int]) = list match {
    case Nil => println("Nil")
    case List(x) => println(x)
  }                                             

  example(List(11, 3, -5, 5, 889, 955, 1024))

它说:

scala.MatchError: List(11, 3, -5, 5, 889, 955, 1024) (of class scala.collection.immutable.$colon$colon)

我坐在一个大约10000 LoC的项目前.我必须将此项目从Scala 2.9更新到2.10.这样做得很好,但由于清单,我收到了许多弃用警告.

在使用stackoverflow和许多其他站点的搜索功能之后,我没有那么多问题.我想总结一下; 关键点是:

1. TypeTags和ClassTag比Manifest和ClassManifest好得多.特别是你可以使用这些作为同义词(TypeTags < - > Manifests和ClassTags < - > ClassManifest)

2. TypeTag比ClassTag更强大,ClassTag更受限制TypeTags.我的第一个问题:在这个项目中,manifest[T].erasure.getSimpleName经常使用这种方法.现在我不仅可以将其切换为,typeTag[T].runtimeClass.getSimpleName因为代码不会编译,但是classTag[T].runtimeClass.getSimpleName它会编译.这会影响语义吗？(注意:该方法erasure也已弃用;您必须使用该方法runtimeClass)

3. 第二个问题: Scala 2.9中的清单类型检查是:manifest[T] <:< manifest[A].在Scala 2.10中,我会写这个typeOf[T] <:< typeOf[A].但是<:<被弃用了？!

4. 我可以将TypeTag转换为ClassTag吗？即:如果我只使用清单进行类型检查(Nr.3)和名称提取(Nr.2):我能将每个Manifest/ClassManifest重命名为ClassTag吗？

我想得到一个List的内部类型的清单,如下所示并将其传递给另一个函数,我该怎么做？谢谢

  def f(any: Any) = any match {
    case x: Int => println("Int")
    case a: List[_] => // get the manifest of List's inner type, and use it in the function g()
  }

  def g[T:Manifest](list:List[T]) = {}

所以说我们有几个这样的类：

abstract class Throw {
    def winsOver(t2: Throw): Boolean
}

class Rock extends Throw {
    override def winsOver(t2: Throw): Boolean = t2 match {
        case _: Scissors => true
        case _           => false
    }
}

class Scissors extends Throw {
    override def winsOver(t2: Throw): Boolean = t2 match {
        case _: Paper => true
        case _        => false
    }
}

class Paper extends Throw {
    override def winsOver(t2: Throw): Boolean = t2 match {
        case _: Rock => true
        case …

有没有办法可以获得函数的字符串表示？

val f = List(1, 2, 3, 4, 66, 11).foldLeft(55)_

f是一个类型的函数((Int, Int) => Int) => Int,这将是我正在寻找的表示,但我无法在任何地方找到它.

toString当然,这个方法是我的第一次尝试,但它返回的只是<function1>.scala REPL做得对,文档也是如此.一定有办法吗？

问候.

如果我有一个接受Type参数的类,例如Seq[T],我有很多这个类的对象.我想根据类型Argument拆分它们T

例如 :

val x = List(Seq[Int](1,2,3,4,5,6,7,8,9,0),Seq[String]("a","b","c"))
x.foreach { a => 
  a match{ 
    case _ : Seq[String] => print("String") 
    case _ : Seq[Int] => print("Int")  
   }
 }

这段代码的结果是 StringString.它只匹配类Seq而不是类型,我应该怎么做才能强制它匹配类型？

我编写了一个泛型函数来从HashMap [String,AnyVal]中获取值.此方法从名称返回一个值,但也具有确保它具有特定类型的功能:

class Context {
  private var variables = HashMap[String, Any] ()

  def getVariable (name: String):Any = variables(name)
  def setVariable (name: String, value: Any) = variables += ((name, value))

  def getVariableOfType[T <: AnyVal] (name:String):T ={
    val v = variables(name)
    v match {
      case T => v.asInstanceOf[T]
      case _ => null.asInstanceOf[T]
    }
  }

}

函数getVariableOfType [T <:AnyVal]将无法编译,因为它在行情况下显示"无法解析符号T" T => v.asInstanceOf[T]

我想知道是否有可能做以下事情:

import scala.reflect.runtime.universe._
class Bar[T]
def foo[T]()(implicit ctag: reflect.ClassTag[T]) { 
  val clazz = classOf[Bar[ctag.runtimeClass.asInstanceOf[Class[T]]]] 
}

这里Scala编译器抱怨:

error: stable identifier required, but ctag.runtimeClass found.

有没有办法从函数中可用的运行时类型信息中插入类型参数的类类型？