ox

A fork started using forkCancellable, backed by a (virtual) thread.

An error mode where errors are represented as Either[E, T] instances.

Describes the representation of application errors. Such errors have type E and are reported in context F.

An application error is a value which is returned as a successful completion of a fork. However, unlike regular values, such error values are reported and cause the enclosing scope to end.

For any type T, F[T] represents a value which might either:

• be successful; in that case, a T instance can be derived
• be an error; in that case, an E instance can be derived

A fork started using fork, forkError, forkUser, forkUserError, forkCancellable or forkPlain, backed by a (virtual) thread.

An error mode which doesn't allow reporting application errors.

However, forks can still fail by throwing exceptions.

Capability granted by an supervised or supervisedError concurrency scope.

Represents a capability to:

• fork supervised or unsupervised, asynchronously running computations in a concurrency scope. Such forks can be created using fork, forkUser, forkPlain or forkCancellable.
• register resources to be cleaned up after the scope ends

Capability granted by a supervisedError concurrency scope.

Represents a capability to:

• fork supervised or unsupervised, asynchronously running computations in a concurrency scope. Such forks can be created e.g. using forkError, forkUserError, fork, forkPlain, forkCancellable.
• register resources to be cleaned up after the scope ends

OxError is similar to Ox, however it additionally allows completing forks with application errors of type E in context F. Such errors cause enclosing scope to end, and any forks that are still running to be cancelled

Capability granted by an unsupervised concurrency scope (as well as, via subtyping, by supervised and supervisedError).

Represents a capability to:

• fork unsupervised, asynchronously running computations in a concurrency scope. Such forks can be created using forkPlain or forkCancellable.
• register resources to be cleaned up after the scope ends

An error mode where errors are represented as an union of E and T values. T should always be different from E, otherwise errors can't be told apart from successful values. To discern between the two, a class tag for E is necessary (it must have a distinct run-time representation).

Checks if the current thread is interrupted. Useful in compute-intensive code, which wants to cooperate in the cancellation protocol, e.g. when run in a supervised scope.

Repeat evaluating f forever.

Starts a fork (logical thread of execution), which is guaranteed to complete before the enclosing supervised or supervisedError block completes.

