gistfile1.txt

Bad

def ++(xs: GenTraversableOnce[A]): ArrayBuffer[A]
def ++[B](that: GenTraversableOnce[B]): ArrayBuffer[B]
def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[ArrayBuffer[A], B, That]): That
def ++:[B](that: TraversableOnce[B]): ArrayBuffer[B]
def +:(elem: A): ArrayBuffer[A]
def -(elem1: A, elem2: A, elems: A*): ArrayBuffer[A]
def -(elem: A): ArrayBuffer[A]
def --(xs: GenTraversableOnce[A]): ArrayBuffer[A]
def :+(elem: A): ArrayBuffer[A]
def collect[B](pf: PartialFunction[A, B]): ArrayBuffer[B]
def diff(that: collection.Seq[A]): ArrayBuffer[A]
def distinct: ArrayBuffer[A]
def drop(n: Int): ArrayBuffer[A]
def dropRight(n: Int): ArrayBuffer[A]
def dropWhile(p: (A) ⇒ Boolean): ArrayBuffer[A]
def filter(p: (A) ⇒ Boolean): ArrayBuffer[A]
def filterNot(p: (A) ⇒ Boolean): ArrayBuffer[A]
def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): ArrayBuffer[B]
def flatten[B]: ArrayBuffer[B]
def groupBy[K](f: (A) ⇒ K): immutable.Map[K, ArrayBuffer[A]]
def grouped(size: Int): Iterator[ArrayBuffer[A]]
def init: ArrayBuffer[A]
def intersect(that: collection.Seq[A]): ArrayBuffer[A]
def map[B](f: (A) ⇒ B): ArrayBuffer[B]
def padTo(len: Int, elem: A): ArrayBuffer[A]
def partition(p: (A) ⇒ Boolean): (ArrayBuffer[A], ArrayBuffer[A])
def patch(from: Int, that: GenSeq[A], replaced: Int): ArrayBuffer[A]

Good
def ++=(xs: TraversableOnce[A]): ArrayBuffer.this.type
def ++=:(xs: TraversableOnce[A]): ArrayBuffer.this.type
def +=(elem: A): ArrayBuffer.this.type
def +=(elem1: A, elem2: A, elems: A*): ArrayBuffer.this.type
def +=:(elem: A): ArrayBuffer.this.type
def --=(xs: TraversableOnce[A]): ArrayBuffer.this.type
def -=(x: A): ArrayBuffer.this.type
def -=(elem1: A, elem2: A, elems: A*): ArrayBuffer.this.type
def /:[B](z: B)(op: (B, A) ⇒ B): B
def :\[B](z: B)(op: (A, B) ⇒ B): B
def aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B
def corresponds[B](that: GenSeq[B])(p: (A, B) ⇒ Boolean): Boolean
def append(elems: A*): Unit
def appendAll(xs: TraversableOnce[A]): Unit
def contains[A1 >: A](elem: A1): Boolean
def containsSlice[B](that: GenSeq[B]): Boolean
def count(p: (A) ⇒ Boolean): Int
def endsWith[B](that: GenSeq[B]): Boolean
def equals(that: Any): Boolean
def exists(p: (A) ⇒ Boolean): Boolean
def clear(): Unit
def clone(): ArrayBuffer[A]
def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
def combinations(n: Int): Iterator[ArrayBuffer[A]]
def find(p: (A) ⇒ Boolean): Option[A]
def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
def foldRight[B](z: B)(op: (A, B) ⇒ B): B
def forall(p: (A) ⇒ Boolean): Boolean
def foreach(f: (A) ⇒ Unit): Unit
def hashCode(): Int
def head: A
def headOption: Option[A]
def indexOf(elem: A, from: Int): Int
def indexOf(elem: A): Int
def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
def indexOfSlice[B >: A](that: GenSeq[B]): Int
def indexWhere(p: (A) ⇒ Boolean, from: Int): Int
def indexWhere(p: (A) ⇒ Boolean): Int
def indices: immutable.Range
def inits: Iterator[ArrayBuffer[A]]
def insert(n: Int, elems: A*): Unit
def insertAll(n: Int, seq:
def isEmpty: Boolean
def iterator: Iterator[A]
def last: A
def lastIndexOf(elem: A, end: Int): Int
def lastIndexOf(elem: A): Int
def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int
def lastIndexWhere(p: (A) ⇒ Boolean): Int
def lastOption: Option[A]
def length: Int
def lengthCompare(len: Int): Int
def maxBy[B](f: (A) ⇒ B): A
def max: A
def min: A
def minBy[B](f: (A) ⇒ B): A
def mkString: String
def mkString(sep: String): String
def mkString(start: String, sep: String, end: String): String
def nonEmpty: Boolean
def permutations: Iterator[ArrayBuffer[A]]
def prefixLength(p: (A) ⇒ Boolean): Int
def prepend(elems: A*): Unit
def prependAll(xs: TraversableOnce[A]): Unit
def product: A
def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

Inherited 
def compose[A](g: (A) ⇒ Int): (A) ⇒ A
def apply(idx: Int): A
def applyOrElse[A1 <: Int, B1 >: A](x: A1, default: (A1) ⇒ B1): B1
def andThen[C](k: (A) ⇒ C): PartialFunction[Int, C]
def isDefinedAt(idx: Int): Boolean
def lift: (Int) ⇒ Option[A]
def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

???
def par: ParArray[A]
def mapResult[NewTo](f: (ArrayBuffer[A]) ⇒ NewTo): Builder[A, NewTo]
def isTraversableAgain: Boolean
def hasDefiniteSize: Boolean
def genericBuilder[B]: Builder[B, ArrayBuffer[B]]
def addString(b: scala.StringBuilder): scala.StringBuilder
def addString(b: scala.StringBuilder, sep: String): scala.StringBuilder
def addString(b: scala.StringBuilder, start: String, sep: String, end: String): scala.StringBuilder
def canEqual(that: Any): Boolean
def charAt(index: Int): Char
def companion: GenericCompanion[ArrayBuffer]
def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit
def copyToArray(xs: Array[A]): Unit
def copyToArray(xs: Array[A], start: Int): Unit
def copyToBuffer[B >: A](dest: Buffer[B]): Unit