如何使用我自己的通用`map`（正确的方法）来丰富Scala集合？

Question

I'm trying to enrich Scala collections with my own map method, and I'm close but the implicit conversion doesn't work. Besides that, is there anything else I'm missing here? I'm looking at various other resources on the Web, including SO answers that this question is being marked as duplicating , and many are missing something here and there (eg using C[A] <: GenTraversable[A] , using b() instead of b(xs) , forgetting about Array , forgetting about BitSet , etc.).

implicit def conv[A,C](xs: C)(implicit ev: C <:< GenTraversableLike[A,C]) = new {
  def mymap[B,D](f: A => B)(implicit b: CanBuildFrom[C,B,D]): D = b(xs).result // placeholder
}

scala> conv(List(1,2,3))
res39: java.lang.Object{def mymap[B,D](f: Int => B)(implicit b: scala.collection.generic.CanBuildFrom[List[Int],B,D]): D} = $$$$2c9d7a9074166de3bf8b66cf7c45a3ed$$$$anon$1@3ed0eea6

scala> conv(List(1,2,3))mymap(_+1)
res40: List[Int] = List()

scala> conv(BitSet(1,2,3))mymap(_+1)
res41: scala.collection.immutable.BitSet = BitSet()

scala> conv(BitSet(1,2,3))mymap(_.toFloat)
res42: scala.collection.immutable.Set[Float] = Set()

scala> List(1,2,3)mymap(_+1)
<console>:168: error: Cannot prove that List[Int] <:< scala.collection.IterableLike[A,List[Int]].
              List(1,2,3)mymap(_+1)
                  ^

scala> implicit def conv[A, C](xs: C)(implicit ev: C => GenTraversable[A]) = new {
     | def mymap[B,D](f: A => B)(implicit b: CanBuildFrom[GenTraversable[A],B,D]): D =
     | xs map f
     | }
conv: [A, C](xs: C)(implicit ev: C => scala.collection.GenTraversable[A])java.lang.Object{def mymap[B,D](f: A => B)(implicit b: scala.collection.generic.CanBuildFrom[scala.collection.GenTraversable[A],B,D]): D}

scala> conv(Array(1)) mymap (_+1)
res6: scala.collection.GenTraversable[Int] = ArrayBuffer(2)

scala> Array(1) mymap (_+1)
<console>:68: error: No implicit view available from Array[Int] => scala.collection.GenTraversable[A].
              Array(1) mymap (_+1)
                   ^

Answer 1

I've answered this very question about type inference just last week. Here's the code:

implicit def conv[A,C <: GenTraversable[A]](xs: C with GenTraversableLike[A,C]) = new {
  def mymap[B,D](f: A => B)(implicit b: CanBuildFrom[C,B,D]): D = {
    val builder = b(xs)
    xs foreach { x => builder += f(x) }
    builder.result
  }
}

I could have used GenTraversable instead of GenTraversableLike in this particular case. I prefer the later because it offers more.

The problem is that declaring [A, C <: GenTraversable[A]] does not instruct Scala to infer the type of A from the type of C . Types are inferred based on how they are used in the parameters, and then checked against the boundaries specified by the type parameters.

So when I write xs: C with GenTraversable[A] , I let Scala know it should infer A from xs . And writing GenTraversableLike[A, C] tells Scala it should pick a collection that returns C for methods that return the same collection. This means you can call filter and get C back, instead of getting GenTraversable back.

As for wishing to include views, that I don't know how you could accomplish.

Answer 2

I have answered a similar question here . You can also refer to this thread where Rex Kerr explains how to perform such pimping in general.