Scala: Selecting a subset of types from a generic collection without std collections. (collect)

Question

Following my previous question came a quick and great answer, however it turned out my example didn't match my actual production code well enough. In summary I'm in need of a new implementation of the collect method.

The second fruit world (with some pretty funky fruit trees):

class Fruit {
    var seeds:Array[Fruit] = Array()
    def naiveCollect[F <: Fruit]:Array[Fruit] = this match {
        case f:F => Array(this)
        case _ => seeds.map(_.select[F]).flatten.toArray
    }
}

class Apple extends Fruit
class Pear extends Fruit
class GrannySmith extends Apple

Does not work because of type erasure:

var tree = new Fruit { seeds = Array(
                new Apple,
                new Pear,
                new GrannySmith,
                new Pear { seeds = Array(
                    new Apple,
                    new Pear)},
                new Apple)}

scala> tree.naiveCollect[Apple]
res1: Array[Fruit] = Array($anon$2@5a4b99fa)

// wanted output: Apple, GrannySmith, Apple, Apple

EDIT, SOLUTION1:

Turns out i managed to produce something which works by using the PartialFunction as in the std lib.

class Fruit {
    ...
    def clumsyCollect[F](pf:PartialFunction[Fruit, F]):Seq[F] = 
        if (pf.isDefinedAt(this))
            List(pf(this))
        else
            seeds.flatMap(_.selectPartial[F](pf))
}

Use case:

tree.clumsyCollect { case a:Apple => a }

Any alternatives or tips on cleaning this up would still be great though!

incrop · Accepted Answer · 2011-08-16T14:22:35.687

I think what you need is scala.reflect.ClassManifest

class Fruit {
    var seeds:Array[Fruit] = Array()
    def select[F <: Fruit](implicit cm: ClassManifest[F]): Array[F] = 
      if (cm.erasure.isInstance(this))        
        Array(this.asInstanceOf[F])
      else 
        seeds.flatMap(_.select[F])
}

With every call of select an implicit parameter containing actual class information will be passed. You can now make class checks at runtime, and also you can return Array of more specific type.

This produces desired result:

scala> tree.select[Apple]
res12: Array[Apple] = Array(Apple@10fa4d, GrannySmith@a10ca8, Apple@14611ec, Apple@142b533)

Alternatively, you can use context bound syntax:

def select[F <: Fruit : ClassManifest]: Array[F] = 
  if (classManifest[F].erasure.isInstance(this))        
...

This is just what I was getting at, thanks! Swinging around those ClassManifests is a little clumsy (not your code, but in general), but I suppose it's a pretty advanced functionality after all. — fickludd, Aug 17 '11 at 08:09

Ruediger Keller · Answer 2 · 2011-08-16T20:11:21.333

Manifests can be used to work around erasure. Since we're only interested in the manifest's erasure, we use a ClassManifest here because it's more lightweight.

The following is simple and works but the return type of select is Array[Fruit], not Array[F].

  class Fruit {
      var seeds: Array[Fruit] = Array()
      def select[F <: Fruit](implicit m: ClassManifest[F]): Array[Fruit] =
        seeds.filter(s => m.erasure.isInstance(s)) 
  }

The following provides a return type of Array[F] but is a little more involved.

  class Fruit {
      var seeds: Array[Fruit] = Array()
      def select[F <: Fruit](implicit m: ClassManifest[F]): Array[F] = {
        seeds.foldLeft(Array.newBuilder[F]) { (b, s) =>
          if(m.erasure.isInstance(s)) b += s.asInstanceOf[F] else b
        }.result
      }
  }

Edit: I just noticed that I didn't answer what the op asked. I will leave my answer anyway, maybe it's useful to someone.

Scala: Selecting a subset of types from a generic collection without std collections. (collect)

2 Answers2