Tascalate Concurrent 0.9.0

This release adds several major features as long as refactorings of the existing API (so it has some breaking changes):

1. Revisit and refactor Promise.raw() functionality and introducing Promise.unwrap() (single-level undecoration) in addition to Promise.raw() (full undecoration); fixing all related code to use unwrap in favor of raw.
2. Adding new operators to Promise - thenFilter and thenFilterAsync
3. Adding missing Thread / Executor -related stuff: TaskCompletionService, TreadFactoryBuilder, ThreadGroupBuilder and alike.
4. Revisiting ContextVar and related context-aware functionality: shifting responsibilities, introducing ContextTrampoline, provide an option to create contex-aware Executor-s in addition to context-aware Promise-s.
5. Adding asynchronous version of try-with-resource functionality to Promises that supports both synchronously closeable resources (std. AutoClosable) and asynchronously closeable resources (implementing library-specific AsyncCloseable).
6. Adding AsyncCompletions class that provides an option to iterate / stream over completed Promise-s results (loaded by batches).
7. Providing an option to partitioned collections processing with Promises.partitioned.
8. Introduce PromiseOperations class that exposes utility methods for convenient decoration of Promise-s via Promise.as(decorator) operation.
9. Adding Promises.loop to provide asynchronous function-style equivalent of Java loops (like for / while / do-while).
10. Refactor retry functionality (fix corner cases, simplifying code using asynchronous loop).
11. Complement all / any[Strict] / atLeast[Strict] / with overloaded methods that accepts and returns keyed collections (java.util.Map) in addition to indexed collections.

Tascalate Concurrent 0.8.4

Minor release with the following changes:

1. Fix bug in default DelayPolicy.withMinDelay(...) metod -- erroneously delegates to withMaxDelay.
2. Remove rarely used internal helper classes to minimize library size.

Tascalate Concurrent 0.8.3

The following changes are done:

1. Fixed error with unimplemented methods for children of AbstractPromiseDecorator (sic!)
2. Avoid async operations with exceptionallyAsync / exceptionallyComposeAsync when no exception produced.
3. Simplify Promise default methods logic via delegation to DependentPromise (it's used anyway) -- reduces code duplication.
4. Remove non-api methods from Promises class.
5. Introducing Promise.onCancel operator -- execute custom code block when promise is cancelled (directly, or as dependent promise or via timeout)

Tascalate Concurrent 0.8.2

The following changes is done:

1. Adding new Java 12 CompletionStage API methods: exceptionallyAsync, composeExceptionally, composeExceptionallyAsync.
2. Adding meaningful stack trace to MultitargetException (includes stack traces of child exceptions).

Tascalate Concurrent 0.8.1

The following changes are made since 0.8.0

1. Fixed timeout handling in Promises.retry* - previously only timeout set was cancellable, not the original promise.
2. Fixed error in RetryPolicy that prevents creating infinite retry operations.
3. Revisited decorators hierarchy
4. Fix numerous bugs in decorators (enlistOptions are not passed for dependent promise decorator; wrong behavior for defaultAsyncOn / dependent decorators)
5. Introduced ContextVar -- now it's possible to relay contextual variables (ThreadLocal-s) to composition operations on Promise-s

Tascalate Concurrent 0.8.0

The following changes are made since 0.7.1

1. Fixed exceptional completion handling in Promise.orTimeout and Promise.onTimeout operations
2. The artifact was renamed to align naming across other Tascalate projects

IMPORTANT!
From version 0.8.0 please use the following artifact name:

<dependency>
    <groupId>net.tascalate</groupId>
    <artifactId>net.tascalate.concurrent</artifactId>
    <version>0.8.0</version>
</dependency>

The old naming was:

<dependency>
    <groupId>net.tascalate.concurrent</groupId>
    <artifactId>net.tascalate.concurrent.lib</artifactId>
    <version>0.7.1</version>
</dependency>

Tascalate Concurrent 0.7.1

Minor enhancements:

1. Decorators returned from Promise.defaultAsyncOn(executor) now avoids nesting decoration on defaultAsyncOn
2. The result of Promises.retry with Executor argument (i.e. all methods except Promises.retryFuture) now has a default asynchronous Executor set to the parameter.

Tascalate Concurrent 0.7.0 (Java 9+ support / Promises.retry refactoring)

The release contains both important bug fixing and important refactorings:

1. Promise.orTimeout was fixed (previously no cancellation on timeout)
2. Promise.delay was fixed (previously no delay on error)
3. The Executor used after timeout methods now is always the default asynchronous executor of the original Promise (previously this requirement was not hold in some cases).
4. Promises.retry* and Promises.poll* functionality has been fully revisited -- now only retry is left and it's a responsibility of RetryPolicy to define what result is valid (hence more flexible options besides just non-null are possible); RetryPolicy / DelayPolicy / RetryContext was intensively revisited and are not compatible with previous version.
5. CompletableTask.submit method is added to allow submitting a Callable -- i.e. a lambda that throws any exception.
6. Now library is created as a multi-release JAR and may be used with Java 8 as regular classpath library or with Java 9+ as a module

Bug fixing release

• Fixes "hanged" promises when Executor.execute throws RejectedExecutionException.
• Internal code refactorings and simplifications (within AbstractCompletableTask hierarchy)

Bug fixing release

Fix exception handling in AbstractCompletableTask.whenCompleteAsync