TArray

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply(index: Int): USTM[A]

Extracts value from ref in array.

final def asInstanceOf[T0]: T0

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

Finds the result of applying a partial function to the first value in its domain.

def collectFirstSTM[E, B](pf: PartialFunction[A, STM[E, B]]): STM[E, Option[B]]

Finds the result of applying an transactional partial function to the first value in its domain.

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

Determine if the array contains a specified value.

def count(p: (A) ⇒ Boolean): USTM[Int]

Count the values in the array matching a predicate.

def countSTM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Int]

Count the values in the array matching a transactional predicate.

def exists(p: (A) ⇒ Boolean): USTM[Boolean]

Determine if the array contains a value satisfying a predicate.

def existsSTM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Boolean]

Determine if the array contains a value satisfying a transactional predicate.

def find(p: (A) ⇒ Boolean): USTM[Option[A]]

Find the first element in the array matching a predicate.

def findLast(p: (A) ⇒ Boolean): USTM[Option[A]]

Find the last element in the array matching a predicate.

def findLastSTM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Option[A]]

Find the last element in the array matching a transactional predicate.

def findSTM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Option[A]]

Find the first element in the array matching a transactional predicate.

def firstOption: USTM[Option[A]]

The first entry of the array, if it exists.

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

Atomically folds using a pure function.

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

Atomically folds using a transactional function.

def forall(p: (A) ⇒ Boolean): USTM[Boolean]

Atomically evaluate the conjunction of a predicate across the members of the array.

def forallSTM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Boolean]

Atomically evaluate the conjunction of a transactional predicate across the members of the array.

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

Atomically performs transactional effect for each item in array.

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

def indexOf(a: A, from: Int): USTM[Int]

Get the first index of a specific value in the array, starting at a specific index, or -1 if it does not occur.

def indexOf(a: A): USTM[Int]

Get the first index of a specific value in the array or -1 if it does not occur.

def indexWhere(p: (A) ⇒ Boolean, from: Int): USTM[Int]

Get the index of the first entry in the array, starting at a specific index, matching a predicate.

def indexWhere(p: (A) ⇒ Boolean): USTM[Int]

Get the index of the first entry in the array matching a predicate.

def indexWhereSTM[E](p: (A) ⇒ STM[E, Boolean], from: Int): STM[E, Int]

Starting at specified index, get the index of the next entry that matches a transactional predicate.

def indexWhereSTM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Int]

Get the index of the first entry in the array matching a transactional predicate.

final def isInstanceOf[T0]: Boolean

def lastIndexOf(a: A, end: Int): USTM[Int]

Get the first index of a specific value in the array, bounded above by a specific index, or -1 if it does not occur.

def lastIndexOf(a: A): USTM[Int]

Get the last index of a specific value in the array or -1 if it does not occur.

def lastOption: USTM[Option[A]]

The last entry in the array, if it exists.

def maxOption(implicit ord: Ordering[A]): USTM[Option[A]]

Atomically compute the greatest element in the array, if it exists.

def minOption(implicit ord: Ordering[A]): USTM[Option[A]]

Atomically compute the least element in the array, if it exists.

def reduceOption(op: (A, A) ⇒ A): USTM[Option[A]]

Atomically reduce the array, if non-empty, by a binary operator.

def reduceOptionSTM[E](op: (A, A) ⇒ STM[E, A]): STM[E, Option[A]]

Atomically reduce the non-empty array using a transactional binary operator.

def size: Int

Returns the size of the array.

def toChunk: USTM[Chunk[A]]

Collects all elements into a chunk.

def toList: USTM[List[A]]

Collects all elements into a list.

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 effect.

def update(index: Int, fn: (A) ⇒ A): USTM[Unit]

Updates element in the array with given function.

def updateSTM[E](index: Int, fn: (A) ⇒ STM[E, A]): STM[E, Unit]

Atomically updates element in the array with given transactional effect.

def collectFirstM[E, B](pf: PartialFunction[A, STM[E, B]]): STM[E, Option[B]]

Finds the result of applying an transactional partial function to the first value in its domain.

def countM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Int]

Count the values in the array matching a transactional predicate.

def existsM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Boolean]

Determine if the array contains a value satisfying a transactional predicate.

def findLastM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Option[A]]

Find the last element in the array matching a transactional predicate.

def findM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Option[A]]

Find the first element in the array matching a transactional predicate.

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

Atomically folds using a transactional function.

def forallM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Boolean]

Atomically evaluate the conjunction of a transactional predicate across the members of the array.

def indexWhereM[E](p: (A) ⇒ STM[E, Boolean], from: Int): STM[E, Int]

Starting at specified index, get the index of the next entry that matches a transactional predicate.

def indexWhereM[E](p: (A) ⇒ STM[E, Boolean]): STM[E, Int]

Get the index of the first entry in the array matching a transactional predicate.

def reduceOptionM[E](op: (A, A) ⇒ STM[E, A]): STM[E, Option[A]]

Atomically reduce the non-empty array using a transactional binary operator.

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

Atomically updates all elements using a transactional effect.

def updateM[E](index: Int, fn: (A) ⇒ STM[E, A]): STM[E, Unit]

Atomically updates element in the array with given transactional effect.