Diet

abstract val isEmpty: Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def &(that: Diet[A])(implicit discrete: Enum[A], order: Order[A]): Diet[A]

intersection with the given diet

def +(range: Range[A])(implicit discrete: Enum[A], order: Order[A]): Diet[A]

alias for add

def +(value: A)(implicit discrete: Enum[A], order: Order[A]): Diet[A]

alias for add

def ++(that: Diet[A])(implicit discrete: Enum[A], order: Order[A]): Diet[A]

Returns the union of this Diet with another Diet.

def -(range: Range[A])(implicit discrete: Enum[A], order: Order[A]): Diet[A]

alias for removeRange

def -(value: A)(implicit discrete: Enum[A], order: Order[A]): Diet[A]

alias for remove

final def ==(arg0: Any): Boolean

def add(value: A)(implicit discrete: Enum[A], order: Order[A]): Diet[A]

Adds new value to the tree.

def addRange(range: Range[A])(implicit discrete: Enum[A], order: Order[A]): Diet[A]

Add new value range [x, y] to the Diet.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

Returns true if x is a value is in the tree.

def containsRange(range: Range[A])(implicit order: Order[A]): Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def foldLeft[B](s: B)(f: (B, A) ⇒ B)(implicit enumA: Enum[A], orderA: Order[A]): B

def foldRight[B](s: B)(f: (B, A) ⇒ B)(implicit enumA: Enum[A], orderA: Order[A]): B

final def getClass(): Class[_]

def hashCode(): Int

def intervals: List[Range[A]]

Returns a list of all disjoint sets in the tree where each set is represented by ARange.

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B)(implicit arg0: Enum[B], arg1: Order[B]): Diet[B]

def max: Option[A]

max value in the tree

def min: Option[A]

min value in the tree

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def remove(x: A)(implicit discrete: Enum[A], order: Order[A]): Diet[A]

remove x from the tree

def removeRange(range: Range[A])(implicit discrete: Enum[A], order: Order[A]): Diet[A]

remove a range from Diet

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

def toList()(implicit discrete: Enum[A], order: Order[A]): List[A]

Convert tree in a sorted list from all disjoint sets in the tree.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def |(that: Diet[A])(implicit discrete: Enum[A], order: Order[A]): Diet[A]

Returns the union of this Diet with another Diet.