TSet

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def contains(a: A): USTM[Boolean]

Tests whether or not set contains an element.

def delete(a: A): USTM[Unit]

Removes a single element from the set.

def deleteAll(as: Iterable[A]): USTM[Unit]

Removes elements from the set.

def diff(other: TSet[A]): USTM[Unit]

Atomically transforms the set into the difference of itself and the provided set.

def fold[B](zero: B)(op: (B, A) ⇒ B): USTM[B]

Atomically folds using a pure function.

def foldSTM[B, E](zero: B)(op: (B, A) ⇒ STM[E, B]): STM[E, B]

Atomically folds using a transactional function.

def foreach[E](f: (A) ⇒ STM[E, Unit]): STM[E, Unit]

Atomically performs transactional-effect for each element in set.

def getClass(): Class[_ <: AnyVal]

def intersect(other: TSet[A]): USTM[Unit]

Atomically transforms the set into the intersection of itself and the provided set.

def isEmpty: USTM[Boolean]

Tests if the set is empty or not

final def isInstanceOf[T0]: Boolean

def put(a: A): USTM[Unit]

Stores new element in the set.

def removeIf(p: (A) ⇒ Boolean): USTM[Unit]

Removes elements matching predicate.

def retainIf(p: (A) ⇒ Boolean): USTM[Unit]

Retains elements matching predicate.

def size: USTM[Int]

Returns the set's cardinality.

def takeFirst[B](pf: PartialFunction[A, B]): USTM[B]

Takes the first matching value, or retries until there is one.

def takeFirstSTM[R, E, B](pf: (A) ⇒ ZSTM[R, Option[E], B]): ZSTM[R, E, B]

def takeSome[B](pf: PartialFunction[A, B]): USTM[NonEmptyChunk[B]]

Takes all matching values, or retries until there is at least one.

def takeSomeSTM[R, E, B](pf: (A) ⇒ ZSTM[R, Option[E], B]): ZSTM[R, E, NonEmptyChunk[B]]

Takes all matching values, or retries until there is at least one.

def toList: USTM[List[A]]

Collects all elements into a list.

def toSet: USTM[Set[A]]

Collects all elements into a set.

def toString(): String

def transform(f: (A) ⇒ A): USTM[Unit]

Atomically updates all elements using a pure function.

def transformSTM[E](f: (A) ⇒ STM[E, A]): STM[E, Unit]

Atomically updates all elements using a transactional function.

def union(other: TSet[A]): USTM[Unit]

Atomically transforms the set into the union of itself and the provided set.

def foldM[B, E](zero: B)(op: (B, A) ⇒ STM[E, B]): STM[E, B]

Atomically folds using a transactional function.

def transformM[E](f: (A) ⇒ STM[E, A]): STM[E, Unit]

Atomically updates all elements using a transactional function.