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.

Performs an atomic read; equivalent to apply().

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

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

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

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