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]的appart，还有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]
    }
}

由于清单很快也会被弃用（请参阅下面的评论），您应该考虑使用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)

Scala：可选的类型参数？

3 个答案: