GenBag

abstract def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[GenBag[A], B, That]): That

abstract def -(elem: A): GenBag[A]

abstract def /:[B](z: B)(op: (B, A) ⇒ B): B

abstract def :\[B](z: B)(op: (A, B) ⇒ B): B

abstract def added(elem: A, count: Int): GenBag[A]

abstract def aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B

abstract def bagConfiguration: BagConfiguration[A, BagBucket]

abstract def bucketsIterator: Iterator[BagBucket]

Iterator over buckets

abstract def canEqual(that: Any): Boolean

abstract def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[GenBag[A], B, That]): That

abstract def contains(elem: A): Boolean

Tests if some element is contained in this bag.

abstract def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit

abstract def copyToArray[B >: A](xs: Array[B], start: Int): Unit

abstract def copyToArray[B >: A](xs: Array[B]): Unit

abstract def count(p: (A) ⇒ Boolean): Int

abstract def diff(that: GenBag[A]): GenBag[A]

Returns a bag containing the multi-set difference of this bag with that bag

abstract def drop(n: Int): GenBag[A]

abstract def dropWhile(pred: (A) ⇒ Boolean): GenBag[A]

abstract def exists(p: (A) ⇒ Boolean): Boolean

abstract def filter(pred: (A) ⇒ Boolean): GenBag[A]

abstract def filterNot(pred: (A) ⇒ Boolean): GenBag[A]

abstract def find(p: (A) ⇒ Boolean): Option[A]

abstract def flatMap[B, That](f: (A) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[GenBag[A], B, That]): That

abstract def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

abstract def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

abstract def foldRight[B](z: B)(op: (A, B) ⇒ B): B

abstract def forall(p: (A) ⇒ Boolean): Boolean

abstract def foreach[U](f: (A) ⇒ U): Unit

abstract def getBucket(elem: A): Option[BagBucket]

Returns the bucket associated with some key element.

abstract def groupBy[K](f: (A) ⇒ K): GenMap[K, GenBag[A]]

abstract def hasDefiniteSize: Boolean

abstract def head: A

abstract def headOption: Option[A]

abstract def init: GenBag[A]

abstract def intersect(that: GenBag[A]): GenBag[A]

Returns a bag containing the multi-set intersection of this bag and that bag

abstract def isEmpty: Boolean

abstract def isTraversableAgain: Boolean

abstract def last: A

abstract def lastOption: Option[A]

abstract def leastCommon: GenBag[A]

Returns a Bag with the least common elements up to the equivalence defined in the BagConfiguration

abstract def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[GenBag[A], B, That]): That

abstract def max[A1 >: A](implicit ord: Ordering[A1]): A

abstract def maxBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

abstract def maxUnion(that: GenBag[A]): GenBag[A]

Returns a bag containing the multi-set max union (or generalized set union) of this bag and that bag

abstract def min[A1 >: A](implicit ord: Ordering[A1]): A

abstract def minBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

abstract def mkString: String

abstract def mkString(sep: String): String

abstract def mkString(start: String, sep: String, end: String): String

abstract def mostCommon: GenBag[A]

Returns a Bag with the most common elements up to the equivalence defined in the BagConfiguration

abstract def nonEmpty: Boolean

abstract def parCombiner: Combiner[A, ParIterable[A]]

abstract def partition(pred: (A) ⇒ Boolean): (GenBag[A], GenBag[A])

abstract def product[A1 >: A](implicit num: Numeric[A1]): A1

abstract def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

abstract def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]

abstract def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]

abstract def reduceRight[B >: A](op: (A, B) ⇒ B): B

abstract def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]

abstract def repr: GenBag[A]

abstract def sameElements[A1 >: A](that: GenIterable[A1]): Boolean

abstract def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[GenBag[A], B, That]): That

abstract def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[GenBag[A], B, That]): That

abstract def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[GenBag[A], B, That]): That

abstract def seq: Iterable[A]

abstract def size: Int

abstract def slice(unc_from: Int, unc_until: Int): GenBag[A]

abstract def span(pred: (A) ⇒ Boolean): (GenBag[A], GenBag[A])

abstract def splitAt(n: Int): (GenBag[A], GenBag[A])

abstract def stringPrefix: String

abstract def sum[A1 >: A](implicit num: Numeric[A1]): A1

abstract def tail: GenBag[A]

abstract def take(n: Int): GenBag[A]

abstract def takeWhile(pred: (A) ⇒ Boolean): GenBag[A]

abstract def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, A, Col[A]]): Col[A]

abstract def toArray[A1 >: A](implicit arg0: ClassTag[A1]): Array[A1]

abstract def toBuffer[A1 >: A]: Buffer[A1]

abstract def toIndexedSeq: immutable.IndexedSeq[A]

abstract def toIterable: GenIterable[A]

abstract def toIterator: Iterator[A]

abstract def toList: List[A]

abstract def toMap[K, V](implicit ev: <:<[A, (K, V)]): GenMap[K, V]

abstract def toSeq: GenSeq[A]

abstract def toSet[A1 >: A]: GenSet[A1]

abstract def toStream: Stream[A]

abstract def toTraversable: GenTraversable[A]

abstract def toVector: Vector[A]

abstract def union(that: GenBag[A]): GenBag[A]

Returns a bag containing the multi-set union of this bag and that bag

abstract def zip[A1 >: A, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[GenBag[A], (A1, B), That]): That

abstract def zipAll[B, A1 >: A, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[GenBag[A], (A1, B), That]): That

abstract def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[GenBag[A], (A1, Int), That]): That

final def !=(arg0: Any): Boolean

final def ##(): Int

def &(that: GenBag[A]): GenBag[A]

Shorthand for intersect

def &~(that: GenBag[A]): GenBag[A]

Shorthand for diff

def +(elemCount: (A, Int)): GenBag[A]

def +(elem: A): GenBag[A]

Add the element to the bag

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def companion: GenericCompanion[GenIterable]

def distinctIterator: Iterator[A]

Iterator over distinct elements

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def finalize(): Unit

def flatten[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): GenIterable[B]

def genericBuilder[B]: Builder[B, GenIterable[B]]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def iterator: Iterator[A]

def maxMultiplicity: Int

Query for the maximum multiplicity of elements in the bag.

def minMultiplicity: Int

Query for the minimum multiplicity of elements in the bag.

def multiplicities: Iterator[(A, Int)]

def multiplicity(elem: A): Int

final def ne(arg0: AnyRef): Boolean

def newBuilder: Builder[A, GenIterable[A]]

final def notify(): Unit

final def notifyAll(): Unit

def par: ParIterable[A]

def subsetOf(that: GenBag[A]): Boolean

Tests if this bag is subset of that bag, where the subset is the multiset subset.

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): GenIterable[GenIterable[B]]

def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (GenIterable[A1], GenIterable[A2])

def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (GenIterable[A1], GenIterable[A2], GenIterable[A3])

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def |(that: GenBag[A]): GenBag[A]

Shorthand for union