2.9.0でのOptManifestとか、NoManifestとかClassManifestが使用されている箇所

gistfile1.scala

./scala/Predef.scala:  type OptManifest[T]   = scala.reflect.OptManifest[T]
./scala/Predef.scala:  def optManifest[T](implicit m: OptManifest[T])     = m
./scala/reflect/ClassManifest.scala:trait ClassManifest[T] extends OptManifest[T] with Equals with Serializable {
./scala/reflect/ClassManifest.scala:  private def subargs(args1: List[OptManifest[_]], args2: List[OptManifest[_]]) = (args1 corresponds args2) {
./scala/reflect/ClassManifest.scala:  def typeArguments: List[OptManifest[_]] = List()
./scala/reflect/ClassManifest.scala:  def classType[T <: AnyRef](clazz: JClass[_], arg1: OptManifest[_], args: OptManifest[_]*): ClassManifest[T] =
./scala/reflect/ClassManifest.scala:  def classType[T <: AnyRef](prefix: OptManifest[_], clazz: JClass[_], args: OptManifest[_]*): ClassManifest[T] =
./scala/reflect/ClassManifest.scala:  def arrayType[T](arg: OptManifest[_]): ClassManifest[Array[T]] = arg match {
./scala/reflect/ClassManifest.scala:  def abstractType[T](prefix: OptManifest[_], name: String, clazz: JClass[_], args: OptManifest[_]*): ClassManifest[T] =
./scala/reflect/ClassManifest.scala:  def abstractType[T](prefix: OptManifest[_], name: String, upperbound: ClassManifest[_], args: OptManifest[_]*): ClassManifest[T] =
./scala/reflect/ClassManifest.scala:  prefix: Option[OptManifest[_]],
./scala/reflect/ClassManifest.scala:  override val typeArguments: List[OptManifest[_]]) extends ClassManifest[T]
./scala/reflect/NoManifest.scala:/** <p> One of the branches of an OptManifest
./scala/reflect/NoManifest.scala:object NoManifest extends OptManifest[Nothing] with Serializable {
./scala/reflect/OptManifest.scala: *    A <code>OptManifest[T]</code> is an optional <a href="Manifest.html"
./scala/reflect/OptManifest.scala:trait OptManifest[+T] extends Serializable

gistfile2.scala

./scala/Predef.scala:  val NoManifest        = scala.reflect.NoManifest
./scala/reflect/ClassManifest.scala:    case (x, y)                                     => (x eq NoManifest) && (y eq NoManifest)
./scala/reflect/ClassManifest.scala:    case NoManifest => Object.asInstanceOf[ClassManifest[Array[T]]]
./scala/reflect/NoManifest.scala:object NoManifest extends OptManifest[Nothing] with Serializable {
./scala/reflect/OptManifest.scala: *    It is either a <code>Manifest</code> or the value <code>NoManifest</code>.

gistfile3.scala

./scala/Array.scala:import scala.reflect.ClassManifest
./scala/Array.scala:  implicit def canBuildFrom[T](implicit m: ClassManifest[T]): CanBuildFrom[Array[_], T, Array[T]] =
./scala/Array.scala:  def newBuilder[T](implicit m: ClassManifest[T]): ArrayBuilder[T] = ArrayBuilder.make[T]()(m)
./scala/Array.scala:  def empty[T: ClassManifest]: Array[T] = new Array[T](0)
./scala/Array.scala:  def apply[T: ClassManifest](xs: T*): Array[T] = {
./scala/Array.scala:  def ofDim[T: ClassManifest](n1: Int): Array[T] =
./scala/Array.scala:  def ofDim[T: ClassManifest](n1: Int, n2: Int): Array[Array[T]] = {
./scala/Array.scala:  def ofDim[T: ClassManifest](n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]] =
./scala/Array.scala:  def ofDim[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]] =
./scala/Array.scala:  def ofDim[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]] =
./scala/Array.scala:  def concat[T: ClassManifest](xss: Array[T]*): Array[T] = {
./scala/Array.scala:  def fill[T: ClassManifest](n: Int)(elem: => T): Array[T] = {
./scala/Array.scala:  def fill[T: ClassManifest](n1: Int, n2: Int)(elem: => T): Array[Array[T]] =
./scala/Array.scala:  def fill[T: ClassManifest](n1: Int, n2: Int, n3: Int)(elem: => T): Array[Array[Array[T]]] =
./scala/Array.scala:  def fill[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => T): Array[Array[Array[Array[T]]]] =
./scala/Array.scala:  def fill[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => T): Array[Array[Array[Array[Array[T]]]]] =
./scala/Array.scala:  def tabulate[T: ClassManifest](n: Int)(f: Int => T): Array[T] = {
./scala/Array.scala:  def tabulate[T: ClassManifest](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]] =
./scala/Array.scala:  def tabulate[T: ClassManifest](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => T): Array[Array[Array[T]]] =
./scala/Array.scala:  def tabulate[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => T): Array[Array[Array[Array[T]]]] =
./scala/Array.scala:  def tabulate[T: ClassManifest](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => T): Array[Array[Array[Array[Array[T]]]]] =
./scala/Array.scala:  def iterate[T: ClassManifest](start: T, len: Int)(f: T => T): Array[T] = {
./scala/Array.scala:  def make[T: ClassManifest](n: Int, elem: T): Array[T] = {
./scala/Array.scala:  def fromFunction[T: ClassManifest](f: Int => T)(n: Int): Array[T] = {
./scala/Array.scala:  def fromFunction[T: ClassManifest](f: (Int, Int) => T)(n1: Int, n2: Int): Array[Array[T]] =
./scala/Array.scala:  def fromFunction[T: ClassManifest](f: (Int, Int, Int) => T)(n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]] =
./scala/Array.scala:  def fromFunction[T: ClassManifest](f: (Int, Int, Int, Int) => T)(n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]] =
./scala/Array.scala:  def fromFunction[T: ClassManifest](f: (Int, Int, Int, Int, Int) => T)(n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]] =
./scala/collection/generic/ClassManifestTraversableFactory.scala:abstract class ClassManifestTraversableFactory[CC[X] <: Traversable[X] with GenericClassManifestTraversableTemplate[X, CC]]
./scala/collection/generic/ClassManifestTraversableFactory.scala:              extends GenericClassManifestCompanion[CC] {
./scala/collection/generic/ClassManifestTraversableFactory.scala:  class GenericCanBuildFrom[A](implicit manif: ClassManifest[A]) extends CanBuildFrom[CC[_], A, CC[A]] {
./scala/collection/generic/ClassManifestTraversableFactory.scala:    def apply(from: CC[_]) = from.genericClassManifestBuilder[A]
./scala/collection/generic/GenericClassManifestCompanion.scala:/** This class represents companions of classes which require ClassManifests
./scala/collection/generic/GenericClassManifestCompanion.scala:abstract class GenericClassManifestCompanion[+CC[X] <: Traversable[X]] {
./scala/collection/generic/GenericClassManifestCompanion.scala:  def newBuilder[A](implicit ord: ClassManifest[A]): Builder[A, CC[A]]
./scala/collection/generic/GenericClassManifestCompanion.scala:  def empty[A: ClassManifest]: CC[A] = newBuilder[A].result
./scala/collection/generic/GenericClassManifestCompanion.scala:  def apply[A](elems: A*)(implicit ord: ClassManifest[A]): CC[A] = {
./scala/collection/generic/GenericClassManifestTraversableTemplate.scala:trait GenericClassManifestTraversableTemplate[+A, +CC[X] <: Traversable[X]] extends HasNewBuilder[A, CC[A]@uncheckedVariance] {
./scala/collection/generic/GenericClassManifestTraversableTemplate.scala:  implicit protected[this] val manifest: ClassManifest[A]
./scala/collection/generic/GenericClassManifestTraversableTemplate.scala:  def classManifestCompanion: GenericClassManifestCompanion[CC]
./scala/collection/generic/GenericClassManifestTraversableTemplate.scala:  def genericClassManifestBuilder[B](implicit man: ClassManifest[B]): Builder[B, CC[B]] = classManifestCompanion.newBuilder[B]
./scala/collection/generic/TraversableForwarder.scala:  override def toArray[B >: A: ClassManifest]: Array[B] = underlying.toArray
./scala/collection/GenTraversableOnce.scala:   *  @tparam B the type of the elements of the array. A `ClassManifest` for
./scala/collection/GenTraversableOnce.scala:   *           A `ClassManifest` must be available for the element type of this $coll.
./scala/collection/GenTraversableOnce.scala:  def toArray[A1 >: A: ClassManifest]: Array[A1]
./scala/collection/immutable/PagedSeq.scala:  def fromIterator[T: ClassManifest](source: Iterator[T]): PagedSeq[T] =
./scala/collection/immutable/PagedSeq.scala:  def fromIterable[T: ClassManifest](source: Iterable[T]): PagedSeq[T] =
./scala/collection/immutable/PagedSeq.scala: *  @tparam T     the type of the elements contained in this paged sequence, with a `ClassManifest` context bound.
./scala/collection/immutable/PagedSeq.scala:class PagedSeq[T: ClassManifest] protected(
./scala/collection/immutable/PagedSeq.scala:private class Page[T: ClassManifest](val num: Int) {
./scala/collection/immutable/StringLike.scala:  override def toArray[B >: Char : ClassManifest]: Array[B] =
./scala/collection/interfaces/IterableMethods.scala:import scala.reflect.ClassManifest
./scala/collection/interfaces/SeqMethods.scala:import scala.reflect.ClassManifest
./scala/collection/interfaces/SetMethods.scala:import scala.reflect.ClassManifest
./scala/collection/interfaces/TraversableOnceMethods.scala:  def toArray[B >: A : ClassManifest]: Array[B]
./scala/collection/mutable/ArrayBuilder.scala:import scala.reflect.ClassManifest
./scala/collection/mutable/ArrayBuilder.scala:   *  @tparam T     type of the elements for the array builder, with a `ClassManifest` context bound.
./scala/collection/mutable/ArrayBuilder.scala:  def make[T: ClassManifest](): ArrayBuilder[T] =
./scala/collection/mutable/ArrayBuilder.scala:    implicitly[ClassManifest[T]].newArrayBuilder()
./scala/collection/mutable/ArrayBuilder.scala:   *  @tparam T     type of elements for the array builder, subtype of `AnyRef` with a `ClassManifest` context bound.
./scala/collection/mutable/ArrayBuilder.scala:  class ofRef[T <: AnyRef : ClassManifest] extends ArrayBuilder[T] {
./scala/collection/mutable/ArrayOps.scala:import scala.reflect.ClassManifest
./scala/collection/mutable/ArrayOps.scala:      ClassManifest.fromClass(
./scala/collection/mutable/ArrayOps.scala:  override def toArray[U >: T : ClassManifest]: Array[U] =
./scala/collection/mutable/ArrayOps.scala:    if (implicitly[ClassManifest[U]].erasure eq repr.getClass.getComponentType)
./scala/collection/mutable/ArrayOps.scala:  def flatten[U, To](implicit asTrav: T => collection.Traversable[U], m: ClassManifest[U]): Array[U] = {
./scala/collection/mutable/ArrayOps.scala:      ClassManifest.fromClass(
./scala/collection/mutable/ArrayOps.scala:      ClassManifest.classType[T](repr.getClass.getComponentType))
./scala/collection/mutable/ArrayStack.scala:  def apply[A: ClassManifest](elems: A*): ArrayStack[A]= {
./scala/collection/mutable/UnrolledBuffer.scala:class UnrolledBuffer[T](implicit val manifest: ClassManifest[T])
./scala/collection/mutable/UnrolledBuffer.scala:   with GenericClassManifestTraversableTemplate[T, UnrolledBuffer]
./scala/collection/mutable/UnrolledBuffer.scala:object UnrolledBuffer extends ClassManifestTraversableFactory[UnrolledBuffer] {
./scala/collection/mutable/UnrolledBuffer.scala:  implicit def canBuildFrom[T](implicit m: ClassManifest[T]): CanBuildFrom[Coll, T, UnrolledBuffer[T]] =
./scala/collection/mutable/UnrolledBuffer.scala:  def newBuilder[T](implicit m: ClassManifest[T]): Builder[T, UnrolledBuffer[T]] = new UnrolledBuffer[T]
./scala/collection/mutable/UnrolledBuffer.scala:  class Unrolled[T: ClassManifest] private[collection] (var size: Int, var array: Array[T], var next: Unrolled[T], val buff: UnrolledBuffer[T] = null) {
./scala/collection/mutable/WrappedArray.scala:import scala.reflect.ClassManifest
./scala/collection/mutable/WrappedArray.scala:  def elemManifest: ClassManifest[T]
./scala/collection/mutable/WrappedArray.scala:  override def toArray[U >: T : ClassManifest]: Array[U] =
./scala/collection/mutable/WrappedArray.scala:    if (implicitly[ClassManifest[U]].erasure eq array.getClass.getComponentType)
./scala/collection/mutable/WrappedArray.scala:  implicit def canBuildFrom[T](implicit m: ClassManifest[T]): CanBuildFrom[WrappedArray[_], T, WrappedArray[T]] =
./scala/collection/mutable/WrappedArray.scala:    lazy val elemManifest = ClassManifest.classType[T](array.getClass.getComponentType)
./scala/collection/mutable/WrappedArray.scala:    def elemManifest = ClassManifest.Byte
./scala/collection/mutable/WrappedArray.scala:    def elemManifest = ClassManifest.Short
./scala/collection/mutable/WrappedArray.scala:    def elemManifest = ClassManifest.Char
./scala/collection/mutable/WrappedArray.scala:    def elemManifest = ClassManifest.Int
./scala/collection/mutable/WrappedArray.scala:    def elemManifest = ClassManifest.Long
./scala/collection/mutable/WrappedArray.scala:    def elemManifest = ClassManifest.Float
./scala/collection/mutable/WrappedArray.scala:    def elemManifest = ClassManifest.Double
./scala/collection/mutable/WrappedArray.scala:    def elemManifest = ClassManifest.Boolean
./scala/collection/mutable/WrappedArray.scala:    def elemManifest = ClassManifest.Unit
./scala/collection/mutable/WrappedArrayBuilder.scala:import scala.reflect.ClassManifest
./scala/collection/mutable/WrappedArrayBuilder.scala:class WrappedArrayBuilder[A](manifest: ClassManifest[A]) extends Builder[A, WrappedArray[A]] {
./scala/collection/parallel/mutable/ParArray.scala:  def createFromCopy[T <: AnyRef : ClassManifest](arr: Array[T]): ParArray[T] = {
./scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala:private[mutable] class DoublingUnrolledBuffer[T](implicit m: ClassManifest[T]) extends UnrolledBuffer[T]()(m) {
./scala/collection/parallel/ParIterableLike.scala:      def otherwise(notbody: => Unit)(implicit m: ClassManifest[Cmb]): Unit
./scala/collection/parallel/ParIterableLike.scala:      def otherwise(notbody: => Unit)(implicit m: ClassManifest[Cmb]) {
./scala/collection/parallel/ParIterableLike.scala:  override def toArray[U >: T: ClassManifest]: Array[U] = {
./scala/collection/Traversable.scala:  override def toArray[B >: A : ClassManifest]: Array[B]
./scala/collection/TraversableOnce.scala:  def toArray[B >: A : ClassManifest]: Array[B] = {
./scala/collection/TraversableProxyLike.scala:  override def toArray[B >: A: ClassManifest]: Array[B] = self.toArray
./scala/Predef.scala:  type ClassManifest[T] = scala.reflect.ClassManifest[T]
./scala/Predef.scala:  val ClassManifest     = scala.reflect.ClassManifest
./scala/Predef.scala:  def classManifest[T](implicit m: ClassManifest[T]) = m
./scala/reflect/ClassManifest.scala:/** A ClassManifest[T] is an opaque descriptor for type T.
./scala/reflect/ClassManifest.scala:trait ClassManifest[T] extends OptManifest[T] with Equals with Serializable {
./scala/reflect/ClassManifest.scala:    case (x: ClassManifest[_], y: ClassManifest[_]) => x <:< y
./scala/reflect/ClassManifest.scala:  def <:<(that: ClassManifest[_]): Boolean = {
./scala/reflect/ClassManifest.scala:  def >:>(that: ClassManifest[_]): Boolean =
./scala/reflect/ClassManifest.scala:    case _: ClassManifest[_]  => true
./scala/reflect/ClassManifest.scala:    case m: ClassManifest[_] => (m canEqual this) && (this.erasure == m.erasure)
./scala/reflect/ClassManifest.scala:  def arrayManifest: ClassManifest[Array[T]] =
./scala/reflect/ClassManifest.scala:    ClassManifest.classType[Array[T]](arrayClass[T](erasure))
./scala/reflect/ClassManifest.scala:    new ArrayBuilder.ofRef[T with AnyRef]()(this.asInstanceOf[ClassManifest[T with AnyRef]]).asInstanceOf[ArrayBuilder[T]]
./scala/reflect/ClassManifest.scala:    else if (erasure.isArray) "["+ClassManifest.fromClass(erasure.getComponentType)+"]"
./scala/reflect/ClassManifest.scala:/** The object ClassManifest defines factory methods for manifests.
./scala/reflect/ClassManifest.scala:object ClassManifest {
./scala/reflect/ClassManifest.scala:  def fromClass[T](clazz: JClass[T]): ClassManifest[T] = clazz match {
./scala/reflect/ClassManifest.scala:    case java.lang.Byte.TYPE      => Byte.asInstanceOf[ClassManifest[T]]
./scala/reflect/ClassManifest.scala:    case java.lang.Short.TYPE     => Short.asInstanceOf[ClassManifest[T]]
./scala/reflect/ClassManifest.scala:    case java.lang.Character.TYPE => Char.asInstanceOf[ClassManifest[T]]
./scala/reflect/ClassManifest.scala:    case java.lang.Integer.TYPE   => Int.asInstanceOf[ClassManifest[T]]
./scala/reflect/ClassManifest.scala:    case java.lang.Long.TYPE      => Long.asInstanceOf[ClassManifest[T]]
./scala/reflect/ClassManifest.scala:    case java.lang.Float.TYPE     => Float.asInstanceOf[ClassManifest[T]]
./scala/reflect/ClassManifest.scala:    case java.lang.Double.TYPE    => Double.asInstanceOf[ClassManifest[T]]
./scala/reflect/ClassManifest.scala:    case java.lang.Boolean.TYPE   => Boolean.asInstanceOf[ClassManifest[T]]
./scala/reflect/ClassManifest.scala:    case java.lang.Void.TYPE      => Unit.asInstanceOf[ClassManifest[T]]
./scala/reflect/ClassManifest.scala:    case _                        => classType[T with AnyRef](clazz).asInstanceOf[ClassManifest[T]]
./scala/reflect/ClassManifest.scala:  /** ClassManifest for the class type `clazz', where `clazz' is
./scala/reflect/ClassManifest.scala:  def classType[T <: AnyRef](clazz: JClass[_]): ClassManifest[T] =
./scala/reflect/ClassManifest.scala:  /** ClassManifest for the class type `clazz[args]', where `clazz' is
./scala/reflect/ClassManifest.scala:  def classType[T <: AnyRef](clazz: JClass[_], arg1: OptManifest[_], args: OptManifest[_]*): ClassManifest[T] =
./scala/reflect/ClassManifest.scala:  /** ClassManifest for the class type `clazz[args]', where `clazz' is
./scala/reflect/ClassManifest.scala:  def classType[T <: AnyRef](prefix: OptManifest[_], clazz: JClass[_], args: OptManifest[_]*): ClassManifest[T] =
./scala/reflect/ClassManifest.scala:  def arrayType[T](arg: OptManifest[_]): ClassManifest[Array[T]] = arg match {
./scala/reflect/ClassManifest.scala:    case NoManifest => Object.asInstanceOf[ClassManifest[Array[T]]]
./scala/reflect/ClassManifest.scala:    case m: ClassManifest[_] => m.asInstanceOf[ClassManifest[T]].arrayManifest
./scala/reflect/ClassManifest.scala:  /** ClassManifest for the abstract type `prefix # name'. `upperBound' is not
./scala/reflect/ClassManifest.scala:  def abstractType[T](prefix: OptManifest[_], name: String, clazz: JClass[_], args: OptManifest[_]*): ClassManifest[T] =
./scala/reflect/ClassManifest.scala:    new ClassManifest[T] {
./scala/reflect/ClassManifest.scala:  /** ClassManifest for the abstract type `prefix # name'. `upperBound' is not
./scala/reflect/ClassManifest.scala:  def abstractType[T](prefix: OptManifest[_], name: String, upperbound: ClassManifest[_], args: OptManifest[_]*): ClassManifest[T] =
./scala/reflect/ClassManifest.scala:    new ClassManifest[T] {
./scala/reflect/ClassManifest.scala:  override val typeArguments: List[OptManifest[_]]) extends ClassManifest[T]
./scala/reflect/generic/AnnotationInfos.scala:  implicit def classfileAnnotArgManifest: ClassManifest[ClassfileAnnotArg] // need a precise manifest to pass to UnPickle's toArray call
./scala/reflect/Manifest.scala:  def methods[T: ClassManifest] = classManifest[T].erasure.getMethods
./scala/reflect/Manifest.scala:  def retType[T: ClassManifest](name: String) =
./scala/reflect/Manifest.scala:trait Manifest[T] extends ClassManifest[T] with Equals {
./scala/reflect/Manifest.scala:  override def <:<(that: ClassManifest[_]): Boolean =
./scala/reflect/Manifest.scala:    override def <:<(that: ClassManifest[_]): Boolean = (that eq this)
./scala/reflect/Manifest.scala:    override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any)
./scala/reflect/Manifest.scala:    override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any)
./scala/reflect/Manifest.scala:    override def <:<(that: ClassManifest[_]): Boolean =
./scala/reflect/Manifest.scala:    override def <:<(that: ClassManifest[_]): Boolean = (that ne null)
./scala/runtime/ScalaRunTime.scala:import scala.reflect.ClassManifest
./scala/util/control/Exception.scala:  def mkCatcher[Ex <: Throwable: ClassManifest, T](isDef: Ex => Boolean, f: Ex => T) = new Catcher[T] {
./scala/util/control/Exception.scala:  implicit def throwableSubtypeToCatcher[Ex <: Throwable: ClassManifest, T](pf: PartialFunction[Ex, T]) =
./scala/util/Marshal.scala:  import scala.reflect.ClassManifest
./scala/util/Marshal.scala:  def dump[A](o: A)(implicit m: ClassManifest[A]): Array[Byte] = {
./scala/util/Marshal.scala:  def load[A](buffer: Array[Byte])(implicit expected: ClassManifest[A]): A = {
./scala/util/Marshal.scala:    val found = in.readObject.asInstanceOf[ClassManifest[_]]
./scala/util/Sorting.scala:import scala.reflect.ClassManifest
./scala/util/Sorting.scala:  def stableSort[K: ClassManifest: Ordering](a: Array[K]) {
./scala/util/Sorting.scala:  def stableSort[K: ClassManifest](a: Array[K], f: (K, K) => Boolean) {
./scala/util/Sorting.scala:  def stableSort[K: ClassManifest](a: Seq[K], f: (K, K) => Boolean): Array[K] = {
./scala/util/Sorting.scala:  def stableSort[K: ClassManifest: Ordering](a: Seq[K]): Array[K] =
./scala/util/Sorting.scala:  def stableSort[K: ClassManifest, M: Ordering](a: Seq[K], f: K => M): Array[K] =
./scala/util/Sorting.scala:    stableSort(a)(implicitly[ClassManifest[K]], Ordering[M] on f)
./scala/util/Sorting.scala:  private def stableSort[K : ClassManifest](a: Array[K], lo: Int, hi: Int, scratch: Array[K], f: (K,K) => Boolean) {