Set

abstract def isEmpty: Boolean

Returns true if the Set is the empty Set.

abstract val size: Int

The number of items in the Set.

final def !=(arg0: Any): Boolean

final def ##(): Int

def &(another: Set[A])(implicit order: Order[A]): Set[A]

Return a Set containing the intersection of elements with this Set and the given Set.

def +(x: A)(implicit order: Order[A]): Set[A]

Add's the given element to the Set if it is not already present.

def ++(another: Set[A])(implicit order: Order[A]): Set[A]

Return a Set containing the union of elements with this Set and the given Set.

def -(removals: Set[A])(implicit order: Order[A]): Set[A]

Return a Set that has any elements appearing in the removals set removed O(n log n)

final def ==(arg0: Any): Boolean

def add(x: A)(implicit order: Order[A]): Branch[A]

Add's the given element to the Set if it is not already present.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def contains(x: A)(implicit order: Order[A]): Boolean

Returns true if the given element is in the Set.

def diff(removals: Set[A])(implicit order: Order[A]): Set[A]

Return a Set that has any elements appearing in the removals set removed O(n log n)

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def find(pred: (A) ⇒ Boolean): Option[A]

Find the minimum element matching the given predicate.

def flatMap[B](f: (A) ⇒ Set[B])(implicit arg0: Order[B]): Set[B]

Map a function on all values of the set

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

fold the elements together from min to max, using the passed seed, and accumulator function.

def foldRight[B](z: Eval[B])(f: (A, Eval[B]) ⇒ Eval[B]): Eval[B]

fold the elements together from min to max, using the passed seed, and accumulator function.

final def getClass(): Class[_]

def hashCode(): Int

def intersect(another: Set[A])(implicit order: Order[A]): Set[A]

Return a Set containing the intersection of elements with this Set and the given Set.

final def isInstanceOf[T0]: Boolean

def iset(implicit order: Order[A]): ISet[A]

Return an ISet (intentional set) with the same members as this set

def map[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Set[B]

Map a function on all values of the set

def max: Option[A]

Retruns None if the Set is empty, otherwise returns the maximum element.

def min: Option[A]

Retruns None if the Set is empty, otherwise returns the minumum element.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def remove(x: A)(implicit order: Order[A]): Set[A]

Return a Set which does not contain the given element.

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

def toList(): List[A]

Return the sorted list of elements.

def toScalaSet: scala.collection.immutable.Set[A]

Return a scala set containing the elments in the Set O(n)

def toString(): String

def union(another: Set[A])(implicit order: Order[A]): Set[A]

Return a Set containing the union of elements with this Set and the given Set.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def |(another: Set[A])(implicit order: Order[A]): Set[A]

Return a Set containing the union of elements with this Set and the given Set.