Question

Referring to a previous answer of mine on stackoverflow

The core of the complexity is illustrated in just one method:

implicit def traversableToFilterOps[CC[X] <: Traversable[X], T]
(xs: CC[T])(implicit witness: CC[T] <:< TraversableLike[T,CC[T]]) =
  new MoreFilterOperations[CC[T], T](xs)

With two questions:

1. Is there any way to give the compiler a hint that Map meets the signature CC[X] <: Traversable[X]?
   I would expect it to match as a Traversable[Tuple2[_,_]] but this doesn’t happen. In the end, I had to write a second method taking CC[KX,VX] <: Map[KX,VX], but that feels redundant

2. witness: CC[T] <:< TraversableLike[T,CC[T]] also seems redundant given the first type parameter, my gut feeling is that this is enforced by the type of Traversable and must always hold true for any possible subclass or value of X, so there should be no reason to explicitly require it as a witness.

If I test this using an existential type in the REPL, then the compiler seems to agree with me:

scala> implicitly[Traversable[X] <:< TraversableLike[X,Traversable[X]] forSome { type X }]
res8: <:<[Traversable[X],scala.collection.TraversableLike[X,Traversable[X]]] forSome { type X } = <function1>

Is there therefore any way to do away with the boilerplate?

Answer 1

I’m a Scala noob, so please don’t shoot me down if this doesn’t help.

Assuming this:

class MoreFilterOperations[Repr <% TraversableLike[T,Repr], T] (xs: Repr) {}

Would something like this work?

// t2fo is short for traversableToFilterOps
implicit def t2fo[Repr <% TraversableLike[T, Repr], T](xs: Repr) = 
  new MoreFilterOperations[Repr, T](xs)

// m2fo is short for mapToFilterOps
implicit def m2fo[Repr <% Map[K, V] <% TraversableLike[(K,V), Repr], K, V]
  (xs: Repr) = new MoreFilterOperations[Repr, (K, V)](xs)

This should work because (according to the book I have.. Programming Scala, p264) the following method definition with a view bound:

def m [A <% B](arglist): R = ...

It is effectively the same as this method definition:

def m [A](arglist)(implicit viewAB: A => B): R = ...