The fork behaves as a daemon thread. That is, if the body of the scope completes successfully, and all other user forks (created using forkUser) complete successfully, the scope will end, cancelling all running forks (including this one, if it's still running). That is, successful completion of this fork isn't required to end the scope.

An exception thrown while evaluating t will cause the fork to fail and the enclosing scope to end (cancelling all other running forks).

For alternate behaviors regarding ending the scope, see forkUser, forkError, forkUserError, forkCancellable and forkPlain.

For each thunk in the given sequence, starts a fork using fork. All forks are guaranteed to complete before the enclosing supervised or unsupervised block completes.

If ran in a supervised scope, all forks behave as daemon threads (see fork for details).

Starts a fork (logical thread of execution), which is guaranteed to complete before the enclosing supervised, supervisedError or unsupervised block completes, and which can be cancelled on-demand.

In case an exception is thrown while evaluating t, it will be thrown when calling the returned Fork's .join() method.

The fork is unsupervised (similarly to forkPlain), hence success or failure isn't signalled to the enclosing scope and doesn't influence the scope's lifecycle.

For alternate behaviors, see fork, forkError, forkUser, forkUserError and forkPlain.

Implementation note: a cancellable fork is created by starting a nested scope in a fork, and then starting a fork there. Hence, it is more expensive than fork, as two virtual threads are started.

Starts a fork (logical thread of execution), which is guaranteed to complete before the enclosing supervisedError block completes.

Behaves the same as fork, but additionally allows reporting application errors represented as values of type E in context F. An application error causes the enclosing scope to end.

Application errors are values with which forks might successfully complete, but are still considered a value-level representation of an error (as opposed to an exception, which isn't a value which is returned, but is thrown instead). Such errors are reported to the enclosing scope. If the ErrorMode provided when creating the scope using supervisedError classifies a fork return value as an error, the scope ends (cancelling all other running forks).

Starts a fork (logical thread of execution), which is guaranteed to complete before the enclosing supervised, supervisedError or unsupervised block completes.

In case an exception is thrown while evaluating t, it will be thrown when calling the returned Fork's .join() method.

Success or failure isn't signalled to the enclosing scope, and doesn't influence the scope's lifecycle.

For alternate behaviors, see fork, forkUser and forkCancellable.

Starts a fork (logical thread of execution), which is guaranteed to complete before the enclosing supervised or supervisedError block completes.

The fork behaves as a user-level thread. That is, the scope won't end until the body of the scope, and all other user forks (including this one) complete successfully. That is, successful completion of this fork is required to end the scope.

An exception thrown while evaluating t will cause the enclosing scope to end (cancelling all other running forks).

For alternate behaviors, see fork, forkError, forkUserError, forkCancellable and forkPlain.

Starts a fork (logical thread of execution), which is guaranteed to complete before the enclosing supervisedError block completes.

Behaves the same as forkUser, but additionally allows reporting application errors represented as values of type E in context F, which cause the enclosing scope to end.

Application errors are values with which forks might successfully complete, but are still considered a value-level representation of an error (as opposed to an exception, which isn't a value which is returned, but is thrown instead). Such errors are reported to the enclosing scope. If the ErrorMode provided when creating the scope using supervisedError classifies a fork return value as an error, the scope ends (cancelling all other running forks).

Blocks the current thread indefinitely, until it is interrupted.

Runs the given computations in parallel. If any fails, interrupts the others, and re-throws the exception.

Runs the given computations in parallel. If any fails, interrupts the others, and re-throws the exception.

Runs the given computations in parallel. If any fails, interrupts the others, and re-throws the exception.

Runs the given computations in parallel. If any fails, interrupts the others, and re-throws the exception.

Runs the given computations in parallel. If any fails because of an exception, or if any returns an application error, other computations are interrupted. Then, the exception is re-thrown, or the error value returned. Application errors must be of type E in context F, and each computation must return an F-wrapped value.

Runs the given computations in parallel. If any fails because of an exception, or if any returns an application error, other computations are interrupted. Then, the exception is re-thrown, or the error value returned. Application errors must be of type E in context F, and each computation must return an F-wrapped value.

Runs the given computations in parallel. If any fails because of an exception, or if any returns an application error, other computations are interrupted. Then, the exception is re-thrown, or the error value returned. Application errors must be of type E in context F, and each computation must return an F-wrapped value.

Runs the given computations in parallel. If any fails because of an exception, or if any returns an application error, other computations are interrupted. Then, the exception is re-thrown, or the error value returned. Application errors must be of type E in context F, and each computation must return an F-wrapped value.

Runs the given computations in parallel. If any fails because of an exception, or if any returns a Left, other computations are interrupted. Then, the exception is re-thrown, or the Left error value returned. Each computation must return an Either, with an error type being a subtype of E.

Runs the given computations in parallel. If any fails because of an exception, or if any returns a Left, other computations are interrupted. Then, the exception is re-thrown, or the Left error value returned. Each computation must return an Either, with an error type being a subtype of E.

Runs the given computations in parallel. If any fails because of an exception, or if any returns a Left, other computations are interrupted. Then, the exception is re-thrown, or the Left error value returned. Each computation must return an Either, with an error type being a subtype of E.

Runs the given computations in parallel. If any fails because of an exception, or if any returns a Left, other computations are interrupted. Then, the exception is re-thrown, or the Left error value returned. Each computation must return an Either, with an error type being a subtype of E.

Runs the given computations in parallel, with at most parallelism running in parallel at the same time. If any computation fails because of an exception, or if any returns a Left, other computations are interrupted. Then, the exception is re-thrown, or the Left error value returned. Each computation must return an Either, with an error type being a subtype of E.

Runs the given computations in parallel, with at most parallelism running in parallel at the same time. If any computation fails, interrupts the others, and re-throws the exception.

Runs the given computations in parallel, with at most parallelism running in parallel at the same time. If any computation fails because of an exception, or if any returns an application error, other computations are interrupted. Then, the exception is re-thrown, or the error value returned. Application errors must be of type E in context F, and each computation must return an F-wrapped value.

Returns the result of the first computation to complete successfully, or if all fail - throws the first exception.

Returns the result of the first computation to complete successfully, or if all fail / return an application error - throws the first exception / returns the first application error. Application errors must be of type E in context F, and each computation must return an F-wrapped value.

Returns the result of the first computation to complete successfully, or if all fail - throws the first exception.

Returns the result of the first computation to complete successfully, or if all fail - throws the first exception.

Returns the result of the first computation to complete successfully, or if all fail - throws the first exception.

Returns the result of the first computation to complete successfully, or if all fail / return an application error - throws the first exception / returns the first application error. Application errors must be of type E in context F, and each computation must return an F-wrapped value.

Returns the result of the first computation to complete successfully, or if all fail / return an application error - throws the first exception / returns the first application error. Application errors must be of type E in context F, and each computation must return an F-wrapped value.

Returns the result of the first computation to complete successfully, or if all fail / return an application error - throws the first exception / returns the first application error. Application errors must be of type E in context F, and each computation must return an F-wrapped value.

Returns the result of the first computation to complete successfully, or if all fail / return a Left - throws the first exception / returns the first Left. Each computation must return an Either, with an error type being a subtype of E.

Returns the result of the first computation to complete successfully, or if all fail / return a Left - throws the first exception / returns the first Left. Each computation must return an Either, with an error type being a subtype of E.

Returns the result of the first computation to complete successfully, or if all fail / return a Left - throws the first exception / returns the first Left. Each computation must return an Either, with an error type being a subtype of E.

Returns the result of the first computation to complete (either successfully or with an exception).

Returns the result of the first computation to complete (either successfully or with an exception).

Returns the result of the first computation to complete (either successfully or with an exception).

Returns the result of the first computation to complete (either successfully or with an exception).

Release the given resource, by running the release code block. Releasing is done after all the forks in the scope complete (either successfully or with an error), but before the current concurrency scope completes. Releasing is uninterruptible.

Release the given resource, which implements AutoCloseable, by running its .close() method. Releasing is done after all the forks in the scope complete (either successfully or with an error), but before the current concurrency scope completes. Releasing is uninterruptible.

Repeat evaluating f until it evaluates to true.

Repeat evaluating f while it evaluates to true.

Sleep (block the current thread/fork) for the provided amount of time.

Starts a new concurrency scope, which allows starting forks in the given code block f. Forks can be started using fork, forkUser, forkCancellable and forkPlain. All forks are guaranteed to complete before this scope completes.

The scope is ran in supervised mode, that is:

• the scope ends once all user, supervised forks (started using forkUser), including the f body, succeed. Forks started using fork (daemon) don't have to complete successfully for the scope to end.
• the scope also ends once the first supervised fork (including the f main body) fails with an exception
• when the scope ends, all running forks are cancelled
• the scope completes (that is, this method returns) only once all forks started by f have completed (either successfully, or with an exception)

Upon successful completion, returns the result of evaluating f. Upon failure, the exception that caused the scope to end is re-thrown (regardless if the exception was thrown from the main body, or from a fork). Any other exceptions that occur when completing the scope are added as suppressed.

Starts a new concurrency scope, which allows starting forks in the given code block f. Forks can be started using fork, forkError, forkUser, forkUserError, forkCancellable and forkPlain. All forks are guaranteed to complete before this scope completes.

Behaves the same as supervised, but additionally allows reporting application errors represented as values of type E in context F. An application error causes the enclosing scope to end.

The result of computation t, if it took less than duration, and a TimeoutException otherwise.

Result of the computation t if it took less than duration, and Left(timeoutValue) otherwise.

A Some if the computation t took less than duration, and None otherwise.

Prevent f from being interrupted. Any interrupted exceptions that occur while evaluating f will be re-thrown once it completes.

Starts a new concurrency scope, which allows starting forks in the given code block f. Forks can be started using forkPlain, and forkCancellable. All forks are guaranteed to complete before this scope completes.

It is advisable to use supervised scopes if possible, as they minimise the chances of an error to go unnoticed.

The scope is ran in unsupervised mode, that is:

• the scope ends once the f body completes; this causes any running forks started within f to be cancelled
• the scope completes (that is, this method returns) only once all forks started by f have completed (either successfully, or with an exception)
• fork failures aren't handled in any special way, but can be inspected using Fork.join

Upon successful completion, returns the result of evaluating f. Upon failure, that is an exception thrown by f, it is re-thrown.

Use the given resource, acquired using acquire and released using release in the given f code block. Releasing is uninterruptible. To use multiple resource, consider created a supervised scope and useInScope method.

Use the given AutoCloseable resource, acquired using acquire in the given f code block. Releasing is uninterruptible. To use multiple resource, consider created a supervised scope and useCloseableInScope method.

Use the given resource, which implements AutoCloseable, in the current concurrency scope. The resource is allocated using acquire, and released after the all forks in the scope complete (either successfully or with an error), using AutoCloseable.close(). Releasing is uninterruptible.

Use the given resource in the current concurrency scope. The resource is allocated using acquire, and released after the all forks in the scope complete (either successfully or with an error), using release. Releasing is uninterruptible.