是否有一种内置的更优雅的方法来按元素类型过滤和映射集合？

Question

如果我想缩小某个特定类型（例如 String）的所有元素的 Iterable[A] 范围，我可以这样做：

as filter { _.isInstanceOf[String] }

但是，这显然是可取的 使用这个作为Iterable[String]，可以通过map来完成：

as filter { _.isInstanceOf[String] } map { _.asInstanceOf[String] }

这非常丑陋。当然，我可以使用 flatMap 代替：

as flatMap[String] { a => 
  if (a.isInstanceOf[String]) 
    Some(a.asInstanceOf[String]) 
  else
    None
}

但我不确定这是否更具可读性！我编写了一个函数，narrow，它可以通过隐式转换来使用：

as.narrow(classOf[String])

但我想知道是否有一个我忽略的更好的内置机制。特别是能够将 List[A] 缩小为 List[String]，而不是 Iterable[String] 会很好。 code> 就像我的函数一样。

Answer 1

isInstanceOf / asInstanceOf 的 Scala 语法糖是模式匹配：

as flatMap { case x: String => Some(x); case _ => None }

因为它使用 flatMap，所以它通常应该返回与开始时相同的集合。

在 Scala 2.8 上，有一个实验函数可以执行这种模式，在对象 PartialFunction 中定义。所以，在 Scala 2.8 上你可以这样做：

as flatMap (PartialFunction.condOpt(_ : Any) { case x: String => x })

看起来更大主要是因为我没有先导入该函数。但是，话又说回来，在 Scala 2.8 上有一种更直接的方法：

as collect { case x: String => x }

Answer 2

作为记录，这里是 narrow 的完整实现。与问题中给出的签名不同，它使用隐式 Manifest 来避免某些字符：

implicit def itrToNarrowSyntax[A](itr: Iterable[A]) = new {
  def narrow[B](implicit m: Manifest[B]) = {
    itr flatMap { x => 
      if (Manifest.singleType(x) <:< m)
        Some(x)
      else
        None
    }
  }
}

val res = List("daniel", true, 42, "spiewak").narrow[String]  
res == Iterable("daniel", "spiewak")

不幸的是，缩小到特定类型（例如 List[String]）而不是 Iterable[String] 有点难。它可以通过利用更高种类的 Scala 2.8.0 中的新集合 API 来完成，但在当前框架中不能。

Answer 3

您将来可能会使用：

for(a :Type <- itr) yield a

但现在不起作用。
欲了解更多信息，请访问以下链接：
http://lampsvn.epfl.ch/trac/scala/ticket/1089
http://lampsvn.epfl.ch/trac/scala/ticket/900

Answer 4

保持形状：我现在有点匆忙，所以我把石膏留在那儿，但我很确定它可以被消除。这在主干中有效：

import reflect.Manifest
import collection.Traversable
import collection.generic.CanBuildFrom
import collection.mutable.ListBuffer

object narrow {
  class Narrower[T, CC[X] <: Traversable[X]](coll: CC[T])(implicit m1: Manifest[CC[T]], bf: CanBuildFrom[CC[T], T, CC[T]]) {
    def narrow[B: Manifest]: CC[B] = {
      val builder = bf(coll)      
      def isB(x: T): Option[T] = if (Manifest.singleType(x) <:< manifest[B]) Some(x) else None

      coll flatMap isB foreach (builder += _)
      builder mapResult (_.asInstanceOf[CC[B]]) result
    }
  }

  implicit def toNarrow[T, CC[X] <: Traversable[X]](coll: CC[T])(implicit m1: Manifest[CC[T]], bf: CanBuildFrom[CC[T], T, CC[T]]) = 
    new Narrower[T,CC](coll)

  def main(args: Array[String]): Unit = {
    println(Set("abc", 5, 5.5f, "def").narrow[String])
    println(List("abc", 5, 5.5f, "def").narrow[String]) 
  }
}

运行它：

Set(abc, def)
List(abc, def)