Scala:可选类型参数

Question

我写了这样一个方法:

def typeOnly[T, S](seq: Seq[S]): Seq[T] = {
  seq.flatMap{
    case t: T => Some(t)
    case _ => None
  }
}

我希望这样调用它:

typeOnly[String](List(1, "2", 3, "4"))

它不工作。我似乎必须指定第二个类型参数S:

typeOnly[String, Any](List(1, "2", 3, "4"))

但是为什么呢?难道编译器不知道List(1, "2", 3, "4")是Seq[Any]吗?

Answer 1

TL;DR

在Scala 2.9中使用。x:

def typeOnly[T](seq : Seq[Any])(implicit m : Manifest[T]) : Seq[T] = { 
    seq.collect { 
        case t if m.erasure.isInstance(t) => t.asInstanceOf[T]
    }
}
scala> typeOnly[String](List(1,2,"3",4))
res1: Seq[String] = List(3)    

，这是Scala 2.10的。x:

def typeOnly[T](seq : Seq[Any])(implicit tag : scala.reflect.ClassTag[T]) = { 
    seq.collect { 
        case t if tag.runtimeClass.isInstance(t) => t.asInstanceOf[T]
    }
}

---

由于Seq被定义为trait Seq[+A](键是+)，因此任何Seq[S]也都是Seq[Any]。

另一方面，正如已经说过的，T在编译函数时被"遗忘"，因此不能直接使用它。必须以某种方式将T的类作为参数传递。

def typeOnly[T](seq : Seq[Any], c : Class[T]) : Seq[T] = { 
    seq.flatMap { 
        case t if c.isInstance(t) => Some(t.asInstanceOf[T])
        case _ => None 
    }
} 

在Scala中，除了Class[T]，还有Manifest[T]，它更强大一些，因此也更习惯。特别是，它有一个方法erasure，它返回一个Class[T]。使用它，您可以像这样编写函数:

def typeOnly[T](seq : Seq[Any], m : Manifest[T]) : Seq[T] = { 
    seq.flatMap { 
        case t if m.erasure.isInstance(t) => Some(t.asInstanceOf[T])
        case _ => None 
    }
} 

看来我们什么也没得到。但是，如果您很好地要求编译器(使用implicit)，它将在调用函数时为您传递Manifest。

def typeOnly[T](seq : Seq[Any])(implicit m : Manifest[T]) : Seq[T] = { 
    seq.flatMap { 
        case t if m.erasure.isInstance(t) => Some(t.asInstanceOf[T])
        case _ => None 
    }
}

例子:

scala> typeOnly[java.lang.Integer](List(1,2,"3",4))
res2: Seq[java.lang.Integer] = List(1, 2, 4)
scala> typeOnly[String](List(1,2,"3",4))
res3: Seq[String] = List(3)
scala> typeOnly[java.lang.Double](List(1,2,"3",4))
res4: Seq[java.lang.Double] = List()

有更多的选择，其中一些更习惯。比如，你可以，使用collect与部分定义函数:

def typeOnly[T](seq : Seq[Any])(implicit m : Manifest[T]) : Seq[T] = { 
    seq.collect { 
        case t if m.erasure.isInstance(t) => t.asInstanceOf[T]
    }
}

警告:前面的例子可以在Scala 2.9.3及以下版本中使用。如果你正在开发Scala 2.10。x， Manifest#erasure已弃用。使用runtimeClass代替:

def typeOnly[T](seq : Seq[Any])(implicit m : Manifest[T]) = { 
    seq.collect { 
        case t if m.runtimeClass.isInstance(t) => t.asInstanceOf[T]
    }
}

由于manifest很快也将被弃用(参见下面的注释)，您应该考虑使用ClassTag。

def typeOnly[T](seq : Seq[Any])(implicit tag : scala.reflect.ClassTag[T]) = { 
    seq.collect { 
        case t if tag.runtimeClass.isInstance(t) => t.asInstanceOf[T]
    }
}

Answer 2

您的case t: T => Some(t)不按类型T过滤元素。您需要的是这样的内容:

  def typeOnly[T](seq: Seq[Any], clazz: Class[T] = classOf[Any]): Seq[T] = {
    seq.flatMap{
      case t: T if clazz.isInstance(t) => Some(t)
      case _ => None
    }
  }

可以这样调用:

typeOnly(Seq(1, "2", 3))
typeOnly(Seq(1, "2", 3), classOf[String])

Answer 3

如果您的目标是允许typeOnly用户只指定T类型参数，您可以这样定义:

def typeOnly[S](seq: Seq[S]) = new {
  def apply[T]: Seq[T] =
    seq.flatMap{
      case t: T => Some(t)
      case _ => None
    }
}

你必须这样命名

val l = typeOnly(List(1, "2", 3, "4"))[String]

(注意类型形参在实参之后，而不是在typeOnly之后)。

由于它对结构类型的特殊使用，增加了一个编译器警告。如果你想避免添加import language.reflectiveCalls来解决这个问题，你可以依赖一个中间类:

case class TypeOnlyFilter[S](seq: Seq[S]) {
  def apply[T]: Seq[T] =
    seq.flatMap{
      case t: T => Some(t)
      case _ => None
    }
}
def typeOnly[S](seq: Seq[S]) =
  new TypeOnlyFilter(seq)

注意，这个实现仍然有一个关于未检查的抽象类型模式T的编译器警告(与您的原始实现一样)。你只需要一个ClassTag类型的T来解决这个问题，所以最终的解决方案看起来像:

import scala.reflect.ClassTag
case class TypeOnlyFilter[S](seq: Seq[S]) {
  def apply[T: ClassTag]: Seq[T] =
    seq.flatMap{
      case t: T => Some(t)
      case _ => None
    }
}
def typeOnly[S](seq: Seq[S]) =
  new TypeOnlyFilter(seq)