Blocks until f(get) is true, in a manner consistent with the current context. Requires that the predicate be safe to reevaluate, and that f(x) == f(y) if x == y.

v.await(f) is equivalent to

atomic { implicit t =>
  if (!f(v.get)) retry
}

If you want to wait for a predicate that involves more than one Ref then use retry directly.

Equivalent to atomically executing (if (before == get) { set(after); true } else false), but may be more efficient, especially if there is no enclosing atomic block.

Equivalent to atomically executing (if (before eq get) { set(after); true } else false), but may be more efficient, especially if there is no enclosing atomic block.

Performs an atomic read; equivalent to apply().

Atomically replaces the value v stored in the Ref with f(v), returning the old value. transform should be preferred if the return value is not needed, since it gives the STM more flexibility to avoid transaction conflicts.

Acts like ref.getWith(f) if there is an active transaction, otherwise just returns f(get).

Returns a Ref that accesses the same memory location as this view. The returned Ref might be the original reference that was used to construct this view, or it might be a Ref that is equivalent (and ==) to the original.

Acts like ref.relaxedGet(equiv) if there is an active transaction, otherwise just returns get.

Performs an atomic write; equivalent to update(v).

Works like set(v), but returns the old value. This is an atomic swap, equivalent to atomically performing a get followed by set(v).

Atomically replaces the value v stored in the Ref with f(v). Some Ref implementations may defer execution of f or call f multiple times to avoid transaction conflicts.

Atomically replaces the value v stored in the Ref with f(v), returning the new value. transform should be preferred if the return value is not needed, since it gives the STM more flexibility to avoid transaction conflicts.

Atomically replaces the value v stored in the Ref with pf(v) if pf.isDefinedAt(v), returning true, otherwise leaves the element unchanged and returns false. pf.apply and pf.isDefinedAt might be invoked multiple times by the STM, and might be called later in any enclosing atomic block.

Blocks until f(get) is true and returns true, or returns false if the condition does not become true within within the specified timeout.

v.tryAwait(timeout)(f) is equivalent to

atomic { implicit t =>
  f(v.get) || { retryFor(timeout) ; false }
}

Performs an atomic write and returns true, or returns false. The STM implementation may choose to return false to reduce (not necessarily avoid) blocking. If no other threads are performing any transactional or atomic accesses then this method will succeed.

Transforms the value stored in the Ref by multiplying it.

Note: Implementations may choose to ignore the provided Numeric[A] instance if A is a primitive type.

Transforms the value stored in the Ref by incrementing it.

Note: Implementations may choose to ignore the provided Numeric[A] instance if A is a primitive type.

Transforms the value stored in the Ref by decrementing it.

Note: Implementations may choose to ignore the provided Numeric[A] instance if A is a primitive type.

Transforms the value stored in ref by performing a division on it, throwing away the remainder if division is not exact for instances of type A. The careful reader will note that division is actually provided by Fractional[A] or Integral[A], it is not defined on Numeric[A]. To avoid compile-time ambiguity this method accepts a Numeric[A] and assumes that it can be converted at runtime into either a Fractional[A] or an Integral[A].

Note: Implementations may choose to ignore the provided Numeric[A] instance if A is a primitive type.

Performs an atomic read of the value in ref. If an atomic block is active (see Txn.findCurrent) then the read will be performed as part of the transaction, otherwise it will act as if it was performed inside a new atomic block. Equivalent to get.

Returns a string representation of the transactional value in this instance for debugging convenience. The Ref reads (and writes) performed while constructing the result will be discarded before returning. This method works fine outside a transaction.

If this method is called from within a transaction that is already doomed (status Txn.Rolledback), a string describing the reason for the outer transaction's rollback will be returned.

Returns some value that is suitable for examination in a debugger, or returns a Txn.RollbackCause if called from inside a doomed atomic block.

Atomically replaces the value v stored in the Ref with the first element of the 2-tuple returned by f(v), returning the second element.

Performs an atomic write of the value in ref. If an atomic block is active (see Txn.findCurrent) then the write will be performed as part of the transaction, otherwise it will act as if it was performed inside a new atomic block. Equivalent to set(v).