Question

I was wondering how to go about adding a ‘partitionCount’ method to Lists, e.g.:
(not tested, shamelessly based on List.scala):

Do I have to create my own sub-class and an implicit type converter?

(My original attempt had a lot of problems, so here is one based on @Easy’s answer):

class MyRichList[A](targetList: List[A]) {
  def partitionCount(p: A => Boolean): (Int, Int) = {
    var btrue = 0
    var bfalse = 0
    var these = targetList
    while (!these.isEmpty) {
      if (p(these.head)) { btrue += 1 }  else { bfalse += 1 }
      these = these.tail
    }
    (btrue, bfalse)
  }
}

and here is a little more general version that’s good for Seq[…]:

implicit def seqToRichSeq[T](s: Seq[T]) = new MyRichSeq(s)

class MyRichList[A](targetList: List[A]) {
  def partitionCount(p: A => Boolean): (Int, Int) = {
    var btrue = 0
    var bfalse = 0
    var these = targetList
    while (!these.isEmpty) {
      if (p(these.head)) { btrue += 1 }  else { bfalse += 1 }
      these = these.tail
    }
    (btrue, bfalse)
  }
}

Answer 1

You can use implicit conversion like this:

implicit def listToMyRichList[T](l: List[T]) = new MyRichList(l)

class MyRichList[T](targetList: List[T]) {
    def partitionCount(p: T => Boolean): (Int, Int) = ...
}

and instead of this you need to use targetList. You don’t need to extend List. In this example I create simple wrapper MyRichList that would be used implicitly.

You can generalize wrapper further, by defining it for Traversable, so that it will work for may other collection types and not only for Lists:

implicit def listToMyRichTraversable[T](l: Traversable[T]) = new MyRichTraversable(l)

class MyRichTraversable[T](target: Traversable[T]) {
    def partitionCount(p: T => Boolean): (Int, Int) = ...
}

Also note, that implicit conversion would be used only if it’s in scope. This means, that you need to import it (unless you are using it in the same scope where you have defined it).