How can I reusably filter based on type in Scala?

val boss = People.all.collect { case boss: Authority => boss }.head

val boss = People.all.view.collect { case boss: Authority => boss }.head

val bossOpt = People.all.view.collect { case boss: Authority => boss }.headOption
bossOpt.foreach(_.giveOrder) // happens only if a boss was found

def filter[T, T2](data: Traversable[T2])(implicit ev: ClassTag[T]) = data collect {
    case t: T => t
}

val data = Seq(new B, new B, new C, new B)
filter[B, A](data) //Traversable[B] with length 3
filter[C, A](data) //Traversable[C] with length 1

def filter[T : ClassTag](data: Traversable[_]) = data collect { case t: T => t }
filter[B](data)

val data = Vector(new B, new B, new C, new B)
data filter { _.isInstanceOf[B] } //Vector[A]
data filter { _.isInstanceOf[B] } map { _.asInstanceOf[B] } //Vector[B]
data collect { case t: B => t } //Vector[B].  Note that if you know the type at the calling point, this is pretty concise and might not need a helper method at all

//As opposed to:
filter[B](data) //Traversable[B], not a Vector!

implicit class RichTraversable[T2, Repr <: TraversableLike[T2, Repr], That](val trav: TraversableLike[T2, Repr]) extends AnyVal {
    def withType[T : ClassTag](implicit bf: CanBuildFrom[Repr, T, That]) = trav.collect {
        case t: T => t
    }
}

data.withType[B] //Vector[B], as desired    

list.groupBy(_.animal).values.map(_.maxBy(_.age)).toList

list.groupBy(_.getAs[String]("animal")).values.map(_.maxBy(_.getAs[Int]("age"))).toList

    class TestMacro(val c: blackbox.Context) {
      import c.universe._
      def filterMembers[
        T : WeakTypeTag,
        Filter : TypeTag
      ]: List[Symbol] = {
        val tpe = weakTypeOf[T].typeSymbol.typeSignature

        (for {
          baseClass <- tpe.baseClasses.reverse
          symbol <- baseClass.typeSignature.members.sorted
          if symbol.typeSignature <:< typeOf[Filter]
        } yield symbol)(collection.breakOut)
      }
    }