ISet

abstract val size: Int

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def \\(other: ISet[A])(implicit o: Order[A]): ISet[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

Alias for member

final def delete(x: A)(implicit o: Order[A]): ISet[A]

final def deleteAt(i: Int): ISet[A]

final def deleteFindMax: (A, ISet[A])

final def deleteFindMin: (A, ISet[A])

final def deleteMax: ISet[A]

final def deleteMin: ISet[A]

final def difference(other: ISet[A])(implicit o: Order[A]): ISet[A]

final def elemAt(i: Int): Option[A]

Alias for Foldable[ISet].index

final def elems: List[A]

final def eq(arg0: AnyRef): Boolean

final def equals(other: Any): Boolean

final def filter(p: (A) ⇒ Boolean): ISet[A]

final def filterGt(a: Option[A])(implicit o: Order[A]): ISet[A]

final def filterLt(a: Option[A])(implicit o: Order[A]): ISet[A]

def finalize(): Unit

final def findMax: Option[A]

final def findMin: Option[A]

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

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

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

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

final def getClass(): Class[_]

final def hashCode(): Int

final def insert(x: A)(implicit o: Order[A]): ISet[A]

final def intersection(other: ISet[A])(implicit o: Order[A]): ISet[A]

final def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

final def isProperSubsetOf(other: ISet[A])(implicit o: Order[A]): Boolean

final def isSubsetOf(other: ISet[A])(implicit o: Order[A]): Boolean

final def lookupGE(x: A)(implicit o: Order[A]): Option[A]

final def lookupGT(x: A)(implicit o: Order[A]): Option[A]

final def lookupIndex(x: A)(implicit o: Order[A]): Option[Int]

final def lookupLE(x: A)(implicit o: Order[A]): Option[A]

final def lookupLT(x: A)(implicit o: Order[A]): Option[A]

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

For the Functor composition law to hold it is important that the Order[B] is substitutive for the Order[A] – that is, that the Order[B] should be no stronger, it should not distinguish two B instances that would be considered as equal A instances.

-- | /O(n*log n)/.
-- @'map' f s@ is the set obtained by applying @f@ to each element of @s@.
--
-- It's worth noting that the size of the result may be smaller if,
-- for some @(x,y)@, @x \/= y && f x == f y@

final def maxView: Option[(A, ISet[A])]

final def member(x: A)(implicit o: Order[A]): Boolean

def merge(other: ISet[A]): ISet[A]

final def minView: Option[(A, ISet[A])]

final def ne(arg0: AnyRef): Boolean

final def notMember(x: A)(implicit o: Order[A]): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def partition(p: (A) ⇒ Boolean): (ISet[A], ISet[A])

final def split(x: A)(implicit o: Order[A]): (ISet[A], ISet[A])

final def splitMember(x: A)(implicit o: Order[A]): (ISet[A], Boolean, ISet[A])

final def splitRoot: List[ISet[A]]

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

final def toAscList: List[A]

final def toDescList: List[A]

final def toList: List[A]

def toString(): String

final def trim(a: Option[A], b: Option[A])(implicit o: Order[A]): ISet[A]

final def union(other: ISet[A])(implicit o: Order[A]): ISet[A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit