EqHashSet

Companion object EqHashSet

class EqHashSet[A <: AnyRef] extends Set[A] with SetLike[A, EqHashSet[A]] with EqHash[A, EqHashSet[A]]

Linear Supertypes

Ordering

Alphabetic
By Inheritance

Inherited

EqHashSet
EqHash
Set
SetLike
Cloneable
Cloneable
Cloneable
Shrinkable
Builder
Growable
Clearable
Scriptable
Set
SetLike
Subtractable
GenSet
GenericSetTemplate
GenSetLike
Function1
Iterable
Iterable
IterableLike
Equals
GenIterable
GenIterableLike
Traversable
Mutable
Traversable
GenTraversable
GenericTraversableTemplate
TraversableLike
GenTraversableLike
Parallelizable
TraversableOnce
GenTraversableOnce
FilterMonadic
HasNewBuilder
AnyRef
Any

Implicitly

by CollectionsHaveToParArray
by MonadOps
by any2stringadd
by StringFormat
by Ensuring
by ArrowAssoc
by alternateImplicit

Hide All
Show All

Visibility

Public
All

Instance Constructors

new EqHashSet(other: EqHashSet[A])
new EqHashSet(_sizeHint: Int = EqHash.defCapacity)

Type Members

abstract class EqHashIterator[A] extends Iterator[A]

Attributes
protected
Definition Classes
EqHash
class KeyIndexIterator extends (EqHash.this)#EqHashIterator[Int]

Attributes
protected
Definition Classes
EqHash
type Self = EqHashSet[A]

Attributes
protected[this]
Definition Classes
TraversableLike
class WithFilter extends FilterMonadic[A, Repr]

Definition Classes
TraversableLike

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def &(that: GenSet[A]): EqHashSet[A]

Definition Classes
GenSetLike
def &~(that: GenSet[A]): EqHashSet[A]

Definition Classes
GenSetLike
def +(elem1: A, elem2: A, elems: A*): EqHashSet[A]

Definition Classes
SetLike → SetLike
Annotations
@migration
Migration
(Changed in version 2.8.0) + creates a new set. Use += to add an element to this set and return that set itself.
def +(elem: A): EqHashSet[A]

Definition Classes
SetLike → SetLike → GenSetLike
Annotations
@migration
Migration
(Changed in version 2.8.0) + creates a new set. Use += to add an element to this set and return that set itself.
def ++(xs: GenTraversableOnce[A]): EqHashSet[A]

Definition Classes
SetLike → SetLike
Annotations
@migration
Migration
(Changed in version 2.8.0) ++ creates a new set. Use ++= to add elements to this set and return that set itself.
def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[EqHashSet[A], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def ++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[EqHashSet[A], B, That]): That

Definition Classes
TraversableLike
def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[EqHashSet[A], B, That]): That

Definition Classes
TraversableLike
def ++=(xs: TraversableOnce[A]): EqHashSet.this.type

Definition Classes
Growable
def +=(elem: A): EqHashSet.this.type

Definition Classes
EqHashSet → SetLike → Builder → Growable
def +=(elem1: A, elem2: A, elems: A*): EqHashSet.this.type

Definition Classes
Growable
def -(elem1: A, elem2: A, elems: A*): EqHashSet[A]

Definition Classes
SetLike → Subtractable
Annotations
@migration
Migration
(Changed in version 2.8.0) - creates a new set. Use -= to remove an element from this set and return that set itself.
def -(elem: A): EqHashSet[A]

Definition Classes
SetLike → SetLike → Subtractable → GenSetLike
Annotations
@migration
Migration
(Changed in version 2.8.0) - creates a new set. Use -= to remove an element from this set and return that set itself.
def --(xs: GenTraversableOnce[A]): EqHashSet[A]

Definition Classes
SetLike → Subtractable
Annotations
@migration
Migration
(Changed in version 2.8.0) -- creates a new set. Use --= to remove elements from this set and return that set itself.
def --=(xs: TraversableOnce[A]): EqHashSet.this.type

Definition Classes
Shrinkable
def -=(elem: A): EqHashSet.this.type

Definition Classes
EqHashSet → SetLike → Shrinkable
def -=(elem1: A, elem2: A, elems: A*): EqHashSet.this.type

Definition Classes
Shrinkable
def ->[B](y: B): (EqHashSet[A], B)

Implicit
This member is added by an implicit conversion from EqHashSet[A] to ArrowAssoc[EqHashSet[A]] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
def /:[B](z: B)(op: (B, A) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def :\[B](z: B)(op: (A, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val _size: Int

Attributes
protected
Definition Classes
EqHash
def add(elem: A): Boolean

Definition Classes
EqHashSet → SetLike
def addString(b: StringBuilder): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, sep: String): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Definition Classes
TraversableOnce
def aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def andThen[A](g: (Boolean) ⇒ A): (A) ⇒ A

Definition Classes
Function1
Annotations
@unspecialized()
def apply(elem: A): Boolean

Definition Classes
GenSetLike → Function1
final def asInstanceOf[T0]: T0

Definition Classes
Any
def canEqual(other: Any): Boolean

Definition Classes
EqHashSet → IterableLike → Equals
def clear: Unit

Definition Classes
EqHash
def clone(): EqHashSet[A]

Definition Classes
EqHashSet → SetLike → Cloneable → AnyRef
final def closeDeletion(index: Int): Unit

Attributes
protected
Definition Classes
EqHash
def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[EqHashSet[A], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def collectFirst[B](pf: PartialFunction[A, B]): Option[B]

Definition Classes
TraversableOnce
def companion: GenericCompanion[Set]

Definition Classes
Set → Set → GenSet → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → GenericTraversableTemplate
def compose[A](g: (A) ⇒ A): (A) ⇒ Boolean

Definition Classes
Function1
Annotations
@unspecialized()
final def contains(elem: A): Boolean

Definition Classes
EqHashSet → SetLike → GenSetLike
Annotations
@inline()
def containsElem(elem: A): Boolean

Definition Classes
EqHashSet → EqHash
def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def copyToArray[B >: A](xs: Array[B]): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToArray[B >: A](xs: Array[B], start: Int): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToBuffer[B >: A](dest: Buffer[B]): Unit

Definition Classes
TraversableOnce
def count(p: (A) ⇒ Boolean): Int

Definition Classes
TraversableOnce → GenTraversableOnce
def diff(that: GenSet[A]): EqHashSet[A]

Definition Classes
SetLike → GenSetLike
def drop(n: Int): EqHashSet[A]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def dropRight(n: Int): EqHashSet[A]

Definition Classes
IterableLike
def dropWhile(p: (A) ⇒ Boolean): EqHashSet[A]

Definition Classes
TraversableLike → GenTraversableLike
def elemHashCode: (Array[AnyRef], Int) ⇒ Int

Attributes
protected
Definition Classes
EqHashSet → EqHash
def empty: EqHashSet[A]

Definition Classes
EqHashSet → SetLike → GenericSetTemplate
def ensuring(cond: (EqHashSet[A]) ⇒ Boolean, msg: ⇒ Any): EqHashSet[A]

Implicit
This member is added by an implicit conversion from EqHashSet[A] to Ensuring[EqHashSet[A]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (EqHashSet[A]) ⇒ Boolean): EqHashSet[A]

Implicit
This member is added by an implicit conversion from EqHashSet[A] to Ensuring[EqHashSet[A]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): EqHashSet[A]

Implicit
This member is added by an implicit conversion from EqHashSet[A] to Ensuring[EqHashSet[A]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): EqHashSet[A]

Implicit
This member is added by an implicit conversion from EqHashSet[A] to Ensuring[EqHashSet[A]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(other: Any): Boolean

Definition Classes
EqHash → AnyRef → Any
def exists(p: (A) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def filter(p: (A) ⇒ Boolean): EqHashSet[A]

Definition Classes
TraversableLike → GenTraversableLike
def filterNot(p: (A) ⇒ Boolean): EqHashSet[A]

Definition Classes
TraversableLike → GenTraversableLike
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: (A) ⇒ Boolean): Option[A]

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def flatMap[B, That](f: (A) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[EqHashSet[A], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def flatten[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): Set[B]

Definition Classes
GenericTraversableTemplate
def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def foldRight[B](z: B)(op: (A, B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def forall(p: (A) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def foreach[U](f: (A) ⇒ U): Unit

Definition Classes
IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
def formatted(fmtstr: String): String

Implicit
This member is added by an implicit conversion from EqHashSet[A] to StringFormat[EqHashSet[A]] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
def from(other: EqHashSet[A]): Unit

Definition Classes
EqHash
def genericBuilder[B]: Builder[B, Set[B]]

Definition Classes
GenericTraversableTemplate
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def groupBy[K](f: (A) ⇒ K): Map[K, EqHashSet[A]]

Definition Classes
TraversableLike → GenTraversableLike
def grouped(size: Int): Iterator[EqHashSet[A]]

Definition Classes
IterableLike
def hasDefiniteSize: Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def hashCode(): Int

Definition Classes
EqHash → AnyRef → Any
def head: A

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def headOption: Option[A]

Definition Classes
TraversableLike → GenTraversableLike
final def index(key: AnyRef): Int

Attributes
protected
Definition Classes
EqHash
Annotations
@inline()
def index(maskedKey: AnyRef, keyHash: Int, tabLength: Int): Int

Attributes
protected
Definition Classes
EqHash
def init: EqHashSet[A]

Definition Classes
TraversableLike → GenTraversableLike
def inits: Iterator[EqHashSet[A]]

Definition Classes
TraversableLike
def intersect(that: GenSet[A]): EqHashSet[A]

Definition Classes
GenSetLike
def isEmpty: Boolean

Definition Classes
SetLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isTraversableAgain: Boolean

Definition Classes
TraversableLike → GenTraversableLike → GenTraversableOnce
def iterator: Iterator[A]

Definition Classes
EqHashSet → GenSetLike → IterableLike → GenIterableLike
def last: A

Definition Classes
TraversableLike → GenTraversableLike
def lastOption: Option[A]

Definition Classes
TraversableLike → GenTraversableLike
def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[EqHashSet[A], B, That]): That

Definition Classes
SetLike → TraversableLike → GenTraversableLike → FilterMonadic
Annotations
@migration
Migration
(Changed in version 2.8.0) Set.map now returns a Set, so it will discard duplicate values.
def mapResult[NewTo](f: (EqHashSet[A]) ⇒ NewTo): Builder[A, NewTo]

Definition Classes
Builder
final def maskNull(key: AnyRef): AnyRef

Attributes
protected
Definition Classes
EqHash
Annotations
@inline()
def max[B >: A](implicit cmp: Ordering[B]): A

Definition Classes
TraversableOnce → GenTraversableOnce
def maxBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

Definition Classes
TraversableOnce → GenTraversableOnce
final def maxCapacity: Int

Attributes
protected
Definition Classes
EqHash
Annotations
@inline()
def min[B >: A](implicit cmp: Ordering[B]): A

Definition Classes
TraversableOnce → GenTraversableOnce
def minBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString: String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(sep: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(start: String, sep: String, end: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def move(oldTable: Array[AnyRef], oldLength: Int, newTable: Array[AnyRef], newLength: Int): Unit

Attributes
protected
Definition Classes
EqHashSet → EqHash
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newBuilder: Builder[A, EqHashSet[A]]

Attributes
protected[this]
Definition Classes
SetLike → SetLike → TraversableLike → HasNewBuilder
final def nextKeyIndex(i: Int, len: Int): Int

Attributes
protected
Definition Classes
EqHash
Annotations
@inline()
def nonEmpty: Boolean

Definition Classes
TraversableOnce → GenTraversableOnce
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
def par: ParSet[A]

Definition Classes
Parallelizable
def parCombiner: Combiner[A, ParSet[A]]

Attributes
protected[this]
Definition Classes
SetLike → SetLike → TraversableLike → Parallelizable
def partition(p: (A) ⇒ Boolean): (EqHashSet[A], EqHashSet[A])

Definition Classes
TraversableLike → GenTraversableLike
def product[B >: A](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceLeft[B >: A](op: (B, A) ⇒ B): B

Definition Classes
TraversableOnce
def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRight[B >: A](op: (A, B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def remove(elem: A): Boolean

Definition Classes
EqHashSet → SetLike
def repr: EqHashSet[A]

Definition Classes
TraversableLike → GenTraversableLike
def resize: Unit

Attributes
protected
Definition Classes
EqHash
def result(): EqHashSet[A]

Definition Classes
SetLike → Builder
def retain(p: (A) ⇒ Boolean): Unit

Definition Classes
SetLike
def reversed: List[A]

Attributes
protected[this]
Definition Classes
TraversableOnce
def sameElements[B >: A](that: GenIterable[B]): Boolean

Definition Classes
IterableLike → GenIterableLike
def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[EqHashSet[A], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[EqHashSet[A], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[EqHashSet[A], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
Annotations
@migration
Migration
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
def seq: Set[A]

Definition Classes
Set → Set → GenSet → GenSetLike → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
final def size: Int

Definition Classes
EqHash
Annotations
@inline()
final def sizeHint: Int

Attributes
protected
Definition Classes
EqHashSet → EqHash
def sizeHint(coll: TraversableLike[_, _], delta: Int): Unit

Definition Classes
Builder
def sizeHint(coll: TraversableLike[_, _]): Unit

Definition Classes
Builder
def sizeHint(size: Int): Unit

Definition Classes
Builder
def sizeHintBounded(size: Int, boundingColl: TraversableLike[_, _]): Unit

Definition Classes
Builder
def sizeHintIfCheap: Int

Attributes
protected[scala.collection]
Definition Classes
GenTraversableOnce
def slice(from: Int, until: Int): EqHashSet[A]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def sliding(size: Int, step: Int): Iterator[EqHashSet[A]]

Definition Classes
IterableLike
def sliding(size: Int): Iterator[EqHashSet[A]]

Definition Classes
IterableLike
def span(p: (A) ⇒ Boolean): (EqHashSet[A], EqHashSet[A])

Definition Classes
TraversableLike → GenTraversableLike
def splitAt(n: Int): (EqHashSet[A], EqHashSet[A])

Definition Classes
TraversableLike → GenTraversableLike
final def step: Int

Attributes
protected
Definition Classes
EqHashSet → EqHash
def stringPrefix: String

Definition Classes
SetLike → TraversableLike → GenTraversableLike
def subsetOf(that: GenSet[A]): Boolean

Definition Classes
GenSetLike
def subsets(): Iterator[EqHashSet[A]]

Definition Classes
SetLike
def subsets(len: Int): Iterator[EqHashSet[A]]

Definition Classes
SetLike
def sum[B >: A](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val table: Array[AnyRef]

Attributes
protected
Definition Classes
EqHash
def tail: EqHashSet[A]

Definition Classes
TraversableLike → GenTraversableLike
def tails: Iterator[EqHashSet[A]]

Definition Classes
TraversableLike
def take(n: Int): EqHashSet[A]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def takeRight(n: Int): EqHashSet[A]

Definition Classes
IterableLike
def takeWhile(p: (A) ⇒ Boolean): EqHashSet[A]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def thisCollection: Iterable[A]

Attributes
protected[this]
Definition Classes
IterableLike → TraversableLike
val threshold: Int

Attributes
protected
Definition Classes
EqHash
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, A, Col[A]]): Col[A]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toBuffer[A1 >: A]: Buffer[A1]

Definition Classes
SetLike → TraversableOnce → GenTraversableOnce
def toCollection(repr: EqHashSet[A]): Iterable[A]

Attributes
protected[this]
Definition Classes
IterableLike → TraversableLike
def toIndexedSeq: IndexedSeq[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterable: Iterable[A]

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def toIterator: Iterator[A]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toList: List[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def toMap[T, U](implicit ev: <:<[A, (T, U)]): Map[T, U]

Definition Classes
TraversableOnce → GenTraversableOnce
def toParArray: ParArray[T]

Implicit
This member is added by an implicit conversion from EqHashSet[A] to CollectionsHaveToParArray[EqHashSet[A], T] performed by method CollectionsHaveToParArray in scala.collection.parallel. This conversion will take place only if an implicit value of type (EqHashSet[A]) ⇒ GenTraversableOnce[T] is in scope.
Definition Classes
CollectionsHaveToParArray
def toSeq: Seq[A]

Definition Classes
SetLike → SetLike → TraversableOnce → GenTraversableOnce
def toSet[B >: A]: Set[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toStream: Stream[A]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
def toString(): String

Definition Classes
SetLike → Function1 → TraversableLike → AnyRef → Any
def toTraversable: Traversable[A]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toVector: Vector[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): Set[Set[B]]

Definition Classes
GenericTraversableTemplate
Annotations
@migration
Migration
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
def union(that: GenSet[A]): EqHashSet[A]

Definition Classes
SetLike → GenSetLike
final def unmaskNull(key: AnyRef): AnyRef

Attributes
protected
Definition Classes
EqHash
Annotations
@inline()
def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (Set[A1], Set[A2])

Definition Classes
GenericTraversableTemplate
def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (Set[A1], Set[A2], Set[A3])

Definition Classes
GenericTraversableTemplate
def update(elem: A, included: Boolean): Unit

Definition Classes
SetLike
def view(from: Int, until: Int): IterableView[A, EqHashSet[A]]

Definition Classes
IterableLike → TraversableLike
def view: IterableView[A, EqHashSet[A]]

Definition Classes
IterableLike → TraversableLike
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@native() @throws( ... )
def withFilter(p: (A) ⇒ Boolean): FilterMonadic[A, EqHashSet[A]]

Definition Classes
TraversableLike → FilterMonadic
def zip[A1 >: A, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[EqHashSet[A], (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipAll[B, A1 >: A, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[EqHashSet[A], (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[EqHashSet[A], (A1, Int), That]): That

Definition Classes
IterableLike → GenIterableLike
def |(that: GenSet[A]): EqHashSet[A]

Definition Classes
GenSetLike
def →[B](y: B): (EqHashSet[A], B)

Implicit
This member is added by an implicit conversion from EqHashSet[A] to ArrowAssoc[EqHashSet[A]] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Shadowed Implicit Value Members

def +(other: String): String
Implicit
This member is added by an implicit conversion from EqHashSet[A] to any2stringadd[EqHashSet[A]] performed by method any2stringadd in scala.Predef.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(eqHashSet: any2stringadd[EqHashSet[A]]).+(other)
Definition Classes
any2stringadd
def filter(p: (A) ⇒ Boolean): TraversableOnce[A]
Implicit
This member is added by an implicit conversion from EqHashSet[A] to MonadOps[A] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(eqHashSet: MonadOps[A]).filter(p)
Definition Classes
MonadOps
def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]
Implicit
This member is added by an implicit conversion from EqHashSet[A] to MonadOps[A] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(eqHashSet: MonadOps[A]).flatMap(f)
Definition Classes
MonadOps
def map[B](f: (A) ⇒ B): TraversableOnce[B]
Implicit
This member is added by an implicit conversion from EqHashSet[A] to MonadOps[A] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(eqHashSet: MonadOps[A]).map(f)
Definition Classes
MonadOps
def withFilter(p: (A) ⇒ Boolean): Iterator[A]
Implicit
This member is added by an implicit conversion from EqHashSet[A] to MonadOps[A] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(eqHashSet: MonadOps[A]).withFilter(p)
Definition Classes
MonadOps

Deprecated Value Members

def <<(cmd: Message[A]): Unit

Definition Classes
SetLike → Scriptable
Annotations
@deprecated
Deprecated
(Since version 2.11.0) scripting is deprecated

Inherited from EqHash[A, EqHashSet[A]]

Inherited from Set[A]

Inherited from SetLike[A, EqHashSet[A]]

Inherited from Cloneable[Set[A]]

Inherited from Cloneable

Inherited from Shrinkable[A]

Inherited from Builder[A, EqHashSet[A]]

Inherited from Growable[A]

Inherited from Clearable

Inherited from Scriptable[A]

Packages

EqHashSet 

Companion object EqHashSet

class EqHashSet[A <: AnyRef] extends Set[A] with SetLike[A, EqHashSet[A]] with EqHash[A, EqHashSet[A]]

Instance Constructors

Type Members

Value Members

Shadowed Implicit Value Members

Deprecated Value Members

Inherited from EqHash[A, EqHashSet[A]]

Inherited from Set[A]

Inherited from SetLike[A, EqHashSet[A]]

Inherited from Cloneable[Set[A]]

Inherited from Cloneable

Inherited from Cloneable

Inherited from Shrinkable[A]

Inherited from Builder[A, EqHashSet[A]]

Inherited from Growable[A]

Inherited from Clearable

Inherited from Scriptable[A]

Inherited from Set[A]

Inherited from SetLike[A, EqHashSet[A]]

Inherited from Subtractable[A, EqHashSet[A]]

Inherited from GenSet[A]

Inherited from GenericSetTemplate[A, Set]

Inherited from GenSetLike[A, EqHashSet[A]]

Inherited from (A) ⇒ Boolean

Inherited from Iterable[A]

Inherited from Iterable[A]

Inherited from IterableLike[A, EqHashSet[A]]

Inherited from Equals

Inherited from GenIterable[A]

Inherited from GenIterableLike[A, EqHashSet[A]]

Inherited from Traversable[A]

Inherited from Mutable

Inherited from Traversable[A]

Inherited from GenTraversable[A]

Inherited from GenericTraversableTemplate[A, Set]

Inherited from TraversableLike[A, EqHashSet[A]]

Inherited from GenTraversableLike[A, EqHashSet[A]]

Inherited from Parallelizable[A, ParSet[A]]

Inherited from TraversableOnce[A]

Inherited from GenTraversableOnce[A]

Inherited from FilterMonadic[A, EqHashSet[A]]

Inherited from HasNewBuilder[A, EqHashSet[A]]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion CollectionsHaveToParArray from EqHashSet[A] to CollectionsHaveToParArray[EqHashSet[A], T]

Inherited by implicit conversion MonadOps from EqHashSet[A] to MonadOps[A]

Inherited by implicit conversion any2stringadd from EqHashSet[A] to any2stringadd[EqHashSet[A]]

Inherited by implicit conversion StringFormat from EqHashSet[A] to StringFormat[EqHashSet[A]]

Inherited by implicit conversion Ensuring from EqHashSet[A] to Ensuring[EqHashSet[A]]

Inherited by implicit conversion ArrowAssoc from EqHashSet[A] to ArrowAssoc[EqHashSet[A]]

Inherited by implicit conversion alternateImplicit from EqHashSet[A] to ForceImplicitAmbiguity

Ungrouped

EqHashSet