1

我写了一个这样的方法:

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")a的事实Seq[Any]吗?

4

3 回答 3

5

TL;博士

将此用于 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](键是+),anySeq[S]也是 a 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返回 a的方法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]
    }
}
于 2013-05-29T14:04:16.133 回答
3

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])
于 2013-05-29T14:08:46.470 回答
0

如果您的目标是允许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 的编译器警告(就像您的原始实现一样)。你只需要一个ClassTagfor 类型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)
于 2014-07-19T01:20:51.820 回答