member-scraping-app

0.test.scala

object Test {
  def main(args: Array[String]): Unit = {
    val settings = new scala.tools.nsc.Settings(msg => throw sys.error(msg))
    settings.classpath.value = "/Users/jason/scala/2.11/lib/scala-library.jar"
    val compiler = new scala.tools.nsc.Global(settings)
    import compiler._, definitions._
    new compiler.Run()

    def explode(p: Symbol): Stream[Symbol] = {
      val members =
        if (p.isClass) p.info.decls.toStream.filterNot(_.initialize.isJava).filterNot(_.isImplClass).flatMap(explode)
        else if (p.isPackage || p.isModule) explode(p.moduleClass)
        else Stream()
      Stream(p) ++ members
    }

    val coll = findMemberFromRoot(TermName("scala.collection"))
    val members = explode(coll)
    settings.debug.value = true
    members foreach { mem =>
      definitions.fullyInitializeSymbol(mem)
      println("  " * mem.ownerChain.length + (if (mem.isClass || mem.isModule) (mem.kindString + " " + mem.name.decoded) else mem.defString))
    }
    settings.debug.value = false
  }
}

1.out.log

      package collection
      package class collection
        class :+
        module :+
        module class :+
          <method> def <init>(): collection.this.$colon$plus.type
          <method> def unapply[T, Coll <: collection.this.SeqLike[T,Coll]](<param> t: Coll with collection.this.SeqLike[T,Coll]{}): scala.this.Option[scala.this.Tuple2[Coll,T]]
        class +:
        module +:
        module class +:
          <method> def <init>(): collection.this.$plus$colon.type
          <method> def unapply[T, Coll <: collection.this.SeqLike[T,Coll]](<param> t: Coll with collection.this.SeqLike[T,Coll]{}): scala.this.Option[scala.this.Tuple2[T,Coll]]
        class AbstractIterable
          <method> def <init>(): collection.this.AbstractIterable[A]
        module AbstractIterable
        module class AbstractIterable
        class AbstractIterator
          <method> def <init>(): collection.this.AbstractIterator[A]
        module AbstractIterator
        module class AbstractIterator
        class AbstractMap
          <method> def <init>(): collection.this.AbstractMap[A,B]
        module AbstractMap
        module class AbstractMap
        class AbstractSeq
          <method> def <init>(): collection.this.AbstractSeq[A]
        module AbstractSeq
        module class AbstractSeq
        class AbstractSet
          <method> def <init>(): collection.this.AbstractSet[A]
        module AbstractSet
        module class AbstractSet
        class AbstractTraversable
          <method> def <init>(): collection.this.AbstractTraversable[A]
        module AbstractTraversable
        module class AbstractTraversable
        trait BitSet
          <method> def $init$(): scala.this.Unit
          <method> override def empty: collection.this.BitSet
        module BitSet
        module class BitSet
          <method> def <init>(): collection.this.BitSet.type
          <method> <stable> <accessor> val empty: collection.this.BitSet
          private[this] val empty : collection.this.BitSet
          <method> def newBuilder: mutable.this.Builder[scala.this.Int,immutable.this.BitSet]
          <method> implicit def canBuildFrom: generic.this.CanBuildFrom[collection.this.BitSet,scala.this.Int,collection.this.BitSet]
        trait BitSetLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def empty: This
          <method> <deferred> protected def nwords: scala.this.Int
          <method> <deferred> protected def word(<param> idx: scala.this.Int): scala.this.Long
          <method> <deferred> protected def fromBitMaskNoCopy(<param> elems: scala.this.Array[scala.this.Long]): This
          <method> def toBitMask: scala.this.Array[scala.this.Long]
          <method> override def size: scala.this.Int
          <method> override def isEmpty: scala.this.Boolean
          <method> implicit def ordering: scala.this.Ordering[scala.this.Int]
          <method> def rangeImpl(<param> from: scala.this.Option[scala.this.Int],<param> until: scala.this.Option[scala.this.Int]): This
          <method> def iterator: collection.this.Iterator[scala.this.Int]
          <method> override def keysIteratorFrom(<param> start: scala.this.Int): collection.this.AbstractIterator[scala.this.Int]
          <method> override def foreach[B](<param> f: scala.this.Function1[scala.this.Int,B]): scala.this.Unit
          <method> def $bar(<param> other: collection.this.BitSet): This
          <method> def $amp(<param> other: collection.this.BitSet): This
          <method> def $amp$tilde(<param> other: collection.this.BitSet): This
          <method> def $up(<param> other: collection.this.BitSet): This
          <method> def contains(<param> elem: scala.this.Int): scala.this.Boolean
          <method> def subsetOf(<param> other: collection.this.BitSet): scala.this.Boolean
          <method> override def addString(<param> sb: mutable.this.StringBuilder,<param> start: String,<param> sep: String,<param> end: String): mutable.this.StringBuilder
          <method> override def stringPrefix: lang.this.String
        module BitSetLike
        module class BitSetLike
          <method> def <init>(): collection.this.BitSetLike.type
          <method> final <stable> <accessor> private[package class collection] val LogWL: scala.this.Int(6)
          final private[this] val LogWL : scala.this.Int(6)
          <method> final <stable> <accessor> private val WordLength: scala.this.Int(64)
          final private[this] val WordLength : scala.this.Int(64)
          <method> final <stable> <accessor> private[package class collection] val MaxSize: scala.this.Int(33554432)
          final private[this] val MaxSize : scala.this.Int(33554432)
          <method> private[package class collection] def updateArray(<param> elems: scala.this.Array[scala.this.Long],<param> idx: scala.this.Int,<param> w: scala.this.Long): scala.this.Array[scala.this.Long]
        trait BufferedIterator
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def head: A
          <method> override def buffered: BufferedIterator.this.type
        module BufferedIterator
        module class BufferedIterator
        trait CustomParallelizable
          <method> def $init$(): scala.this.Unit
          <method> <deferred> override def par: ParRepr
          <method> override protected[this] def parCombiner: parallel.this.Combiner[A,ParRepr]
        module CustomParallelizable
        module class CustomParallelizable
        class DebugUtils
        module DebugUtils
        module class DebugUtils
          <method> def <init>(): collection.this.DebugUtils.type
          <method> def unsupported(<param> msg: String): scala.this.Nothing
          <method> def noSuchElement(<param> msg: String): scala.this.Nothing
          <method> def indexOutOfBounds(<param> index: scala.this.Int): scala.this.Nothing
          <method> def illegalArgument(<param> msg: String): scala.this.Nothing
          <method> def buildString(<param> closure: scala.this.Function1[scala.this.Function1[scala.this.Any,scala.this.Unit],scala.this.Unit]): String
          <method> def arrayString[T](<param> array: scala.this.Array[T],<param> from: scala.this.Int,<param> until: scala.this.Int): String
        trait DefaultMap
          <method> def $init$(): scala.this.Unit
          <method> override def $plus[B1 >: B](<param> kv: scala.this.Tuple2[A,B1]): collection.this.Map[A,B1]
          <method> override def $minus(<param> key: A): collection.this.Map[A,B]
        module DefaultMap
        module class DefaultMap
        trait GenIterable
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def seq: collection.this.Iterable[A]
          <method> override def companion: generic.this.GenericCompanion[collection.this.GenIterable]
        module GenIterable
        module class GenIterable
          <method> def <init>(): collection.this.GenIterable.type
          <method> implicit def canBuildFrom[A]: GenIterable.this.GenericCanBuildFrom[A]
          <method> def newBuilder[A]: mutable.this.Builder[A,collection.this.Iterable[A]]
        trait GenIterableLike
          <method> <deferred> def iterator: collection.this.Iterator[A]
          <method> <deferred> def sameElements[A1 >: A](<param> that: collection.this.GenIterable[A1]): scala.this.Boolean
          <method> <deferred> def zip[A1 >: A, B, That](<param> that: collection.this.GenIterable[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,B],That]): That
          <method> <deferred> def zipWithIndex[A1 >: A, That](implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,scala.this.Int],That]): That
          <method> <deferred> def zipAll[B, A1 >: A, That](<param> that: collection.this.GenIterable[B],<param> thisElem: A1,<param> thatElem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,B],That]): That
        module GenIterableLike
        module class GenIterableLike
        trait GenMap
          <method> <deferred> def seq: collection.this.Map[A,B]
          <method> <deferred> def updated[B1 >: B](<param> key: A,<param> value: B1): collection.this.GenMap[A,B1]
        module GenMap
        module class GenMap
          <method> def <init>(): collection.this.GenMap.type
          <method> def empty[A, B]: immutable.this.Map[A,B]
          <method> implicit def canBuildFrom[A, B]: generic.this.CanBuildFrom[GenMap.this.Coll,scala.this.Tuple2[A,B],collection.this.GenMap[A,B]]
        trait GenMapLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def default(<param> key: A): B
          <method> <deferred> def get(<param> key: A): scala.this.Option[B]
          <method> <deferred> def apply(<param> key: A): B
          <method> <deferred> def seq: collection.this.Map[A,B]
          <method> <deferred> def $plus[B1 >: B](<param> kv: scala.this.Tuple2[A,B1]): collection.this.GenMap[A,B1]
          <method> <deferred> def $minus(<param> key: A): Repr
          <method> override def hashCode(): scala.this.Int
          <method> <deferred> def getOrElse[B1 >: B](<param> key: A,<param> <bynameparam> default: scala.this.<byname>[B1]): B1
          <method> <deferred> def contains(<param> key: A): scala.this.Boolean
          <method> <deferred> def isDefinedAt(<param> key: A): scala.this.Boolean
          <method> <deferred> def keySet: collection.this.GenSet[A]
          <method> <deferred> def keys: collection.this.GenIterable[A]
          <method> <deferred> def values: collection.this.GenIterable[B]
          <method> <deferred> def keysIterator: collection.this.Iterator[A]
          <method> <deferred> def valuesIterator: collection.this.Iterator[B]
          <method> <deferred> def filterKeys(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.GenMap[A,B]
          <method> <deferred> def mapValues[C](<param> f: scala.this.Function1[B,C]): collection.this.GenMap[A,C]
          <method> override def equals(<param> that: scala.this.Any): scala.this.Boolean
        module GenMapLike
        module class GenMapLike
        trait GenSeq
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def seq: collection.this.Seq[A]
          <method> override def companion: generic.this.GenericCompanion[collection.this.GenSeq]
        module GenSeq
        module class GenSeq
          <method> def <init>(): collection.this.GenSeq.type
          <method> implicit def canBuildFrom[A]: GenSeq.this.GenericCanBuildFrom[A]
          <method> def newBuilder[A]: mutable.this.Builder[A,collection.this.Seq[A]]
        trait GenSeqLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def seq: collection.this.Seq[A]
          <method> <deferred> def apply(<param> idx: scala.this.Int): A
          <method> <deferred> def length: scala.this.Int
          <method> def isDefinedAt(<param> idx: scala.this.Int): scala.this.Boolean
          <method> <deferred> def segmentLength(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> from: scala.this.Int): scala.this.Int
          <method> def prefixLength(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Int
          <method> <deferred> def indexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> from: scala.this.Int): scala.this.Int
          <method> def indexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Int
          <method> def indexOf[B >: A](<param> elem: B): scala.this.Int
          <method> def indexOf[B >: A](<param> elem: B,<param> from: scala.this.Int): scala.this.Int
          <method> def lastIndexOf[B >: A](<param> elem: B): scala.this.Int
          <method> def lastIndexOf[B >: A](<param> elem: B,<param> end: scala.this.Int): scala.this.Int
          <method> def lastIndexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Int
          <method> <deferred> def lastIndexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> end: scala.this.Int): scala.this.Int
          <method> <deferred> def reverse: Repr
          <method> <deferred> def reverseMap[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def startsWith[B](<param> that: collection.this.GenSeq[B]): scala.this.Boolean
          <method> <deferred> def startsWith[B](<param> that: collection.this.GenSeq[B],<param> offset: scala.this.Int): scala.this.Boolean
          <method> <deferred> def endsWith[B](<param> that: collection.this.GenSeq[B]): scala.this.Boolean
          <method> <deferred> def patch[B >: A, That](<param> from: scala.this.Int,<param> patch: collection.this.GenSeq[B],<param> replaced: scala.this.Int)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def updated[B >: A, That](<param> index: scala.this.Int,<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def $plus$colon[B >: A, That](<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def $colon$plus[B >: A, That](<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def padTo[B >: A, That](<param> len: scala.this.Int,<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def corresponds[B](<param> that: collection.this.GenSeq[B])(<param> p: scala.this.Function2[A,B,scala.this.Boolean]): scala.this.Boolean
          <method> <deferred> def toSeq: collection.this.GenSeq[A]
          <method> def union[B >: A, That](<param> that: collection.this.GenSeq[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def diff[B >: A](<param> that: collection.this.GenSeq[B]): Repr
          <method> <deferred> def intersect[B >: A](<param> that: collection.this.GenSeq[B]): Repr
          <method> <deferred> def distinct: Repr
          <method> override def hashCode(): scala.this.Int
          <method> override def equals(<param> that: scala.this.Any): scala.this.Boolean
        module GenSeqLike
        module class GenSeqLike
        trait GenSet
          <method> def $init$(): scala.this.Unit
          <method> override def companion: generic.this.GenericCompanion[collection.this.GenSet]
          <method> <deferred> def seq: collection.this.Set[A]
        module GenSet
        module class GenSet
          <method> def <init>(): collection.this.GenSet.type
          <method> implicit def canBuildFrom[A]: GenSet.this.GenericCanBuildFrom[A]
          <method> def newBuilder[A]: mutable.this.Builder[A,immutable.this.Set[A]]
        trait GenSetLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def iterator: collection.this.Iterator[A]
          <method> <deferred> def contains(<param> elem: A): scala.this.Boolean
          <method> <deferred> def $plus(<param> elem: A): Repr
          <method> <deferred> def $minus(<param> elem: A): Repr
          <method> <deferred> def seq: collection.this.Set[A]
          <method> def apply(<param> elem: A): scala.this.Boolean
          <method> def intersect(<param> that: collection.this.GenSet[A]): Repr
          <method> def $amp(<param> that: collection.this.GenSet[A]): Repr
          <method> <deferred> def union(<param> that: collection.this.GenSet[A]): Repr
          <method> def $bar(<param> that: collection.this.GenSet[A]): Repr
          <method> <deferred> def diff(<param> that: collection.this.GenSet[A]): Repr
          <method> def $amp$tilde(<param> that: collection.this.GenSet[A]): Repr
          <method> def subsetOf(<param> that: collection.this.GenSet[A]): scala.this.Boolean
          <method> override def equals(<param> that: scala.this.Any): scala.this.Boolean
          <method> override def hashCode(): scala.this.Int
        module GenSetLike
        module class GenSetLike
        trait GenTraversable
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def seq: collection.this.Traversable[A]
          <method> def companion: generic.this.GenericCompanion[collection.this.GenTraversable]
        module GenTraversable
        module class GenTraversable
          <method> def <init>(): collection.this.GenTraversable.type
          <method> implicit def canBuildFrom[A]: GenTraversable.this.GenericCanBuildFrom[A]
          <method> def newBuilder[A]: mutable.this.Builder[A,collection.this.Traversable[A]]
        trait GenTraversableLike
          <method> <deferred> def repr: Repr
          <method> <deferred> def size: scala.this.Int
          <method> <deferred> def head: A
          <method> <deferred> def headOption: scala.this.Option[A]
          <method> <deferred> def isTraversableAgain: scala.this.Boolean
          <method> <deferred> def tail: Repr
          <method> <deferred> def last: A
          <method> <deferred> def lastOption: scala.this.Option[A]
          <method> <deferred> def init: Repr
          <method> <deferred> def scan[B >: A, That](<param> z: B)(<param> op: scala.this.Function2[B,B,B])(implicit <param> cbf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def scanLeft[B, That](<param> z: B)(<param> op: scala.this.Function2[B,A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def scanRight[B, That](<param> z: B)(<param> op: scala.this.Function2[A,B,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
          <method> <deferred> def map[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def collect[B, That](<param> pf: scala.this.PartialFunction[A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def flatMap[B, That](<param> f: scala.this.Function1[A,collection.this.GenTraversableOnce[B]])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def $plus$plus[B >: A, That](<param> that: collection.this.GenTraversableOnce[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> <deferred> def filter(<param> pred: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> <deferred> def filterNot(<param> pred: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> <deferred> def partition(<param> pred: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[Repr,Repr]
          <method> <deferred> def groupBy[K](<param> f: scala.this.Function1[A,K]): collection.this.GenMap[K,Repr]
          <method> <deferred> def take(<param> n: scala.this.Int): Repr
          <method> <deferred> def drop(<param> n: scala.this.Int): Repr
          <method> <deferred> def slice(<param> unc_from: scala.this.Int,<param> unc_until: scala.this.Int): Repr
          <method> <deferred> def splitAt(<param> n: scala.this.Int): scala.this.Tuple2[Repr,Repr]
          <method> <deferred> def takeWhile(<param> pred: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> <deferred> def span(<param> pred: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[Repr,Repr]
          <method> <deferred> def dropWhile(<param> pred: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> <deferred> def stringPrefix: String
        module GenTraversableLike
        module class GenTraversableLike
        trait GenTraversableOnce
          <method> <deferred> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
          <method> <deferred> def hasDefiniteSize: scala.this.Boolean
          <method> <deferred> def seq: collection.this.TraversableOnce[A]
          <method> <deferred> def size: scala.this.Int
          <method> <deferred> def isEmpty: scala.this.Boolean
          <method> <deferred> def nonEmpty: scala.this.Boolean
          <method> <deferred> def isTraversableAgain: scala.this.Boolean
          <method> <deferred> def reduce[A1 >: A](<param> op: scala.this.Function2[A1,A1,A1]): A1
          <method> <deferred> def reduceOption[A1 >: A](<param> op: scala.this.Function2[A1,A1,A1]): scala.this.Option[A1]
          <method> <deferred> def fold[A1 >: A](<param> z: A1)(<param> op: scala.this.Function2[A1,A1,A1]): A1
          <method> <deferred> def $div$colon[B](<param> z: B)(<param> op: scala.this.Function2[B,A,B]): B
          <method> <deferred> def $colon$bslash[B](<param> z: B)(<param> op: scala.this.Function2[A,B,B]): B
          <method> <deferred> def foldLeft[B](<param> z: B)(<param> op: scala.this.Function2[B,A,B]): B
          <method> <deferred> def foldRight[B](<param> z: B)(<param> op: scala.this.Function2[A,B,B]): B
          <method> <deferred> def aggregate[B](<param> <bynameparam> z: scala.this.<byname>[B])(<param> seqop: scala.this.Function2[B,A,B],<param> combop: scala.this.Function2[B,B,B]): B
          <method> <deferred> def reduceRight[B >: A](<param> op: scala.this.Function2[A,B,B]): B
          <method> <deferred> def reduceLeftOption[B >: A](<param> op: scala.this.Function2[B,A,B]): scala.this.Option[B]
          <method> <deferred> def reduceRightOption[B >: A](<param> op: scala.this.Function2[A,B,B]): scala.this.Option[B]
          <method> <deferred> def count(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Int
          <method> <deferred> def sum[A1 >: A](implicit <param> num: scala.this.Numeric[A1]): A1
          <method> <deferred> def product[A1 >: A](implicit <param> num: scala.this.Numeric[A1]): A1
          <method> <deferred> def min[A1 >: A](implicit <param> ord: scala.this.Ordering[A1]): A
          <method> <deferred> def max[A1 >: A](implicit <param> ord: scala.this.Ordering[A1]): A
          <method> <deferred> def maxBy[B](<param> f: scala.this.Function1[A,B])(implicit <param> cmp: scala.this.Ordering[B]): A
          <method> <deferred> def minBy[B](<param> f: scala.this.Function1[A,B])(implicit <param> cmp: scala.this.Ordering[B]): A
          <method> <deferred> def forall(<param> pred: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> <deferred> def exists(<param> pred: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> <deferred> def find(<param> pred: scala.this.Function1[A,scala.this.Boolean]): scala.this.Option[A]
          <method> <deferred> def copyToArray[B >: A](<param> xs: scala.this.Array[B]): scala.this.Unit
          <method> <deferred> def copyToArray[B >: A](<param> xs: scala.this.Array[B],<param> start: scala.this.Int): scala.this.Unit
          <method> <deferred> def copyToArray[B >: A](<param> xs: scala.this.Array[B],<param> start: scala.this.Int,<param> len: scala.this.Int): scala.this.Unit
          <method> <deferred> def mkString(<param> start: String,<param> sep: String,<param> end: String): String
          <method> <deferred> def mkString(<param> sep: String): String
          <method> <deferred> def mkString: String
          <method> <deferred> def toArray[A1 >: A](implicit <param> <synthetic> evidence$1: reflect.this.ClassTag[A1]): scala.this.Array[A1]
          <method> <deferred> def toList: scala.this.List[A]
          <method> <deferred> def toIndexedSeq: immutable.this.IndexedSeq[A]
          <method> <deferred> def toStream: scala.this.Stream[A]
          <method> <deferred> def toIterator: collection.this.Iterator[A]
          <method> <deferred> def toBuffer[A1 >: A]: mutable.this.Buffer[A1]
          <method> <deferred> def toTraversable: collection.this.GenTraversable[A]
          <method> <deferred> def toIterable: collection.this.GenIterable[A]
          <method> <deferred> def toSeq: collection.this.GenSeq[A]
          <method> <deferred> def toSet[A1 >: A]: collection.this.GenSet[A1]
          <method> <deferred> def toMap[K, V](implicit <param> ev: $less$colon$less[A,scala.this.Tuple2[K,V]]): collection.this.GenMap[K,V]
          <method> <deferred> def toVector: scala.this.Vector[A]
          <method> <deferred> def to[Col[_]](implicit <param> cbf: generic.this.CanBuildFrom[scala.this.Nothing,A,Col[A @unchecked.this.uncheckedVariance]]): Col[A @unchecked.this.uncheckedVariance]
        module GenTraversableOnce
        module class GenTraversableOnce
        trait IndexedSeq
          <method> def $init$(): scala.this.Unit
          <method> override def companion: generic.this.GenericCompanion[collection.this.IndexedSeq]
          <method> override def seq: collection.this.IndexedSeq[A]
        module IndexedSeq
        module class IndexedSeq
          <method> def <init>(): collection.this.IndexedSeq.type
          <method> override <stable> <accessor> val ReusableCBF: IndexedSeq.this.GenericCanBuildFrom[scala.this.Nothing]
          private[this] val ReusableCBF : IndexedSeq.this.GenericCanBuildFrom[scala.this.Nothing]
          <method> def newBuilder[A]: mutable.this.Builder[A,collection.this.IndexedSeq[A]]
          <method> implicit def canBuildFrom[A]: generic.this.CanBuildFrom[IndexedSeq.this.Coll,A,collection.this.IndexedSeq[A]]
        trait IndexedSeqLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def seq: collection.this.IndexedSeq[A]
          <method> override def hashCode(): scala.this.Int
          <method> override protected[this] def thisCollection: collection.this.IndexedSeq[A]
          <method> override protected[this] def toCollection(<param> repr: Repr): collection.this.IndexedSeq[A]
          class Elements
            <paramaccessor> private[this] val start: scala.this.Int
            <paramaccessor> private[this] val end: scala.this.Int
            <method> def <init>(<param> start: scala.this.Int,<param> end: scala.this.Int): IndexedSeqLike.this.Elements
            <method> <accessor> private def index: scala.this.Int
            <method> <accessor> private def index_$eq(<param> <synthetic> x$1: scala.this.Int): scala.this.Unit
            <mutable> private[this] var index : scala.this.Int
            <method> private def available: scala.this.Int
            <method> def hasNext: scala.this.Boolean
            <method> def next(): A
            <method> def head: A
            <method> override def drop(<param> n: scala.this.Int): collection.this.Iterator[A]
            <method> override def take(<param> n: scala.this.Int): collection.this.Iterator[A]
            <method> override def slice(<param> from: scala.this.Int,<param> until: scala.this.Int): collection.this.Iterator[A]
          <method> override def iterator: collection.this.Iterator[A]
          <method> override def toBuffer[A1 >: A]: mutable.this.Buffer[A1]
        module IndexedSeqLike
        module class IndexedSeqLike
        trait IndexedSeqOptimized
          <method> def $init$(): scala.this.Unit
          <method> override def isEmpty: scala.this.Boolean
          <method> override def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
          <method> private def prefixLengthImpl(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> expectTrue: scala.this.Boolean): scala.this.Int
          <method> override def forall(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> override def exists(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> override def find(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Option[A]
          <method> private def foldl[B](<param> start: scala.this.Int,<param> end: scala.this.Int,<param> z: B,<param> op: scala.this.Function2[B,A,B]): B
          <method> private def foldr[B](<param> start: scala.this.Int,<param> end: scala.this.Int,<param> z: B,<param> op: scala.this.Function2[A,B,B]): B
          <method> override def foldLeft[B](<param> z: B)(<param> op: scala.this.Function2[B,A,B]): B
          <method> override def foldRight[B](<param> z: B)(<param> op: scala.this.Function2[A,B,B]): B
          <method> override def reduceLeft[B >: A](<param> op: scala.this.Function2[B,A,B]): B
          <method> override def reduceRight[B >: A](<param> op: scala.this.Function2[A,B,B]): B
          <method> override def zip[A1 >: A, B, That](<param> that: collection.this.GenIterable[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,B],That]): That
          <method> override def zipWithIndex[A1 >: A, That](implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,scala.this.Int],That]): That
          <method> override def slice(<param> from: scala.this.Int,<param> until: scala.this.Int): Repr
          <method> override def head: A
          <method> override def tail: Repr
          <method> override def last: A
          <method> override def init: Repr
          <method> override def take(<param> n: scala.this.Int): Repr
          <method> override def drop(<param> n: scala.this.Int): Repr
          <method> override def takeRight(<param> n: scala.this.Int): Repr
          <method> override def dropRight(<param> n: scala.this.Int): Repr
          <method> override def splitAt(<param> n: scala.this.Int): scala.this.Tuple2[Repr,Repr]
          <method> override def takeWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> override def dropWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> override def span(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[Repr,Repr]
          <method> override def sameElements[B >: A](<param> that: collection.this.GenIterable[B]): scala.this.Boolean
          <method> override def copyToArray[B >: A](<param> xs: scala.this.Array[B],<param> start: scala.this.Int,<param> len: scala.this.Int): scala.this.Unit
          <method> override def lengthCompare(<param> len: scala.this.Int): scala.this.Int
          <method> override def segmentLength(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> from: scala.this.Int): scala.this.Int
          <method> private def negLength(<param> n: scala.this.Int): scala.this.Int
          <method> override def indexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> from: scala.this.Int): scala.this.Int
          <method> override def lastIndexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> end: scala.this.Int): scala.this.Int
          <method> override def reverse: Repr
          <method> override def reverseIterator: collection.this.Iterator[A]
          <method> override def startsWith[B](<param> that: collection.this.GenSeq[B],<param> offset: scala.this.Int): scala.this.Boolean
          <method> override def endsWith[B](<param> that: collection.this.GenSeq[B]): scala.this.Boolean
          <method> <superaccessor> <artifact> private def super$reduceLeft[B >: A](<param> op: scala.this.Function2[B,A,B]): B
          <method> <superaccessor> <artifact> private def super$reduceRight[B >: A](<param> op: scala.this.Function2[A,B,B]): B
          <method> <superaccessor> <artifact> private def super$zip[A1 >: A, B, That](<param> that: collection.this.GenIterable[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,B],That]): That
          <method> <superaccessor> <artifact> private def super$head: A
          <method> <superaccessor> <artifact> private def super$tail: Repr
          <method> <superaccessor> <artifact> private def super$last: A
          <method> <superaccessor> <artifact> private def super$init: Repr
          <method> <superaccessor> <artifact> private def super$sameElements[B >: A](<param> that: collection.this.GenIterable[B]): scala.this.Boolean
          <method> <superaccessor> <artifact> private def super$endsWith[B](<param> that: collection.this.GenSeq[B]): scala.this.Boolean
        module IndexedSeqOptimized
        module class IndexedSeqOptimized
        trait Iterable
          <method> def $init$(): scala.this.Unit
          <method> override def companion: generic.this.GenericCompanion[collection.this.Iterable]
          <method> override def seq: collection.this.Iterable[A]
        module Iterable
        module class Iterable
          <method> def <init>(): collection.this.Iterable.type
          <method> implicit def canBuildFrom[A]: generic.this.CanBuildFrom[Iterable.this.Coll,A,collection.this.Iterable[A]]
          <method> def newBuilder[A]: mutable.this.Builder[A,collection.this.Iterable[A]]
        trait IterableLike
          <method> def $init$(): scala.this.Unit
          <method> override protected[this] def thisCollection: collection.this.Iterable[A]
          <method> override protected[this] def toCollection(<param> repr: Repr): collection.this.Iterable[A]
          <method> <deferred> def iterator: collection.this.Iterator[A]
          <method> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
          <method> override def forall(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> override def exists(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> override def find(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Option[A]
          <method> override def isEmpty: scala.this.Boolean
          <method> override def foldRight[B](<param> z: B)(<param> op: scala.this.Function2[A,B,B]): B
          <method> override def reduceRight[B >: A](<param> op: scala.this.Function2[A,B,B]): B
          <method> override def toIterable: collection.this.Iterable[A]
          <method> override def toIterator: collection.this.Iterator[A]
          <method> override def head: A
          <method> override def slice(<param> from: scala.this.Int,<param> until: scala.this.Int): Repr
          <method> override def take(<param> n: scala.this.Int): Repr
          <method> override def drop(<param> n: scala.this.Int): Repr
          <method> override def takeWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> def grouped(<param> size: scala.this.Int): collection.this.Iterator[Repr]
          <method> def sliding(<param> size: scala.this.Int): collection.this.Iterator[Repr]
          <method> def sliding(<param> size: scala.this.Int,<param> step: scala.this.Int): collection.this.Iterator[Repr]
          <method> def takeRight(<param> n: scala.this.Int): Repr
          <method> def dropRight(<param> n: scala.this.Int): Repr
          <method> override def copyToArray[B >: A](<param> xs: scala.this.Array[B],<param> start: scala.this.Int,<param> len: scala.this.Int): scala.this.Unit
          <method> def zip[A1 >: A, B, That](<param> that: collection.this.GenIterable[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,B],That]): That
          <method> def zipAll[B, A1 >: A, That](<param> that: collection.this.GenIterable[B],<param> thisElem: A1,<param> thatElem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,B],That]): That
          <method> def zipWithIndex[A1 >: A, That](implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,scala.this.Int],That]): That
          <method> def sameElements[B >: A](<param> that: collection.this.GenIterable[B]): scala.this.Boolean
          <method> override def toStream: immutable.this.Stream[A]
          <method> override def canEqual(<param> that: scala.this.Any): scala.this.Boolean
          <method> override def view: collection.this.IterableView[A,Repr]{}
          <method> override def view(<param> from: scala.this.Int,<param> until: scala.this.Int): collection.this.IterableView[A,Repr]
        module IterableLike
        module class IterableLike
        trait IterableProxy
        module IterableProxy
        module class IterableProxy
        trait IterableProxyLike
          <method> def $init$(): scala.this.Unit
          <method> override def iterator: collection.this.Iterator[A]
          <method> override def grouped(<param> size: scala.this.Int): collection.this.Iterator[Repr]
          <method> override def sliding(<param> size: scala.this.Int): collection.this.Iterator[Repr]
          <method> override def sliding(<param> size: scala.this.Int,<param> step: scala.this.Int): collection.this.Iterator[Repr]
          <method> override def takeRight(<param> n: scala.this.Int): Repr
          <method> override def dropRight(<param> n: scala.this.Int): Repr
          <method> override def zip[A1 >: A, B, That](<param> that: collection.this.GenIterable[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,B],That]): That
          <method> override def zipAll[B, A1 >: A, That](<param> that: collection.this.GenIterable[B],<param> thisElem: A1,<param> thatElem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,B],That]): That
          <method> override def zipWithIndex[A1 >: A, That](implicit <param> bf: generic.this.CanBuildFrom[Repr,scala.this.Tuple2[A1,scala.this.Int],That]): That
          <method> override def sameElements[B >: A](<param> that: collection.this.GenIterable[B]): scala.this.Boolean
          <method> override def view: collection.this.IterableView[A,Repr]{}
          <method> override def view(<param> from: scala.this.Int,<param> until: scala.this.Int): collection.this.IterableView[A,Repr]
        module IterableProxyLike
        module class IterableProxyLike
        trait IterableView
        module IterableView
        module class IterableView
          <method> def <init>(): collection.this.IterableView.type
          type Coll = collection.this.TraversableView[_$1,C] forSome { type C <: <?>; type _$1 <: <?> }
          <method> implicit def canBuildFrom[A]: generic.this.CanBuildFrom[IterableView.this.Coll,A,collection.this.IterableView[A,collection.this.Iterable[_$3] forSome { type _$3 <: <?> }]]
        trait IterableViewLike
          <method> def $init$(): scala.this.Unit
          class AbstractTransformed
            <method> def <init>(): IterableViewLike.this.AbstractTransformed[B]
          trait Transformed
            <method> def $init$(): scala.this.Unit
            <method> <deferred> def iterator: collection.this.Iterator[B]
            <method> override def foreach[U](<param> f: scala.this.Function1[B,U]): scala.this.Unit
            <method> override def toString(): lang.this.String
            <method> override def isEmpty: scala.this.Boolean
          trait EmptyView
            <method> def $init$(): scala.this.Unit
            <method> final def iterator: collection.this.Iterator[scala.this.Nothing]
          trait Forced
            <method> def $init$(): scala.this.Unit
            <method> def iterator: collection.this.Iterator[B]
          trait Sliced
            <method> def $init$(): scala.this.Unit
            <method> def iterator: collection.this.Iterator[A]
          trait Mapped
            <method> def $init$(): scala.this.Unit
            <method> def iterator: collection.this.Iterator[B]
          trait FlatMapped
            <method> def $init$(): scala.this.Unit
            <method> def iterator: collection.this.Iterator[B]
          trait Appended
            <method> def $init$(): scala.this.Unit
            <method> def iterator: collection.this.Iterator[B]
          trait Filtered
            <method> def $init$(): scala.this.Unit
            <method> def iterator: collection.this.Iterator[A]
          trait TakenWhile
            <method> def $init$(): scala.this.Unit
            <method> def iterator: collection.this.Iterator[A]
          trait DroppedWhile
            <method> def $init$(): scala.this.Unit
            <method> def iterator: collection.this.Iterator[A]
          trait Zipped
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val other: collection.this.GenIterable[B]
            <method> def iterator: collection.this.Iterator[scala.this.Tuple2[A,B]]
            <method> final override protected[this] def viewIdentifier: lang.this.String
          trait ZippedAll
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val other: collection.this.GenIterable[B]
            <method> <deferred> <stable> <accessor> protected[this] val thisElem: A1
            <method> <deferred> <stable> <accessor> protected[this] val thatElem: B
            <method> final override protected[this] def viewIdentifier: lang.this.String
            <method> def iterator: collection.this.Iterator[scala.this.Tuple2[A1,B]]
          <method> implicit private[this] def asThis(<param> xs: IterableViewLike.this.Transformed[A]): This
          <method> protected def newZipped[B](<param> that: collection.this.GenIterable[B]): IterableViewLike.this.Transformed[scala.this.Tuple2[A,B]]
          <method> protected def newZippedAll[A1 >: A, B](<param> that: collection.this.GenIterable[B],<param> _thisElem: A1,<param> _thatElem: B): IterableViewLike.this.Transformed[scala.this.Tuple2[A1,B]]
          <method> override protected def newForced[B](<param> <bynameparam> xs: scala.this.<byname>[collection.this.GenSeq[B]]): IterableViewLike.this.Transformed[B]
          <method> override protected def newAppended[B >: A](<param> that: collection.this.GenTraversable[B]): IterableViewLike.this.Transformed[B]
          <method> override protected def newMapped[B](<param> f: scala.this.Function1[A,B]): IterableViewLike.this.Transformed[B]
          <method> override protected def newFlatMapped[B](<param> f: scala.this.Function1[A,collection.this.GenTraversableOnce[B]]): IterableViewLike.this.Transformed[B]
          <method> override protected def newFiltered(<param> p: scala.this.Function1[A,scala.this.Boolean]): IterableViewLike.this.Transformed[A]
          <method> override protected def newSliced(<param> _endpoints: generic.this.SliceInterval): IterableViewLike.this.Transformed[A]
          <method> override protected def newDroppedWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): IterableViewLike.this.Transformed[A]
          <method> override protected def newTakenWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): IterableViewLike.this.Transformed[A]
          <method> override protected def newTaken(<param> n: scala.this.Int): IterableViewLike.this.Transformed[A]
          <method> override protected def newDropped(<param> n: scala.this.Int): IterableViewLike.this.Transformed[A]
          <method> override def drop(<param> n: scala.this.Int): This
          <method> override def take(<param> n: scala.this.Int): This
          <method> override def zip[A1 >: A, B, That](<param> that: collection.this.GenIterable[B])(implicit <param> bf: generic.this.CanBuildFrom[This,scala.this.Tuple2[A1,B],That]): That
          <method> override def zipWithIndex[A1 >: A, That](implicit <param> bf: generic.this.CanBuildFrom[This,scala.this.Tuple2[A1,scala.this.Int],That]): That
          <method> override def zipAll[B, A1 >: A, That](<param> that: collection.this.GenIterable[B],<param> thisElem: A1,<param> thatElem: B)(implicit <param> bf: generic.this.CanBuildFrom[This,scala.this.Tuple2[A1,B],That]): That
          <method> override def grouped(<param> size: scala.this.Int): collection.this.Iterator[This]
          <method> override def sliding(<param> size: scala.this.Int,<param> step: scala.this.Int): collection.this.Iterator[This]
          <method> override def sliding(<param> size: scala.this.Int): collection.this.Iterator[This]
          <method> override def dropRight(<param> n: scala.this.Int): This
          <method> override def takeRight(<param> n: scala.this.Int): This
          <method> override def stringPrefix: lang.this.String
        module IterableViewLike
        module class IterableViewLike
        trait Iterator
          <method> def $init$(): scala.this.Unit
          <method> def seq: collection.this.Iterator[A]
          <method> <deferred> def hasNext: scala.this.Boolean
          <method> <deferred> def next(): A
          <method> def isEmpty: scala.this.Boolean
          <method> def isTraversableAgain: scala.this.Boolean
          <method> def hasDefiniteSize: scala.this.Boolean
          <method> def take(<param> n: scala.this.Int): collection.this.Iterator[A]
          <method> def drop(<param> n: scala.this.Int): collection.this.Iterator[A]
          <method> def slice(<param> from: scala.this.Int,<param> until: scala.this.Int): collection.this.Iterator[A]
          <method> def map[B](<param> f: scala.this.Function1[A,B]): collection.this.Iterator[B]
          <method> def $plus$plus[B >: A](<param> <bynameparam> that: scala.this.<byname>[collection.this.GenTraversableOnce[B]]): collection.this.Iterator[B]
          <method> def flatMap[B](<param> f: scala.this.Function1[A,collection.this.GenTraversableOnce[B]]): collection.this.Iterator[B]
          <method> def filter(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.Iterator[A]
          <method> def corresponds[B](<param> that: collection.this.GenTraversableOnce[B])(<param> p: scala.this.Function2[A,B,scala.this.Boolean]): scala.this.Boolean
          <method> def withFilter(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.Iterator[A]
          <method> def filterNot(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.Iterator[A]
          <method> def collect[B](<param> pf: scala.this.PartialFunction[A,B]): collection.this.Iterator[B]
          <method> def scanLeft[B](<param> z: B)(<param> op: scala.this.Function2[B,A,B]): collection.this.Iterator[B]
          <method> def scanRight[B](<param> z: B)(<param> op: scala.this.Function2[A,B,B]): collection.this.Iterator[B]
          <method> def takeWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.Iterator[A]
          <method> def partition(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[collection.this.Iterator[A],collection.this.Iterator[A]]
          <method> def span(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[collection.this.Iterator[A],collection.this.Iterator[A]]
          <method> def dropWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.Iterator[A]
          <method> def zip[B](<param> that: collection.this.Iterator[B]): collection.this.Iterator[scala.this.Tuple2[A,B]]
          <method> def padTo[A1 >: A](<param> len: scala.this.Int,<param> elem: A1): collection.this.Iterator[A1]
          <method> def zipWithIndex: collection.this.Iterator[scala.this.Tuple2[A,scala.this.Int]]
          <method> def zipAll[B, A1 >: A, B1 >: B](<param> that: collection.this.Iterator[B],<param> thisElem: A1,<param> thatElem: B1): collection.this.Iterator[scala.this.Tuple2[A1,B1]]
          <method> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
          <method> def forall(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> def exists(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> def contains(<param> elem: scala.this.Any): scala.this.Boolean
          <method> def find(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Option[A]
          <method> def indexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Int
          <method> def indexOf[B >: A](<param> elem: B): scala.this.Int
          <method> def buffered: collection.this.BufferedIterator[A]
          class GroupedIterator
            <paramaccessor> private[this] val self: collection.this.Iterator[A]
            <paramaccessor> private[this] val size: scala.this.Int
            <paramaccessor> private[this] val step: scala.this.Int
            <method> def <init>(<param> self: collection.this.Iterator[A],<param> size: scala.this.Int,<param> step: scala.this.Int): Iterator.this.GroupedIterator[B]
            <mutable> private[this] var buffer: mutable.this.ArrayBuffer[B]
            <mutable> private[this] var filled: scala.this.Boolean
            <mutable> private[this] var _partial: scala.this.Boolean
            <mutable> private[this] var pad: scala.this.Option[scala.this.Function0[B]]
            <method> def withPadding(<param> <bynameparam> x: scala.this.<byname>[B]): GroupedIterator.this.type
            <method> def withPartial(<param> x: scala.this.Boolean): GroupedIterator.this.type
            <method> private def takeDestructively(<param> size: scala.this.Int): collection.this.Seq[A]
            <method> private def padding(<param> x: scala.this.Int): immutable.this.List[B]
            <method> private def gap: scala.this.Int
            <method> private def go(<param> count: scala.this.Int): scala.this.Boolean
            <method> private def fill(): scala.this.Boolean
            <method> def hasNext: scala.this.Boolean
            <method> def next(): scala.this.List[B]
          <method> def grouped[B >: A](<param> size: scala.this.Int): Iterator.this.GroupedIterator[B]
          <method> def sliding[B >: A](<param> size: scala.this.Int,<param> <defaultparam> step: scala.this.Int): Iterator.this.GroupedIterator[B]
          <method> def length: scala.this.Int
          <method> def duplicate: scala.this.Tuple2[collection.this.Iterator[A],collection.this.Iterator[A]]
          <method> def patch[B >: A](<param> from: scala.this.Int,<param> patchElems: collection.this.Iterator[B],<param> replaced: scala.this.Int): collection.this.Iterator[B]
          <method> def copyToArray[B >: A](<param> xs: scala.this.Array[B],<param> start: scala.this.Int,<param> len: scala.this.Int): scala.this.Unit
          <method> def sameElements(<param> that: collection.this.Iterator[_$1] forSome { type _$1 <: <?> }): scala.this.Boolean
          <method> def toTraversable: collection.this.Traversable[A]
          <method> def toIterator: collection.this.Iterator[A]
          <method> def toStream: immutable.this.Stream[A]
          <method> override def toString(): lang.this.String
          <method> <synthetic> <defaultparam> def sliding$default$2[B >: A]: scala.this.Int @unchecked.this.uncheckedVariance
        module Iterator
        module class Iterator
          <method> def <init>(): collection.this.Iterator.type
          <method> implicit def IteratorCanBuildFrom[A]: collection.this.TraversableOnce.BufferedCanBuildFrom[A,collection.this.Iterator]
          <method> <stable> <accessor> val empty: collection.this.Iterator[scala.this.Nothing]
          private[this] val empty : collection.this.Iterator[scala.this.Nothing]
          <method> def single[A](<param> elem: A): collection.this.Iterator[A]
          <method> def apply[A](<param> elems: scala.this.<repeated>[A]): collection.this.Iterator[A]
          <method> def fill[A](<param> len: scala.this.Int)(<param> <bynameparam> elem: scala.this.<byname>[A]): collection.this.Iterator[A]
          <method> def tabulate[A](<param> end: scala.this.Int)(<param> f: scala.this.Function1[scala.this.Int,A]): collection.this.Iterator[A]
          <method> def range(<param> start: scala.this.Int,<param> end: scala.this.Int): collection.this.Iterator[scala.this.Int]
          <method> def range(<param> start: scala.this.Int,<param> end: scala.this.Int,<param> step: scala.this.Int): collection.this.Iterator[scala.this.Int]
          <method> def iterate[T](<param> start: T)(<param> f: scala.this.Function1[T,T]): collection.this.Iterator[T]
          <method> def from(<param> start: scala.this.Int): collection.this.Iterator[scala.this.Int]
          <method> def from(<param> start: scala.this.Int,<param> step: scala.this.Int): collection.this.Iterator[scala.this.Int]
          <method> def continually[A](<param> <bynameparam> elem: scala.this.<byname>[A]): collection.this.Iterator[A]
          class ConcatIterator
            <mutable> <paramaccessor> private[this] var current: collection.this.Iterator[A]
            <paramaccessor> private[this] val initial: scala.this.Vector[scala.this.Function0[collection.this.Iterator[A]]]
            <method> def <init>(<param> current: collection.this.Iterator[A],<param> initial: scala.this.Vector[scala.this.Function0[collection.this.Iterator[A]]]): Iterator.this.ConcatIterator[A]
            <method> def <init>(<param> initial: scala.this.Vector[scala.this.Function0[collection.this.Iterator[A]]]): Iterator.this.ConcatIterator[A]
            <mutable> private[this] var queue: scala.this.Vector[scala.this.Function0[collection.this.Iterator[A]]]
            <method> private[this] def advance(): scala.this.Boolean
            <method> def hasNext: scala.this.Boolean
            <method> def next(): A
            <method> override def $plus$plus[B >: A](<param> <bynameparam> that: scala.this.<byname>[collection.this.GenTraversableOnce[B]]): collection.this.Iterator[B]
          class JoinIterator
            <paramaccessor> private[this] val lhs: collection.this.Iterator[A]
            <captured> <paramaccessor> private[this] val that: scala.this.<byname>[collection.this.GenTraversableOnce[A]]
            <method> def <init>(<param> lhs: collection.this.Iterator[A],<param> <bynameparam> that: scala.this.<byname>[collection.this.GenTraversableOnce[A]]): Iterator.this.JoinIterator[A]
            <method> <stable> <accessor> lazy private[this] val rhs: collection.this.Iterator[A]
            <mutable> lazy private[this] var rhs : collection.this.Iterator[A]
            <method> def hasNext: scala.this.Boolean
            <method> def next(): A
            <method> override def $plus$plus[B >: A](<param> <bynameparam> that: scala.this.<byname>[collection.this.GenTraversableOnce[B]]): Iterator.this.ConcatIterator[B]
        class JavaConversions
        module JavaConversions
        module class JavaConversions
          <method> def <init>(): collection.this.JavaConversions.type
        class JavaConverters
        module JavaConverters
        module class JavaConverters
          <method> def <init>(): collection.this.JavaConverters.type
        trait LinearSeq
          <method> def $init$(): scala.this.Unit
          <method> override def companion: generic.this.GenericCompanion[collection.this.LinearSeq]
          <method> override def seq: collection.this.LinearSeq[A]
        module LinearSeq
        module class LinearSeq
          <method> def <init>(): collection.this.LinearSeq.type
          <method> implicit def canBuildFrom[A]: generic.this.CanBuildFrom[LinearSeq.this.Coll,A,collection.this.LinearSeq[A]]
          <method> def newBuilder[A]: mutable.this.Builder[A,collection.this.LinearSeq[A]]
        trait LinearSeqLike
          <method> def $init$(): scala.this.Unit
          <method> override protected[this] def thisCollection: collection.this.LinearSeq[A]
          <method> override protected[this] def toCollection(<param> repr: Repr): collection.this.LinearSeq[A]
          <method> <deferred> def seq: collection.this.LinearSeq[A]
          <method> override def hashCode(): scala.this.Int
          <method> override def iterator: collection.this.Iterator[A]
          <method> final override def corresponds[B](<param> that: collection.this.GenSeq[B])(<param> p: scala.this.Function2[A,B,scala.this.Boolean]): scala.this.Boolean
        module LinearSeqLike
        module class LinearSeqLike
        trait LinearSeqOptimized
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def isEmpty: scala.this.Boolean
          <method> <deferred> def head: A
          <method> <deferred> def tail: Repr
          <method> def length: scala.this.Int
          <method> def apply(<param> n: scala.this.Int): A
          <method> override def foreach[B](<param> f: scala.this.Function1[A,B]): scala.this.Unit
          <method> override def forall(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> override def exists(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> override def contains[A1 >: A](<param> elem: A1): scala.this.Boolean
          <method> override def find(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Option[A]
          <method> override def foldLeft[B](<param> z: B)(<param> f: scala.this.Function2[B,A,B]): B
          <method> override def foldRight[B](<param> z: B)(<param> f: scala.this.Function2[A,B,B]): B
          <method> override def reduceLeft[B >: A](<param> f: scala.this.Function2[B,A,B]): B
          <method> override def reduceRight[B >: A](<param> op: scala.this.Function2[A,B,B]): B
          <method> override def last: A
          <method> override def take(<param> n: scala.this.Int): Repr
          <method> override def drop(<param> n: scala.this.Int): Repr
          <method> override def dropRight(<param> n: scala.this.Int): Repr
          <method> override def slice(<param> from: scala.this.Int,<param> until: scala.this.Int): Repr
          <method> override def takeWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> override def span(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[Repr,Repr]
          <method> override def sameElements[B >: A](<param> that: collection.this.GenIterable[B]): scala.this.Boolean
          <method> override def lengthCompare(<param> len: scala.this.Int): scala.this.Int
          <method> override def isDefinedAt(<param> x: scala.this.Int): scala.this.Boolean
          <method> override def segmentLength(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> from: scala.this.Int): scala.this.Int
          <method> override def indexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> from: scala.this.Int): scala.this.Int
          <method> override def lastIndexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> end: scala.this.Int): scala.this.Int
          <method> <superaccessor> <artifact> private def super$sameElements[B >: A](<param> that: collection.this.GenIterable[B]): scala.this.Boolean
        module LinearSeqOptimized
        module class LinearSeqOptimized
        trait Map
          <method> def $init$(): scala.this.Unit
          <method> def empty: collection.this.Map[A,B]
          <method> override def seq: collection.this.Map[A,B]
        module Map
        module class Map
          <method> def <init>(): collection.this.Map.type
          <method> def empty[A, B]: immutable.this.Map[A,B]
          <method> implicit def canBuildFrom[A, B]: generic.this.CanBuildFrom[Map.this.Coll,scala.this.Tuple2[A,B],collection.this.Map[A,B]]
          class WithDefault
            <paramaccessor> private[this] val underlying: collection.this.Map[A,B]
            <paramaccessor> private[this] val d: scala.this.Function1[A,B]
            <method> def <init>(<param> underlying: collection.this.Map[A,B],<param> d: scala.this.Function1[A,B]): Map.this.WithDefault[A,B]
            <method> override def size: scala.this.Int
            <method> def get(<param> key: A): scala.this.Option[B]
            <method> def iterator: collection.this.Iterator[scala.this.Tuple2[A,B]]
            <method> override def default(<param> key: A): B
        trait MapLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def empty: This
          <method> override protected[this] def newBuilder: mutable.this.Builder[scala.this.Tuple2[A,B],This]
          <method> <deferred> def get(<param> key: A): scala.this.Option[B]
          <method> <deferred> def iterator: collection.this.Iterator[scala.this.Tuple2[A,B]]
          <method> <deferred> def $plus[B1 >: B](<param> kv: scala.this.Tuple2[A,B1]): collection.this.Map[A,B1]
          <method> <deferred> def $minus(<param> key: A): This
          <method> override def isEmpty: scala.this.Boolean
          <method> def getOrElse[B1 >: B](<param> key: A,<param> <bynameparam> default: scala.this.<byname>[B1]): B1
          <method> def apply(<param> key: A): B
          <method> def contains(<param> key: A): scala.this.Boolean
          <method> def isDefinedAt(<param> key: A): scala.this.Boolean
          <method> def keySet: collection.this.Set[A]
          class DefaultKeySet
            <method> def <init>(): MapLike.this.DefaultKeySet
            <method> def contains(<param> key: A): scala.this.Boolean
            <method> def iterator: collection.this.Iterator[A]
            <method> def $plus(<param> elem: A): collection.this.Set[A]
            <method> def $minus(<param> elem: A): collection.this.Set[A]
            <method> override def size: scala.this.Int
            <method> override def foreach[C](<param> f: scala.this.Function1[A,C]): scala.this.Unit
          <method> def keysIterator: collection.this.Iterator[A]
          <method> def keys: collection.this.Iterable[A]
          <method> def values: collection.this.Iterable[B]
          class DefaultValuesIterable
            <method> def <init>(): MapLike.this.DefaultValuesIterable
            <method> def iterator: collection.this.Iterator[B]
            <method> override def size: scala.this.Int
            <method> override def foreach[C](<param> f: scala.this.Function1[B,C]): scala.this.Unit
          <method> def valuesIterator: collection.this.Iterator[B]
          <method> def default(<param> key: A): B
          class FilteredKeys
            <paramaccessor> private[this] val p: scala.this.Function1[A,scala.this.Boolean]
            <method> def <init>(<param> p: scala.this.Function1[A,scala.this.Boolean]): MapLike.this.FilteredKeys
            <method> override def foreach[C](<param> f: scala.this.Function1[scala.this.Tuple2[A,B],C]): scala.this.Unit
            <method> def iterator: collection.this.Iterator[scala.this.Tuple2[A,B]]
            <method> override def contains(<param> key: A): scala.this.Boolean
            <method> def get(<param> key: A): scala.this.Option[B]
          <method> def filterKeys(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.Map[A,B]
          class MappedValues
            <paramaccessor> private[this] val f: scala.this.Function1[B,C]
            <method> def <init>(<param> f: scala.this.Function1[B,C]): MapLike.this.MappedValues[C]
            <method> override def foreach[D](<param> g: scala.this.Function1[scala.this.Tuple2[A,C],D]): scala.this.Unit
            <method> def iterator: collection.this.Iterator[scala.this.Tuple2[A,C]]
            <method> override def size: scala.this.Int
            <method> override def contains(<param> key: A): scala.this.Boolean
            <method> def get(<param> key: A): scala.this.Option[C]
          <method> def mapValues[C](<param> f: scala.this.Function1[B,C]): collection.this.Map[A,C]
          <method> def updated[B1 >: B](<param> key: A,<param> value: B1): collection.this.Map[A,B1]
          <method> def $plus[B1 >: B](<param> kv1: scala.this.Tuple2[A,B1],<param> kv2: scala.this.Tuple2[A,B1],<param> kvs: scala.this.<repeated>[scala.this.Tuple2[A,B1]]): collection.this.Map[A,B1]
          <method> def $plus$plus[B1 >: B](<param> xs: collection.this.GenTraversableOnce[scala.this.Tuple2[A,B1]]): collection.this.Map[A,B1]
          <method> override def filterNot(<param> p: scala.this.Function1[scala.this.Tuple2[A,B],scala.this.Boolean]): This
          <method> override def toSeq: collection.this.Seq[scala.this.Tuple2[A,B]]
          <method> override def toBuffer[C >: scala.this.Tuple2[A,B]]: mutable.this.Buffer[C]
          <method> override protected[this] def parCombiner: parallel.this.Combiner[scala.this.Tuple2[A,B],parallel.this.ParMap[A,B]]
          <method> override def addString(<param> b: scala.this.StringBuilder,<param> start: String,<param> sep: String,<param> end: String): scala.this.StringBuilder
          <method> override def stringPrefix: String
          <method> override def toString(): String
        module MapLike
        module class MapLike
        trait MapProxy
        module MapProxy
        module class MapProxy
        trait MapProxyLike
          <method> def $init$(): scala.this.Unit
          <method> override def get(<param> key: A): scala.this.Option[B]
          <method> override def iterator: collection.this.Iterator[scala.this.Tuple2[A,B]]
          <method> override def $plus[B1 >: B](<param> kv: scala.this.Tuple2[A,B1]): collection.this.Map[A,B1]
          <method> override def $minus(<param> key: A): This
          <method> override def isEmpty: scala.this.Boolean
          <method> override def getOrElse[B1 >: B](<param> key: A,<param> <bynameparam> default: scala.this.<byname>[B1]): B1
          <method> override def apply(<param> key: A): B
          <method> override def contains(<param> key: A): scala.this.Boolean
          <method> override def isDefinedAt(<param> key: A): scala.this.Boolean
          <method> override def keySet: collection.this.Set[A]
          <method> override def keysIterator: collection.this.Iterator[A]
          <method> override def keys: collection.this.Iterable[A]
          <method> override def values: collection.this.Iterable[B]
          <method> override def valuesIterator: collection.this.Iterator[B]
          <method> override def default(<param> key: A): B
          <method> override def filterKeys(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.Map[A,B]
          <method> override def mapValues[C](<param> f: scala.this.Function1[B,C]): collection.this.Map[A,C]
          <method> override def updated[B1 >: B](<param> key: A,<param> value: B1): collection.this.Map[A,B1]
          <method> override def $plus[B1 >: B](<param> kv1: scala.this.Tuple2[A,B1],<param> kv2: scala.this.Tuple2[A,B1],<param> kvs: scala.this.<repeated>[scala.this.Tuple2[A,B1]]): collection.this.Map[A,B1]
          <method> override def $plus$plus[B1 >: B](<param> xs: collection.this.GenTraversableOnce[scala.this.Tuple2[A,B1]]): collection.this.Map[A,B1]
          <method> override def filterNot(<param> p: scala.this.Function1[scala.this.Tuple2[A,B],scala.this.Boolean]): This
          <method> override def addString(<param> b: scala.this.StringBuilder,<param> start: String,<param> sep: String,<param> end: String): scala.this.StringBuilder
        module MapProxyLike
        module class MapProxyLike
        package object class package
        package object package
        package object class package
          <method> def <init>(): collection.this.package.type
          <method> def breakOut[From, T, To](implicit <param> b: generic.this.CanBuildFrom[scala.this.Nothing,T,To]): generic.this.CanBuildFrom[From,T,To]
        trait Parallel
        module Parallel
        module class Parallel
        trait Parallelizable
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def seq: collection.this.TraversableOnce[A]
          <method> def par: ParRepr
          <method> <deferred> protected[this] def parCombiner: parallel.this.Combiner[A,ParRepr]
        module Parallelizable
        module class Parallelizable
        class Searching
        module Searching
        module class Searching
          <method> def <init>(): collection.this.Searching.type
          class SearchResult
            <method> def <init>(): Searching.this.SearchResult
            <method> <deferred> def insertionPoint: scala.this.Int
          class Found
            <method> <stable> <caseaccessor> <accessor> <paramaccessor> val foundIndex: scala.this.Int
            <caseaccessor> <paramaccessor> private[this] val foundIndex : scala.this.Int
            <method> def <init>(<param> foundIndex: scala.this.Int): Searching.this.Found
            <method> override def insertionPoint: scala.this.Int
            <method> <synthetic> def copy(<param> <defaultparam> foundIndex: scala.this.Int): Searching.this.Found
            <method> <synthetic> <defaultparam> def copy$default$1: scala.this.Int @unchecked.this.uncheckedVariance
            <method> override <synthetic> def productPrefix: lang.this.String
            <method> <synthetic> def productArity: scala.this.Int
            <method> <synthetic> def productElement(<param> <synthetic> x$1: scala.this.Int): scala.this.Any
            <method> override <synthetic> def productIterator: collection.this.Iterator[scala.this.Any]
            <method> <synthetic> def canEqual(<param> <synthetic> x$1: scala.this.Any): scala.this.Boolean
            <method> override <synthetic> def hashCode(): scala.this.Int
            <method> override <synthetic> def toString(): lang.this.String
            <method> override <synthetic> def equals(<param> <synthetic> x$1: scala.this.Any): scala.this.Boolean
          class InsertionPoint
            <method> <stable> <caseaccessor> <accessor> <paramaccessor> val insertionPoint: scala.this.Int
            <caseaccessor> <paramaccessor> private[this] val insertionPoint : scala.this.Int
            <method> def <init>(<param> insertionPoint: scala.this.Int): Searching.this.InsertionPoint
            <method> <synthetic> def copy(<param> <defaultparam> insertionPoint: scala.this.Int): Searching.this.InsertionPoint
            <method> <synthetic> <defaultparam> def copy$default$1: scala.this.Int @unchecked.this.uncheckedVariance
            <method> override <synthetic> def productPrefix: lang.this.String
            <method> <synthetic> def productArity: scala.this.Int
            <method> <synthetic> def productElement(<param> <synthetic> x$1: scala.this.Int): scala.this.Any
            <method> override <synthetic> def productIterator: collection.this.Iterator[scala.this.Any]
            <method> <synthetic> def canEqual(<param> <synthetic> x$1: scala.this.Any): scala.this.Boolean
            <method> override <synthetic> def hashCode(): scala.this.Int
            <method> override <synthetic> def toString(): lang.this.String
            <method> override <synthetic> def equals(<param> <synthetic> x$1: scala.this.Any): scala.this.Boolean
          module Found
          module class Found
            <method> def <init>(): Searching.this.Found.type
            <method> final override <synthetic> def toString(): lang.this.String
            <method> case <synthetic> def apply(<param> foundIndex: scala.this.Int): Searching.this.Found
            <method> case <synthetic> def unapply(<param> <synthetic> x$0: Searching.this.Found): scala.this.Option[scala.this.Int]
            <method> <synthetic> private def readResolve(): lang.this.Object
          module InsertionPoint
          module class InsertionPoint
            <method> def <init>(): Searching.this.InsertionPoint.type
            <method> final override <synthetic> def toString(): lang.this.String
            <method> case <synthetic> def apply(<param> insertionPoint: scala.this.Int): Searching.this.InsertionPoint
            <method> case <synthetic> def unapply(<param> <synthetic> x$0: Searching.this.InsertionPoint): scala.this.Option[scala.this.Int]
            <method> <synthetic> private def readResolve(): lang.this.Object
          class SearchImpl
            <method> <stable> <accessor> <paramaccessor> val coll: collection.this.SeqLike[A,Repr]
            <paramaccessor> private[this] val coll : collection.this.SeqLike[A,Repr]
            <method> def <init>(<param> coll: collection.this.SeqLike[A,Repr]): Searching.this.SearchImpl[A,Repr]
            <method> final def search[B >: A](<param> elem: B)(implicit <param> ord: math.this.Ordering[B]): Searching.this.SearchResult
            <method> final def search[B >: A](<param> elem: B,<param> from: scala.this.Int,<param> to: scala.this.Int)(implicit <param> ord: math.this.Ordering[B]): Searching.this.SearchResult
            <method> private def binarySearch[B >: A](<param> elem: B,<param> from: scala.this.Int,<param> to: scala.this.Int)(implicit <param> ord: math.this.Ordering[B]): Searching.this.SearchResult
            <method> private def linearSearch[B >: A](<param> c: collection.this.SeqView[A,Repr],<param> elem: B,<param> offset: scala.this.Int)(implicit <param> ord: math.this.Ordering[B]): Searching.this.SearchResult
          <method> implicit def search[Repr, A](<param> coll: Repr)(implicit <param> fr: generic.this.IsSeqLike[Repr]): Searching.this.SearchImpl[fr.A,Repr]
        trait Seq
          <method> def $init$(): scala.this.Unit
          <method> override def companion: generic.this.GenericCompanion[collection.this.Seq]
          <method> override def seq: collection.this.Seq[A]
        module Seq
        module class Seq
          <method> def <init>(): collection.this.Seq.type
          <method> implicit def canBuildFrom[A]: generic.this.CanBuildFrom[Seq.this.Coll,A,collection.this.Seq[A]]
          <method> def newBuilder[A]: mutable.this.Builder[A,collection.this.Seq[A]]
        class SeqExtractors
          <method> def <init>(): collection.this.SeqExtractors
        module SeqExtractors
        module class SeqExtractors
        trait SeqLike
          <method> def $init$(): scala.this.Unit
          <method> override protected[this] def thisCollection: collection.this.Seq[A]
          <method> override protected[this] def toCollection(<param> repr: Repr): collection.this.Seq[A]
          <method> <deferred> def length: scala.this.Int
          <method> <deferred> def apply(<param> idx: scala.this.Int): A
          <method> override protected[this] def parCombiner: parallel.this.Combiner[A,parallel.this.ParSeq[A]]
          <method> def lengthCompare(<param> len: scala.this.Int): scala.this.Int
          <method> override def isEmpty: scala.this.Boolean
          <method> override def size: scala.this.Int
          <method> def segmentLength(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> from: scala.this.Int): scala.this.Int
          <method> def indexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> from: scala.this.Int): scala.this.Int
          <method> def lastIndexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> end: scala.this.Int): scala.this.Int
          <method> def permutations: collection.this.Iterator[Repr]
          <method> def combinations(<param> n: scala.this.Int): collection.this.Iterator[Repr]
          class PermutationsItr
            <method> def <init>(): SeqLike.this.PermutationsItr
            <synthetic> <artifact> private[this] val x$1: scala.this.Tuple2[mutable.this.Buffer[A],scala.this.Array[scala.this.Int]]
            private[this] val elms: mutable.this.Buffer[A]
            private[this] val idxs: scala.this.Array[scala.this.Int]
            <method> <accessor> private def _hasNext: scala.this.Boolean
            <method> <accessor> private def _hasNext_$eq(<param> <synthetic> x$1: scala.this.Boolean): scala.this.Unit
            <mutable> private[this] var _hasNext : scala.this.Boolean
            <method> def hasNext: scala.this.Boolean
            <method> def next(): Repr
            <method> private def swap(<param> i: scala.this.Int,<param> j: scala.this.Int): scala.this.Unit
            <method> private[this] def init(): scala.this.Tuple2[mutable.this.Buffer[A],scala.this.Array[scala.this.Int]]
          class CombinationsItr
            <paramaccessor> private[this] val n: scala.this.Int
            <method> def <init>(<param> n: scala.this.Int): SeqLike.this.CombinationsItr
            <synthetic> <artifact> private[this] val x$4: scala.this.Tuple3[collection.this.IndexedSeq[A],scala.this.Array[scala.this.Int],scala.this.Array[scala.this.Int]]
            <method> <stable> <accessor> private val elms: collection.this.IndexedSeq[A]
            private[this] val elms : collection.this.IndexedSeq[A]
            <method> <stable> <accessor> private val cnts: scala.this.Array[scala.this.Int]
            private[this] val cnts : scala.this.Array[scala.this.Int]
            <method> <stable> <accessor> private val nums: scala.this.Array[scala.this.Int]
            private[this] val nums : scala.this.Array[scala.this.Int]
            <method> <stable> <accessor> private val offs: scala.this.Array[scala.this.Int]
            private[this] val offs : scala.this.Array[scala.this.Int]
            <method> <accessor> private def _hasNext: scala.this.Boolean
            <method> <accessor> private def _hasNext_$eq(<param> <synthetic> x$1: scala.this.Boolean): scala.this.Unit
            <mutable> private[this] var _hasNext : scala.this.Boolean
            <method> def hasNext: scala.this.Boolean
            <method> def next(): Repr
            <method> private def init(): scala.this.Tuple3[collection.this.IndexedSeq[A],scala.this.Array[scala.this.Int],scala.this.Array[scala.this.Int]]
          <method> def reverse: Repr
          <method> def reverseMap[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def reverseIterator: collection.this.Iterator[A]
          <method> def startsWith[B](<param> that: collection.this.GenSeq[B],<param> offset: scala.this.Int): scala.this.Boolean
          <method> def endsWith[B](<param> that: collection.this.GenSeq[B]): scala.this.Boolean
          <method> def indexOfSlice[B >: A](<param> that: collection.this.GenSeq[B]): scala.this.Int
          <method> def indexOfSlice[B >: A](<param> that: collection.this.GenSeq[B],<param> from: scala.this.Int): scala.this.Int
          <method> def lastIndexOfSlice[B >: A](<param> that: collection.this.GenSeq[B]): scala.this.Int
          <method> def lastIndexOfSlice[B >: A](<param> that: collection.this.GenSeq[B],<param> end: scala.this.Int): scala.this.Int
          <method> def containsSlice[B](<param> that: collection.this.GenSeq[B]): scala.this.Boolean
          <method> def contains[A1 >: A](<param> elem: A1): scala.this.Boolean
          <method> override def union[B >: A, That](<param> that: collection.this.GenSeq[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def diff[B >: A](<param> that: collection.this.GenSeq[B]): Repr
          <method> def intersect[B >: A](<param> that: collection.this.GenSeq[B]): Repr
          <method> private def occCounts[B](<param> sq: collection.this.Seq[B]): mutable.this.Map[B,scala.this.Int]
          <method> def distinct: Repr
          <method> def patch[B >: A, That](<param> from: scala.this.Int,<param> patch: collection.this.GenSeq[B],<param> replaced: scala.this.Int)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def updated[B >: A, That](<param> index: scala.this.Int,<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def $plus$colon[B >: A, That](<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def $colon$plus[B >: A, That](<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def padTo[B >: A, That](<param> len: scala.this.Int,<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def corresponds[B](<param> that: collection.this.GenSeq[B])(<param> p: scala.this.Function2[A,B,scala.this.Boolean]): scala.this.Boolean
          <method> def sortWith(<param> lt: scala.this.Function2[A,A,scala.this.Boolean]): Repr
          <method> def sortBy[B](<param> f: scala.this.Function1[A,B])(implicit <param> ord: math.this.Ordering[B]): Repr
          <method> def sorted[B >: A](implicit <param> ord: math.this.Ordering[B]): Repr
          <method> override def toSeq: collection.this.Seq[A]
          <method> def indices: immutable.this.Range
          <method> override def view: collection.this.SeqView[A,Repr]{}
          <method> override def view(<param> from: scala.this.Int,<param> until: scala.this.Int): collection.this.SeqView[A,Repr]
          <method> override def toString(): String
        module SeqLike
        module class SeqLike
          <method> def <init>(): collection.this.SeqLike.type
          <method> private def kmpOptimizeWord[B](<param> W: collection.this.Seq[B],<param> n0: scala.this.Int,<param> n1: scala.this.Int,<param> forward: scala.this.Boolean): collection.this.IndexedSeq[B]
          <method> private def kmpJumpTable[B](<param> Wopt: collection.this.IndexedSeq[B],<param> wlen: scala.this.Int): scala.this.Array[scala.this.Int]
          <method> private def kmpSearch[B](<param> S: collection.this.Seq[B],<param> m0: scala.this.Int,<param> m1: scala.this.Int,<param> W: collection.this.Seq[B],<param> n0: scala.this.Int,<param> n1: scala.this.Int,<param> forward: scala.this.Boolean): scala.this.Int
          <method> def indexOf[B](<param> source: collection.this.Seq[B],<param> sourceOffset: scala.this.Int,<param> sourceCount: scala.this.Int,<param> target: collection.this.Seq[B],<param> targetOffset: scala.this.Int,<param> targetCount: scala.this.Int,<param> fromIndex: scala.this.Int): scala.this.Int
          <method> def lastIndexOf[B](<param> source: collection.this.Seq[B],<param> sourceOffset: scala.this.Int,<param> sourceCount: scala.this.Int,<param> target: collection.this.Seq[B],<param> targetOffset: scala.this.Int,<param> targetCount: scala.this.Int,<param> fromIndex: scala.this.Int): scala.this.Int
        trait SeqProxy
        module SeqProxy
        module class SeqProxy
        trait SeqProxyLike
          <method> def $init$(): scala.this.Unit
          <method> override def size: scala.this.Int
          <method> override def toSeq: collection.this.Seq[A]
          <method> override def length: scala.this.Int
          <method> override def apply(<param> idx: scala.this.Int): A
          <method> override def lengthCompare(<param> len: scala.this.Int): scala.this.Int
          <method> override def isDefinedAt(<param> x: scala.this.Int): scala.this.Boolean
          <method> override def segmentLength(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> from: scala.this.Int): scala.this.Int
          <method> override def prefixLength(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Int
          <method> override def indexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Int
          <method> override def indexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> from: scala.this.Int): scala.this.Int
          <method> override def indexOf[B >: A](<param> elem: B): scala.this.Int
          <method> override def indexOf[B >: A](<param> elem: B,<param> from: scala.this.Int): scala.this.Int
          <method> override def lastIndexOf[B >: A](<param> elem: B): scala.this.Int
          <method> override def lastIndexOf[B >: A](<param> elem: B,<param> end: scala.this.Int): scala.this.Int
          <method> override def lastIndexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Int
          <method> override def lastIndexWhere(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> end: scala.this.Int): scala.this.Int
          <method> override def reverse: Repr
          <method> override def reverseMap[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def reverseIterator: collection.this.Iterator[A]
          <method> override def startsWith[B](<param> that: collection.this.GenSeq[B],<param> offset: scala.this.Int): scala.this.Boolean
          <method> override def startsWith[B](<param> that: collection.this.GenSeq[B]): scala.this.Boolean
          <method> override def endsWith[B](<param> that: collection.this.GenSeq[B]): scala.this.Boolean
          <method> override def indexOfSlice[B >: A](<param> that: collection.this.GenSeq[B]): scala.this.Int
          <method> override def indexOfSlice[B >: A](<param> that: collection.this.GenSeq[B],<param> from: scala.this.Int): scala.this.Int
          <method> override def lastIndexOfSlice[B >: A](<param> that: collection.this.GenSeq[B]): scala.this.Int
          <method> override def lastIndexOfSlice[B >: A](<param> that: collection.this.GenSeq[B],<param> end: scala.this.Int): scala.this.Int
          <method> override def containsSlice[B](<param> that: collection.this.GenSeq[B]): scala.this.Boolean
          <method> override def contains[A1 >: A](<param> elem: A1): scala.this.Boolean
          <method> override def union[B >: A, That](<param> that: collection.this.GenSeq[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def diff[B >: A](<param> that: collection.this.GenSeq[B]): Repr
          <method> override def intersect[B >: A](<param> that: collection.this.GenSeq[B]): Repr
          <method> override def distinct: Repr
          <method> override def patch[B >: A, That](<param> from: scala.this.Int,<param> patch: collection.this.GenSeq[B],<param> replaced: scala.this.Int)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def updated[B >: A, That](<param> index: scala.this.Int,<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def $plus$colon[B >: A, That](<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def $colon$plus[B >: A, That](<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def padTo[B >: A, That](<param> len: scala.this.Int,<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def corresponds[B](<param> that: collection.this.GenSeq[B])(<param> p: scala.this.Function2[A,B,scala.this.Boolean]): scala.this.Boolean
          <method> override def sortWith(<param> lt: scala.this.Function2[A,A,scala.this.Boolean]): Repr
          <method> override def sortBy[B](<param> f: scala.this.Function1[A,B])(implicit <param> ord: scala.this.Ordering[B]): Repr
          <method> override def sorted[B >: A](implicit <param> ord: scala.this.Ordering[B]): Repr
          <method> override def indices: scala.this.Range
          <method> override def view: collection.this.SeqView[A,Repr]{}
          <method> override def view(<param> from: scala.this.Int,<param> until: scala.this.Int): collection.this.SeqView[A,Repr]
        module SeqProxyLike
        module class SeqProxyLike
        trait SeqView
        module SeqView
        module class SeqView
          <method> def <init>(): collection.this.SeqView.type
          type Coll = collection.this.TraversableView[_$1,C] forSome { type C <: <?>; type _$1 <: <?> }
          <method> implicit def canBuildFrom[A]: generic.this.CanBuildFrom[SeqView.this.Coll,A,collection.this.SeqView[A,collection.this.Seq[_$3] forSome { type _$3 <: <?> }]]
        trait SeqViewLike
          <method> def $init$(): scala.this.Unit
          class AbstractTransformed
            <method> def <init>(): SeqViewLike.this.AbstractTransformed[B]
          trait Transformed
            <method> def $init$(): scala.this.Unit
            <method> <deferred> def length: scala.this.Int
            <method> <deferred> def apply(<param> idx: scala.this.Int): B
            <method> override def toString(): lang.this.String
          trait EmptyView
            <method> def $init$(): scala.this.Unit
            <method> final override def length: scala.this.Int
            <method> final override def apply(<param> n: scala.this.Int): scala.this.Nothing
          trait Forced
            <method> def $init$(): scala.this.Unit
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): B
          trait Sliced
            <method> def $init$(): scala.this.Unit
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): A
            <method> override def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
            <method> override def iterator: collection.this.Iterator[A]
          trait Mapped
            <method> def $init$(): scala.this.Unit
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): B
          trait FlatMapped
            <method> def $init$(): scala.this.Unit
            <method> <stable> <accessor> lazy protected[this] val index: scala.this.Array[scala.this.Int]
            <mutable> lazy private[this] var index : scala.this.Array[scala.this.Int]
            <method> protected[this] def findRow(<param> idx: scala.this.Int,<param> lo: scala.this.Int,<param> hi: scala.this.Int): scala.this.Int
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): B
          trait Appended
            <method> def $init$(): scala.this.Unit
            <method> <stable> <accessor> lazy protected[this] val restSeq: collection.this.GenSeq[B]
            <mutable> lazy private[this] var restSeq : collection.this.GenSeq[B]
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): B
          trait Filtered
            <method> def $init$(): scala.this.Unit
            <method> <stable> <accessor> lazy protected[this] val index: scala.this.Array[scala.this.Int]
            <mutable> lazy private[this] var index : scala.this.Array[scala.this.Int]
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): A
          trait TakenWhile
            <method> def $init$(): scala.this.Unit
            <method> <stable> <accessor> lazy protected[this] val len: scala.this.Int
            <mutable> lazy private[this] var len : scala.this.Int
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): A
          trait DroppedWhile
            <method> def $init$(): scala.this.Unit
            <method> <stable> <accessor> lazy protected[this] val start: scala.this.Int
            <mutable> lazy private[this] var start : scala.this.Int
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): A
          trait Zipped
            <method> def $init$(): scala.this.Unit
            <method> <stable> <accessor> lazy protected[this] val thatSeq: collection.this.Seq[B]
            <mutable> lazy private[this] var thatSeq : collection.this.Seq[B]
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): scala.this.Tuple2[A,B]
          trait ZippedAll
            <method> def $init$(): scala.this.Unit
            <method> <stable> <accessor> lazy protected[this] val thatSeq: collection.this.Seq[B]
            <mutable> lazy private[this] var thatSeq : collection.this.Seq[B]
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): scala.this.Tuple2[A1,B]
          trait Reversed
            <method> def $init$(): scala.this.Unit
            <method> override def iterator: collection.this.Iterator[A]
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): A
            <method> final override protected[this] def viewIdentifier: lang.this.String
            <method> private def createReversedIterator: collection.this.Iterator[A]
          trait Patched
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val from: scala.this.Int
            <method> <deferred> <stable> <accessor> protected[this] val patch: collection.this.GenSeq[B]
            <method> <deferred> <stable> <accessor> protected[this] val replaced: scala.this.Int
            <method> <stable> <accessor> lazy private val plen: scala.this.Int
            <mutable> lazy private[this] var plen : scala.this.Int
            <method> override def iterator: collection.this.Iterator[B]
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): B
            <method> final override protected[this] def viewIdentifier: lang.this.String
          trait Prepended
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val fst: B
            <method> override def iterator: collection.this.Iterator[B]
            <method> def length: scala.this.Int
            <method> def apply(<param> idx: scala.this.Int): B
            <method> final override protected[this] def viewIdentifier: lang.this.String
          <method> override protected def newForced[B](<param> <bynameparam> xs: scala.this.<byname>[collection.this.GenSeq[B]]): SeqViewLike.this.Transformed[B]
          <method> override protected def newAppended[B >: A](<param> that: collection.this.GenTraversable[B]): SeqViewLike.this.Transformed[B]
          <method> override protected def newMapped[B](<param> f: scala.this.Function1[A,B]): SeqViewLike.this.Transformed[B]
          <method> override protected def newFlatMapped[B](<param> f: scala.this.Function1[A,collection.this.GenTraversableOnce[B]]): SeqViewLike.this.Transformed[B]
          <method> override protected def newFiltered(<param> p: scala.this.Function1[A,scala.this.Boolean]): SeqViewLike.this.Transformed[A]
          <method> override protected def newSliced(<param> _endpoints: generic.this.SliceInterval): SeqViewLike.this.Transformed[A]
          <method> override protected def newDroppedWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): SeqViewLike.this.Transformed[A]
          <method> override protected def newTakenWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): SeqViewLike.this.Transformed[A]
          <method> override protected def newZipped[B](<param> that: collection.this.GenIterable[B]): SeqViewLike.this.Transformed[scala.this.Tuple2[A,B]]
          <method> override protected def newZippedAll[A1 >: A, B](<param> that: collection.this.GenIterable[B],<param> _thisElem: A1,<param> _thatElem: B): SeqViewLike.this.Transformed[scala.this.Tuple2[A1,B]]
          <method> protected def newReversed: SeqViewLike.this.Transformed[A]
          <method> protected def newPatched[B >: A](<param> _from: scala.this.Int,<param> _patch: collection.this.GenSeq[B],<param> _replaced: scala.this.Int): SeqViewLike.this.Transformed[B]
          <method> protected def newPrepended[B >: A](<param> elem: B): SeqViewLike.this.Transformed[B]
          <method> override protected def newTaken(<param> n: scala.this.Int): SeqViewLike.this.Transformed[A]
          <method> override protected def newDropped(<param> n: scala.this.Int): SeqViewLike.this.Transformed[A]
          <method> override def reverse: This
          <method> override def patch[B >: A, That](<param> from: scala.this.Int,<param> patch: collection.this.GenSeq[B],<param> replaced: scala.this.Int)(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def padTo[B >: A, That](<param> len: scala.this.Int,<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def reverseMap[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def updated[B >: A, That](<param> index: scala.this.Int,<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def $plus$colon[B >: A, That](<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def $colon$plus[B >: A, That](<param> elem: B)(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def union[B >: A, That](<param> that: collection.this.GenSeq[B])(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def diff[B >: A](<param> that: collection.this.GenSeq[B]): This
          <method> override def intersect[B >: A](<param> that: collection.this.GenSeq[B]): This
          <method> override def sorted[B >: A](implicit <param> ord: scala.this.Ordering[B]): This
          <method> override def sortWith(<param> lt: scala.this.Function2[A,A,scala.this.Boolean]): This
          <method> override def sortBy[B](<param> f: scala.this.Function1[A,B])(implicit <param> ord: scala.this.Ordering[B]): This
          <method> override def combinations(<param> n: scala.this.Int): collection.this.Iterator[This]
          <method> override def permutations: collection.this.Iterator[This]
          <method> override def distinct: This
          <method> override def stringPrefix: lang.this.String
        module SeqViewLike
        module class SeqViewLike
        trait Set
          <method> def $init$(): scala.this.Unit
          <method> override def companion: generic.this.GenericCompanion[collection.this.Set]
          <method> override def seq: collection.this.Set[A]
        module Set
        module class Set
          <method> def <init>(): collection.this.Set.type
          <method> def newBuilder[A]: mutable.this.Builder[A,immutable.this.Set[A]]
          <method> override def empty[A]: collection.this.Set[A]
          <method> implicit def canBuildFrom[A]: generic.this.CanBuildFrom[Set.this.Coll,A,collection.this.Set[A]]
        trait SetLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def empty: This
          <method> override protected[this] def newBuilder: mutable.this.Builder[A,This]
          <method> override protected[this] def parCombiner: parallel.this.Combiner[A,parallel.this.ParSet[A]]
          <method> override def toSeq: collection.this.Seq[A]
          <method> override def toBuffer[A1 >: A]: mutable.this.Buffer[A1]
          <method> override def map[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> <deferred> def contains(<param> elem: A): scala.this.Boolean
          <method> <deferred> def $plus(<param> elem: A): This
          <method> def $plus(<param> elem1: A,<param> elem2: A,<param> elems: scala.this.<repeated>[A]): This
          <method> def $plus$plus(<param> elems: collection.this.GenTraversableOnce[A]): This
          <method> <deferred> def $minus(<param> elem: A): This
          <method> override def isEmpty: scala.this.Boolean
          <method> def union(<param> that: collection.this.GenSet[A]): This
          <method> def diff(<param> that: collection.this.GenSet[A]): This
          <method> def subsets(<param> len: scala.this.Int): collection.this.Iterator[This]
          <method> def subsets: collection.this.Iterator[This]
          class SubsetsItr
            <paramaccessor> private[this] val elms: collection.this.IndexedSeq[A]
            <paramaccessor> private[this] val len: scala.this.Int
            <method> def <init>(<param> elms: collection.this.IndexedSeq[A],<param> len: scala.this.Int): SetLike.this.SubsetsItr
            <method> <stable> <accessor> private val idxs: scala.this.Array[scala.this.Int]
            private[this] val idxs : scala.this.Array[scala.this.Int]
            <method> <accessor> private def _hasNext: scala.this.Boolean
            <method> <accessor> private def _hasNext_$eq(<param> <synthetic> x$1: scala.this.Boolean): scala.this.Unit
            <mutable> private[this] var _hasNext : scala.this.Boolean
            <method> def hasNext: scala.this.Boolean
            <method> def next(): This
          <method> override def stringPrefix: String
          <method> override def toString(): String
          <method> <superaccessor> <artifact> private def super$map[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
        module SetLike
        module class SetLike
        trait SetProxy
        module SetProxy
        module class SetProxy
        trait SetProxyLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def empty: This
          <method> override def contains(<param> elem: A): scala.this.Boolean
          <method> override def $plus(<param> elem: A): This
          <method> override def $minus(<param> elem: A): This
          <method> override def isEmpty: scala.this.Boolean
          <method> override def apply(<param> elem: A): scala.this.Boolean
          <method> override def intersect(<param> that: collection.this.GenSet[A]): This
          <method> override def $amp(<param> that: collection.this.GenSet[A]): This
          <method> override def union(<param> that: collection.this.GenSet[A]): This
          <method> override def $bar(<param> that: collection.this.GenSet[A]): This
          <method> override def diff(<param> that: collection.this.GenSet[A]): This
          <method> override def $amp$tilde(<param> that: collection.this.GenSet[A]): This
          <method> override def subsetOf(<param> that: collection.this.GenSet[A]): scala.this.Boolean
        module SetProxyLike
        module class SetProxyLike
        trait SortedMap
          <method> def $init$(): scala.this.Unit
          <method> override def empty: collection.this.SortedMap[A,B]
          <method> override protected[this] def newBuilder: mutable.this.Builder[scala.this.Tuple2[A,B],collection.this.SortedMap[A,B]]
        module SortedMap
        module class SortedMap
          <method> def <init>(): collection.this.SortedMap.type
          <method> def empty[A, B](implicit <param> ord: scala.this.Ordering[A]): collection.this.SortedMap[A,B]
          <method> implicit def canBuildFrom[A, B](implicit <param> ord: scala.this.Ordering[A]): generic.this.CanBuildFrom[SortedMap.this.Coll,scala.this.Tuple2[A,B],collection.this.SortedMap[A,B]]
          trait Default
            <method> def $init$(): scala.this.Unit
            <method> override def $plus[B1 >: B](<param> kv: scala.this.Tuple2[A,B1]): collection.this.SortedMap[A,B1]
            <method> override def $minus(<param> key: A): collection.this.SortedMap[A,B]
        trait SortedMapLike
          <method> def $init$(): scala.this.Unit
          <method> def firstKey: A
          <method> def lastKey: A
          <method> <deferred> implicit def ordering: scala.this.Ordering[A]
          <method> <deferred> def rangeImpl(<param> from: scala.this.Option[A],<param> until: scala.this.Option[A]): This
          <method> override def keySet: collection.this.SortedSet[A]
          class DefaultKeySortedSet
            <method> def <init>(): SortedMapLike.this.DefaultKeySortedSet
            <method> implicit def ordering: scala.this.Ordering[A]
            <method> override def $plus(<param> elem: A): collection.this.SortedSet[A]
            <method> override def $minus(<param> elem: A): collection.this.SortedSet[A]
            <method> override def rangeImpl(<param> from: scala.this.Option[A],<param> until: scala.this.Option[A]): collection.this.SortedSet[A]
            <method> override def keysIteratorFrom(<param> start: A): collection.this.Iterator[A]
          <method> override def updated[B1 >: B](<param> key: A,<param> value: B1): collection.this.SortedMap[A,B1]
          <method> <deferred> def $plus[B1 >: B](<param> kv: scala.this.Tuple2[A,B1]): collection.this.SortedMap[A,B1]
          <method> override def $plus[B1 >: B](<param> elem1: scala.this.Tuple2[A,B1],<param> elem2: scala.this.Tuple2[A,B1],<param> elems: scala.this.<repeated>[scala.this.Tuple2[A,B1]]): collection.this.SortedMap[A,B1]
          <method> override def filterKeys(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.SortedMap[A,B]
          <method> override def mapValues[C](<param> f: scala.this.Function1[B,C]): collection.this.SortedMap[A,C]
          <method> override def $plus$plus[B1 >: B](<param> xs: collection.this.GenTraversableOnce[scala.this.Tuple2[A,B1]]): collection.this.SortedMap[A,B1]
          <method> <deferred> def iteratorFrom(<param> start: A): collection.this.Iterator[scala.this.Tuple2[A,B]]
          <method> <deferred> def valuesIteratorFrom(<param> start: A): collection.this.Iterator[B]
        module SortedMapLike
        module class SortedMapLike
        trait SortedSet
          <method> def $init$(): scala.this.Unit
          <method> override def empty: collection.this.SortedSet[A]
        module SortedSet
        module class SortedSet
          <method> def <init>(): collection.this.SortedSet.type
          <method> def empty[A](implicit <param> ord: scala.this.Ordering[A]): immutable.this.SortedSet[A]
          <method> def canBuildFrom[A](implicit <param> ord: scala.this.Ordering[A]): generic.this.CanBuildFrom[SortedSet.this.Coll,A,collection.this.SortedSet[A]]
          <method> override implicit def newCanBuildFrom[A](implicit <param> ord: scala.this.Ordering[A]): generic.this.CanBuildFrom[SortedSet.this.Coll,A,collection.this.SortedSet[A]]
        trait SortedSetLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> implicit def ordering: scala.this.Ordering[A]
          <method> override def keySet: This
          <method> override def firstKey: A
          <method> override def lastKey: A
          <method> <deferred> def rangeImpl(<param> from: scala.this.Option[A],<param> until: scala.this.Option[A]): This
          <method> override def from(<param> from: A): This
          <method> override def until(<param> until: A): This
          <method> override def range(<param> from: A,<param> until: A): This
          <method> override def subsetOf(<param> that: collection.this.GenSet[A]): scala.this.Boolean
          <method> def iteratorFrom(<param> start: A): collection.this.Iterator[A]
          <method> <superaccessor> <artifact> private def super$subsetOf(<param> that: collection.this.GenSet[A]): scala.this.Boolean
        module SortedSetLike
        module class SortedSetLike
        trait Traversable
          <method> def $init$(): scala.this.Unit
          <method> override def companion: generic.this.GenericCompanion[collection.this.Traversable]
          <method> override def seq: collection.this.Traversable[A]
        module Traversable
        module class Traversable
          <method> def <init>(): collection.this.Traversable.type
          <method> <stable> <accessor> private[package class collection] val breaks: control.this.Breaks
          private[this] val breaks : control.this.Breaks
          <method> implicit def canBuildFrom[A]: generic.this.CanBuildFrom[Traversable.this.Coll,A,collection.this.Traversable[A]]
          <method> def newBuilder[A]: mutable.this.Builder[A,collection.this.Traversable[A]]
        trait TraversableLike
          <method> def $init$(): scala.this.Unit
          protected[this] type Self = Repr
          <method> def repr: Repr
          <method> final def isTraversableAgain: scala.this.Boolean
          <method> protected[this] def thisCollection: collection.this.Traversable[A]
          <method> protected[this] def toCollection(<param> repr: Repr): collection.this.Traversable[A]
          <method> <deferred> protected[this] def newBuilder: mutable.this.Builder[A,Repr]
          <method> protected[this] def parCombiner: parallel.this.Combiner[A,parallel.this.ParIterable[A]]
          <method> <deferred> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
          <method> def isEmpty: scala.this.Boolean
          <method> def hasDefiniteSize: scala.this.Boolean
          <method> def $plus$plus[B >: A, That](<param> that: collection.this.GenTraversableOnce[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def $plus$plus$colon[B >: A, That](<param> that: collection.this.TraversableOnce[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def $plus$plus$colon[B >: A, That](<param> that: collection.this.Traversable[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def map[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def flatMap[B, That](<param> f: scala.this.Function1[A,collection.this.GenTraversableOnce[B]])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> private def filterImpl(<param> p: scala.this.Function1[A,scala.this.Boolean],<param> isFlipped: scala.this.Boolean): Repr
          <method> def filter(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> def filterNot(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> def collect[B, That](<param> pf: scala.this.PartialFunction[A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def partition(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[Repr,Repr]
          <method> def groupBy[K](<param> f: scala.this.Function1[A,K]): immutable.this.Map[K,Repr]
          <method> def forall(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> def exists(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> def find(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Option[A]
          <method> def scan[B >: A, That](<param> z: B)(<param> op: scala.this.Function2[B,B,B])(implicit <param> cbf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def scanLeft[B, That](<param> z: B)(<param> op: scala.this.Function2[B,A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def scanRight[B, That](<param> z: B)(<param> op: scala.this.Function2[A,B,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> def head: A
          <method> def headOption: scala.this.Option[A]
          <method> override def tail: Repr
          <method> def last: A
          <method> def lastOption: scala.this.Option[A]
          <method> def init: Repr
          <method> def take(<param> n: scala.this.Int): Repr
          <method> def drop(<param> n: scala.this.Int): Repr
          <method> def slice(<param> from: scala.this.Int,<param> until: scala.this.Int): Repr
          <method> private[this] def sliceInternal(<param> from: scala.this.Int,<param> until: scala.this.Int,<param> b: mutable.this.Builder[A,Repr]): Repr
          <method> private[package class scala] def sliceWithKnownDelta(<param> from: scala.this.Int,<param> until: scala.this.Int,<param> delta: scala.this.Int): Repr
          <method> private[package class scala] def sliceWithKnownBound(<param> from: scala.this.Int,<param> until: scala.this.Int): Repr
          <method> def takeWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> def dropWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> def span(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[Repr,Repr]
          <method> def splitAt(<param> n: scala.this.Int): scala.this.Tuple2[Repr,Repr]
          <method> def tails: collection.this.Iterator[Repr]
          <method> def inits: collection.this.Iterator[Repr]
          <method> def copyToArray[B >: A](<param> xs: scala.this.Array[B],<param> start: scala.this.Int,<param> len: scala.this.Int): scala.this.Unit
          <method> def toTraversable: collection.this.Traversable[A]
          <method> def toIterator: collection.this.Iterator[A]
          <method> def toStream: scala.this.Stream[A]
          <method> override def to[Col[_]](implicit <param> cbf: generic.this.CanBuildFrom[scala.this.Nothing,A,Col[A @unchecked.this.uncheckedVariance]]): Col[A @unchecked.this.uncheckedVariance]
          <method> override def toString(): String
          <method> def stringPrefix: String
          <method> def view: collection.this.TraversableView[A,Repr]{}
          <method> def view(<param> from: scala.this.Int,<param> until: scala.this.Int): collection.this.TraversableView[A,Repr]
          <method> def withFilter(<param> p: scala.this.Function1[A,scala.this.Boolean]): generic.this.FilterMonadic[A,Repr]
          class WithFilter
            <paramaccessor> private[this] val p: scala.this.Function1[A,scala.this.Boolean]
            <method> def <init>(<param> p: scala.this.Function1[A,scala.this.Boolean]): TraversableLike.this.WithFilter
            <method> def map[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
            <method> def flatMap[B, That](<param> f: scala.this.Function1[A,collection.this.GenTraversableOnce[B]])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
            <method> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
            <method> def withFilter(<param> q: scala.this.Function1[A,scala.this.Boolean]): TraversableLike.this.WithFilter
          <method> private def iterateUntilEmpty(<param> f: scala.this.Function1[collection.this.Traversable[A @unchecked.this.uncheckedVariance],collection.this.Traversable[A @unchecked.this.uncheckedVariance]]): collection.this.Iterator[Repr]
        module TraversableLike
        module class TraversableLike
        trait TraversableOnce
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
          <method> <deferred> def isEmpty: scala.this.Boolean
          <method> <deferred> def hasDefiniteSize: scala.this.Boolean
          <method> <deferred> def seq: collection.this.TraversableOnce[A]
          <method> <deferred> def forall(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> <deferred> def exists(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> <deferred> def find(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Option[A]
          <method> <deferred> def copyToArray[B >: A](<param> xs: scala.this.Array[B],<param> start: scala.this.Int,<param> len: scala.this.Int): scala.this.Unit
          <method> protected[this] def reversed: scala.this.List[A]
          <method> def size: scala.this.Int
          <method> def nonEmpty: scala.this.Boolean
          <method> def count(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Int
          <method> def collectFirst[B](<param> pf: scala.this.PartialFunction[A,B]): scala.this.Option[B]
          <method> def $div$colon[B](<param> z: B)(<param> op: scala.this.Function2[B,A,B]): B
          <method> def $colon$bslash[B](<param> z: B)(<param> op: scala.this.Function2[A,B,B]): B
          <method> def foldLeft[B](<param> z: B)(<param> op: scala.this.Function2[B,A,B]): B
          <method> def foldRight[B](<param> z: B)(<param> op: scala.this.Function2[A,B,B]): B
          <method> def reduceLeft[B >: A](<param> op: scala.this.Function2[B,A,B]): B
          <method> def reduceRight[B >: A](<param> op: scala.this.Function2[A,B,B]): B
          <method> def reduceLeftOption[B >: A](<param> op: scala.this.Function2[B,A,B]): scala.this.Option[B]
          <method> def reduceRightOption[B >: A](<param> op: scala.this.Function2[A,B,B]): scala.this.Option[B]
          <method> def reduce[A1 >: A](<param> op: scala.this.Function2[A1,A1,A1]): A1
          <method> def reduceOption[A1 >: A](<param> op: scala.this.Function2[A1,A1,A1]): scala.this.Option[A1]
          <method> def fold[A1 >: A](<param> z: A1)(<param> op: scala.this.Function2[A1,A1,A1]): A1
          <method> def aggregate[B](<param> <bynameparam> z: scala.this.<byname>[B])(<param> seqop: scala.this.Function2[B,A,B],<param> combop: scala.this.Function2[B,B,B]): B
          <method> def sum[B >: A](implicit <param> num: scala.this.Numeric[B]): B
          <method> def product[B >: A](implicit <param> num: scala.this.Numeric[B]): B
          <method> def min[B >: A](implicit <param> cmp: scala.this.Ordering[B]): A
          <method> def max[B >: A](implicit <param> cmp: scala.this.Ordering[B]): A
          <method> def maxBy[B](<param> f: scala.this.Function1[A,B])(implicit <param> cmp: scala.this.Ordering[B]): A
          <method> def minBy[B](<param> f: scala.this.Function1[A,B])(implicit <param> cmp: scala.this.Ordering[B]): A
          <method> def copyToBuffer[B >: A](<param> dest: mutable.this.Buffer[B]): scala.this.Unit
          <method> def copyToArray[B >: A](<param> xs: scala.this.Array[B],<param> start: scala.this.Int): scala.this.Unit
          <method> def copyToArray[B >: A](<param> xs: scala.this.Array[B]): scala.this.Unit
          <method> def toArray[B >: A](implicit <param> <synthetic> evidence$1: reflect.this.ClassTag[B]): scala.this.Array[B]
          <method> <deferred> def toTraversable: collection.this.Traversable[A]
          <method> def toList: scala.this.List[A]
          <method> def toIterable: collection.this.Iterable[A]
          <method> def toSeq: collection.this.Seq[A]
          <method> def toIndexedSeq: immutable.this.IndexedSeq[A]
          <method> def toBuffer[B >: A]: mutable.this.Buffer[B]
          <method> def toSet[B >: A]: immutable.this.Set[B]
          <method> def toVector: scala.this.Vector[A]
          <method> def to[Col[_]](implicit <param> cbf: generic.this.CanBuildFrom[scala.this.Nothing,A,Col[A @unchecked.this.uncheckedVariance]]): Col[A @unchecked.this.uncheckedVariance]
          <method> def toMap[T, U](implicit <param> ev: $less$colon$less[A,scala.this.Tuple2[T,U]]): immutable.this.Map[T,U]
          <method> def mkString(<param> start: String,<param> sep: String,<param> end: String): String
          <method> def mkString(<param> sep: String): String
          <method> def mkString: String
          <method> def addString(<param> b: scala.this.StringBuilder,<param> start: String,<param> sep: String,<param> end: String): scala.this.StringBuilder
          <method> def addString(<param> b: scala.this.StringBuilder,<param> sep: String): scala.this.StringBuilder
          <method> def addString(<param> b: scala.this.StringBuilder): scala.this.StringBuilder
        module TraversableOnce
        module class TraversableOnce
          <method> def <init>(): collection.this.TraversableOnce.type
          <method> implicit def alternateImplicit[A](<param> trav: collection.this.TraversableOnce[A]): TraversableOnce.this.ForceImplicitAmbiguity
          class ForceImplicitAmbiguity
            <method> def <init>(): TraversableOnce.this.ForceImplicitAmbiguity
          <method> implicit def flattenTraversableOnce[A, CC[_]](<param> travs: collection.this.TraversableOnce[CC[A]])(implicit <param> ev: scala.this.Function1[CC[A],collection.this.TraversableOnce[A]]): TraversableOnce.this.FlattenOps[A]
          class FlattenOps
            <paramaccessor> private[this] val travs: collection.this.TraversableOnce[collection.this.TraversableOnce[A]]
            <method> def <init>(<param> travs: collection.this.TraversableOnce[collection.this.TraversableOnce[A]]): TraversableOnce.this.FlattenOps[A]
            <method> def flatten: collection.this.Iterator[A]
          class BufferedCanBuildFrom
            <method> def <init>(): TraversableOnce.this.BufferedCanBuildFrom[A,CC]
            <method> <deferred> def bufferToColl[B](<param> buff: mutable.this.ArrayBuffer[B]): CC[B]
            <method> <deferred> def traversableToColl[B](<param> t: collection.this.GenTraversable[B]): CC[B]
            <method> def newIterator: mutable.this.Builder[A,CC[A]]
            <method> def apply(<param> from: CC[_$2] forSome { type _$2 <: <?> }): mutable.this.Builder[A,CC[A]]
            <method> def apply(): mutable.this.Builder[A,CC[A]]
          class OnceCanBuildFrom
            <method> def <init>(): TraversableOnce.this.OnceCanBuildFrom[A]
            <method> def bufferToColl[B](<param> buff: mutable.this.ArrayBuffer[B]): collection.this.Iterator[B]
            <method> def traversableToColl[B](<param> t: collection.this.GenTraversable[B]): collection.this.Traversable[B]
          <method> implicit def OnceCanBuildFrom[A]: TraversableOnce.this.OnceCanBuildFrom[A]
          class MonadOps
            <paramaccessor> private[this] val trav: collection.this.TraversableOnce[A]
            <method> def <init>(<param> trav: collection.this.TraversableOnce[A]): TraversableOnce.this.MonadOps[A]
            <method> def map[B](<param> f: scala.this.Function1[A,B]): collection.this.TraversableOnce[B]
            <method> def flatMap[B](<param> f: scala.this.Function1[A,collection.this.GenTraversableOnce[B]]): collection.this.TraversableOnce[B]
            <method> def withFilter(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.Iterator[A]
            <method> def filter(<param> p: scala.this.Function1[A,scala.this.Boolean]): collection.this.TraversableOnce[A]
          <method> implicit <synthetic> def MonadOps[A](<param> trav: collection.this.TraversableOnce[A]): TraversableOnce.this.MonadOps[A]
        trait TraversableProxy
        module TraversableProxy
        module class TraversableProxy
        trait TraversableProxyLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> def self: Repr
          <method> override def foreach[B](<param> f: scala.this.Function1[A,B]): scala.this.Unit
          <method> override def isEmpty: scala.this.Boolean
          <method> override def nonEmpty: scala.this.Boolean
          <method> override def size: scala.this.Int
          <method> override def hasDefiniteSize: scala.this.Boolean
          <method> override def $plus$plus[B >: A, That](<param> xs: collection.this.GenTraversableOnce[B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def map[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def flatMap[B, That](<param> f: scala.this.Function1[A,collection.this.GenTraversableOnce[B]])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def filter(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> override def filterNot(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> override def collect[B, That](<param> pf: scala.this.PartialFunction[A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def partition(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[Repr,Repr]
          <method> override def groupBy[K](<param> f: scala.this.Function1[A,K]): immutable.this.Map[K,Repr]
          <method> override def forall(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> override def exists(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Boolean
          <method> override def count(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Int
          <method> override def find(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Option[A]
          <method> override def foldLeft[B](<param> z: B)(<param> op: scala.this.Function2[B,A,B]): B
          <method> override def $div$colon[B](<param> z: B)(<param> op: scala.this.Function2[B,A,B]): B
          <method> override def foldRight[B](<param> z: B)(<param> op: scala.this.Function2[A,B,B]): B
          <method> override def $colon$bslash[B](<param> z: B)(<param> op: scala.this.Function2[A,B,B]): B
          <method> override def reduceLeft[B >: A](<param> op: scala.this.Function2[B,A,B]): B
          <method> override def reduceLeftOption[B >: A](<param> op: scala.this.Function2[B,A,B]): scala.this.Option[B]
          <method> override def reduceRight[B >: A](<param> op: scala.this.Function2[A,B,B]): B
          <method> override def reduceRightOption[B >: A](<param> op: scala.this.Function2[A,B,B]): scala.this.Option[B]
          <method> override def scanLeft[B, That](<param> z: B)(<param> op: scala.this.Function2[B,A,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def scanRight[B, That](<param> z: B)(<param> op: scala.this.Function2[A,B,B])(implicit <param> bf: generic.this.CanBuildFrom[Repr,B,That]): That
          <method> override def sum[B >: A](implicit <param> num: scala.this.Numeric[B]): B
          <method> override def product[B >: A](implicit <param> num: scala.this.Numeric[B]): B
          <method> override def min[B >: A](implicit <param> cmp: scala.this.Ordering[B]): A
          <method> override def max[B >: A](implicit <param> cmp: scala.this.Ordering[B]): A
          <method> override def head: A
          <method> override def headOption: scala.this.Option[A]
          <method> override def tail: Repr
          <method> override def last: A
          <method> override def lastOption: scala.this.Option[A]
          <method> override def init: Repr
          <method> override def take(<param> n: scala.this.Int): Repr
          <method> override def drop(<param> n: scala.this.Int): Repr
          <method> override def slice(<param> from: scala.this.Int,<param> until: scala.this.Int): Repr
          <method> override def takeWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> override def dropWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): Repr
          <method> override def span(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[Repr,Repr]
          <method> override def splitAt(<param> n: scala.this.Int): scala.this.Tuple2[Repr,Repr]
          <method> override def copyToBuffer[B >: A](<param> dest: mutable.this.Buffer[B]): scala.this.Unit
          <method> override def copyToArray[B >: A](<param> xs: scala.this.Array[B],<param> start: scala.this.Int,<param> len: scala.this.Int): scala.this.Unit
          <method> override def copyToArray[B >: A](<param> xs: scala.this.Array[B],<param> start: scala.this.Int): scala.this.Unit
          <method> override def copyToArray[B >: A](<param> xs: scala.this.Array[B]): scala.this.Unit
          <method> override def toArray[B >: A](implicit <param> <synthetic> evidence$1: reflect.this.ClassTag[B]): scala.this.Array[B]
          <method> override def toList: scala.this.List[A]
          <method> override def toIterable: collection.this.Iterable[A]
          <method> override def toSeq: collection.this.Seq[A]
          <method> override def toIndexedSeq: immutable.this.IndexedSeq[A]
          <method> override def toBuffer[B >: A]: mutable.this.Buffer[B]
          <method> override def toStream: scala.this.Stream[A]
          <method> override def toSet[B >: A]: immutable.this.Set[B]
          <method> override def toMap[T, U](implicit <param> ev: $less$colon$less[A,scala.this.Tuple2[T,U]]): immutable.this.Map[T,U]
          <method> override def toTraversable: collection.this.Traversable[A]
          <method> override def toIterator: collection.this.Iterator[A]
          <method> override def mkString(<param> start: String,<param> sep: String,<param> end: String): String
          <method> override def mkString(<param> sep: String): String
          <method> override def mkString: String
          <method> override def addString(<param> b: mutable.this.StringBuilder,<param> start: String,<param> sep: String,<param> end: String): mutable.this.StringBuilder
          <method> override def addString(<param> b: mutable.this.StringBuilder,<param> sep: String): mutable.this.StringBuilder
          <method> override def addString(<param> b: mutable.this.StringBuilder): mutable.this.StringBuilder
          <method> override def stringPrefix: String
          <method> override def view: collection.this.TraversableView[A,Repr]{}
          <method> override def view(<param> from: scala.this.Int,<param> until: scala.this.Int): collection.this.TraversableView[A,Repr]
        module TraversableProxyLike
        module class TraversableProxyLike
        trait TraversableView
        module TraversableView
        module class TraversableView
          <method> def <init>(): collection.this.TraversableView.type
          class NoBuilder
            <method> def <init>(): TraversableView.this.NoBuilder[A]
            <method> def $plus$eq(<param> elem: A): NoBuilder.this.type
            <method> def iterator: collection.this.Iterator[A]
            <method> def result(): scala.this.Nothing
            <method> def clear(): scala.this.Unit
          type Coll = collection.this.TraversableView[_$1,C] forSome { type C <: <?>; type _$1 <: <?> }
          <method> implicit def canBuildFrom[A]: generic.this.CanBuildFrom[TraversableView.this.Coll,A,collection.this.TraversableView[A,collection.this.Traversable[_$3] forSome { type _$3 <: <?> }]]
        trait TraversableViewLike
          <method> def $init$(): scala.this.Unit
          <method> <deferred> protected def underlying: Coll
          <method> protected[this] def viewIdentifier: String
          <method> protected[this] def viewIdString: String
          <method> def viewToString: lang.this.String
          <method> override def stringPrefix: lang.this.String
          <method> override protected[this] def newBuilder: mutable.this.Builder[A,This]
          <method> def force[B >: A, That](implicit <param> bf: generic.this.CanBuildFrom[Coll,B,That]): That
          class AbstractTransformed
            <method> def <init>(): TraversableViewLike.this.AbstractTransformed[B]
          trait Transformed
            <method> def $init$(): scala.this.Unit
            <method> <deferred> def foreach[U](<param> f: scala.this.Function1[B,U]): scala.this.Unit
            <method> <stable> <accessor> lazy val underlying: Coll
            <mutable> lazy private[this] var underlying : Coll
            <method> final override protected[this] def viewIdString: lang.this.String
            <method> override def headOption: scala.this.Option[B]
            <method> override def lastOption: scala.this.Option[B]
            <method> override def stringPrefix: lang.this.String
            <method> override def toString(): lang.this.String
          trait EmptyView
            <method> def $init$(): scala.this.Unit
            <method> final override def isEmpty: scala.this.Boolean
            <method> final override def foreach[U](<param> f: scala.this.Function1[scala.this.Nothing,U]): scala.this.Unit
          trait Forced
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val forced: collection.this.GenSeq[B]
            <method> def foreach[U](<param> f: scala.this.Function1[B,U]): scala.this.Unit
            <method> final override protected[this] def viewIdentifier: lang.this.String
          trait Sliced
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val endpoints: generic.this.SliceInterval
            <method> protected[this] def from: scala.this.Int
            <method> protected[this] def until: scala.this.Int
            <method> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
            <method> final override protected[this] def viewIdentifier: lang.this.String
          trait Mapped
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val mapping: scala.this.Function1[A,B]
            <method> def foreach[U](<param> f: scala.this.Function1[B,U]): scala.this.Unit
            <method> final override protected[this] def viewIdentifier: lang.this.String
          trait FlatMapped
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val mapping: scala.this.Function1[A,collection.this.GenTraversableOnce[B]]
            <method> def foreach[U](<param> f: scala.this.Function1[B,U]): scala.this.Unit
            <method> final override protected[this] def viewIdentifier: lang.this.String
          trait Appended
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val rest: collection.this.GenTraversable[B]
            <method> def foreach[U](<param> f: scala.this.Function1[B,U]): scala.this.Unit
            <method> final override protected[this] def viewIdentifier: lang.this.String
          trait Filtered
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val pred: scala.this.Function1[A,scala.this.Boolean]
            <method> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
            <method> final override protected[this] def viewIdentifier: lang.this.String
          trait TakenWhile
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val pred: scala.this.Function1[A,scala.this.Boolean]
            <method> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
            <method> final override protected[this] def viewIdentifier: lang.this.String
          trait DroppedWhile
            <method> def $init$(): scala.this.Unit
            <method> <deferred> <stable> <accessor> protected[this] val pred: scala.this.Function1[A,scala.this.Boolean]
            <method> def foreach[U](<param> f: scala.this.Function1[A,U]): scala.this.Unit
            <method> final override protected[this] def viewIdentifier: lang.this.String
          <method> override def $plus$plus[B >: A, That](<param> xs: collection.this.GenTraversableOnce[B])(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def map[B, That](<param> f: scala.this.Function1[A,B])(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def collect[B, That](<param> pf: scala.this.PartialFunction[A,B])(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def flatMap[B, That](<param> f: scala.this.Function1[A,collection.this.GenTraversableOnce[B]])(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def flatten[B](implicit <param> asTraversable: scala.this.Function1[A,collection.this.GenTraversableOnce[B]]): TraversableViewLike.this.Transformed[B]
          <method> implicit private[this] def asThis(<param> xs: TraversableViewLike.this.Transformed[A]): This
          <method> protected def newForced[B](<param> <bynameparam> xs: scala.this.<byname>[collection.this.GenSeq[B]]): TraversableViewLike.this.Transformed[B]
          <method> protected def newAppended[B >: A](<param> that: collection.this.GenTraversable[B]): TraversableViewLike.this.Transformed[B]
          <method> protected def newMapped[B](<param> f: scala.this.Function1[A,B]): TraversableViewLike.this.Transformed[B]
          <method> protected def newFlatMapped[B](<param> f: scala.this.Function1[A,collection.this.GenTraversableOnce[B]]): TraversableViewLike.this.Transformed[B]
          <method> protected def newFiltered(<param> p: scala.this.Function1[A,scala.this.Boolean]): TraversableViewLike.this.Transformed[A]
          <method> protected def newSliced(<param> _endpoints: generic.this.SliceInterval): TraversableViewLike.this.Transformed[A]
          <method> protected def newDroppedWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): TraversableViewLike.this.Transformed[A]
          <method> protected def newTakenWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): TraversableViewLike.this.Transformed[A]
          <method> protected def newTaken(<param> n: scala.this.Int): TraversableViewLike.this.Transformed[A]
          <method> protected def newDropped(<param> n: scala.this.Int): TraversableViewLike.this.Transformed[A]
          <method> override def filter(<param> p: scala.this.Function1[A,scala.this.Boolean]): This
          <method> override def withFilter(<param> p: scala.this.Function1[A,scala.this.Boolean]): This
          <method> override def partition(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[This,This]
          <method> override def init: This
          <method> override def drop(<param> n: scala.this.Int): This
          <method> override def take(<param> n: scala.this.Int): This
          <method> override def slice(<param> from: scala.this.Int,<param> until: scala.this.Int): This
          <method> override def dropWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): This
          <method> override def takeWhile(<param> p: scala.this.Function1[A,scala.this.Boolean]): This
          <method> override def span(<param> p: scala.this.Function1[A,scala.this.Boolean]): scala.this.Tuple2[This,This]
          <method> override def splitAt(<param> n: scala.this.Int): scala.this.Tuple2[This,This]
          <method> override def scanLeft[B, That](<param> z: B)(<param> op: scala.this.Function2[B,A,B])(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def scanRight[B, That](<param> z: B)(<param> op: scala.this.Function2[A,B,B])(implicit <param> bf: generic.this.CanBuildFrom[This,B,That]): That
          <method> override def groupBy[K](<param> f: scala.this.Function1[A,K]): immutable.this.Map[K,This]
          <method> override def unzip[A1, A2](implicit <param> asPair: scala.this.Function1[A,scala.this.Tuple2[A1,A2]]): scala.this.Tuple2[TraversableViewLike.this.Transformed[A1],TraversableViewLike.this.Transformed[A2]]
          <method> override def unzip3[A1, A2, A3](implicit <param> asTriple: scala.this.Function1[A,scala.this.Tuple3[A1,A2,A3]]): scala.this.Tuple3[TraversableViewLike.this.Transformed[A1],TraversableViewLike.this.Transformed[A2],TraversableViewLike.this.Transformed[A3]]
          <method> override def filterNot(<param> p: scala.this.Function1[A,scala.this.Boolean]): This
          <method> override def inits: collection.this.Iterator[This]
          <method> override def tails: collection.this.Iterator[This]
          <method> override def tail: This
          <method> override def toString(): lang.this.String
          <method> <superaccessor> <artifact> private def super$tail: This
        module TraversableViewLike
        module class TraversableViewLike
        trait ViewMkString
          <method> def $init$(): scala.this.Unit
          <method> protected[this] def thisSeq: collection.this.Seq[A]
          <method> override def mkString: String
          <method> override def mkString(<param> sep: String): String
          <method> override def mkString(<param> start: String,<param> sep: String,<param> end: String): String
          <method> override def addString(<param> b: scala.this.StringBuilder,<param> start: String,<param> sep: String,<param> end: String): scala.this.StringBuilder
        module ViewMkString
        module class ViewMkString
          <method> def breakOut[From, T, To](implicit <param> b: generic.this.CanBuildFrom[scala.this.Nothing,T,To]): generic.this.CanBuildFrom[From,T,To]