CanBuildFrom and upper type bound parameters

Question

Here is a minimalistic example:

def map[U[_] <: Traversable[T], T](col: U[T]): U[T] 
    = col.map(identity)

This code does not compile.

type mismatch;
 found   : Traversable[T]
 required: U[T]
    = col.map(identity)

My understanding of the problem is the col.map(identity) where the compiler infers an implicit CanBuildFrom[U[T], T, Traversable[T]] instead of desired CanBuildFrom[U[T], T, U[T]] .

Is there a way to make this code working?

Answer 1

The mechanics of builder type classes in Scala 2.12 is something like so

def foo[CC[x] <: Traversable[x], A, B](as: CC[A], f: A => B)(
  implicit cbf: CanBuildFrom[CC[A], B, CC[B]]
): CC[B] = {
  val bf = cbf()
  as.foreach { a => bf += f(a) }
  bf.result()
}

or using .to method

def foo[CC[x] <: Traversable[x], A, B](as: CC[A], f: A => B)(
  implicit cbf: CanBuildFrom[CC[A], B, CC[B]]
): CC[B] = {
  as.map(f).to[CC]
}

Corresponding Scala 2.13 code might be

def foo[CC[x] <: Iterable[x], A, B](as: CC[A], f: A => B)(
  implicit cbf: BuildFrom[CC[A], B, CC[B]]
): CC[B] = {
  cbf.fromSpecific(as)(as.map(f))
}

or using factory

def foo[CC[x] <: Iterable[x], A, B](as: CC[A], f: A => B)(
  implicit factory: Factory[B, CC[B]]
): CC[B] = {
  as.map(f).to(factory) // equivalent to factory.fromSpecific(as.map(f))
}

The meanings of three type parameters of collection builder type class are

             | source coll | element of target coll | target coll   |
---------------------------------------------------------------------
CanBuildFrom | -From       | -Elem                  | +To           |
BuildFrom    | -From       | -A                     | +C            |
Factory      |             | -A                     | +C            |

Note these builder type classes are just generalised version of the following idea

scala> val bf = List.newBuilder[Int]
val bf: scala.collection.mutable.Builder[Int,List[Int]] = ListBuffer()

scala> bf += 1 += 4
val res0: bf.type = ListBuffer(1, 4)

scala> bf.result()
val res1: List[Int] = List(1, 4)

but in practice we rarely see collections constructed in such way.

Another option instead of BuildFrom is to use cats type classes such as Functor .