docs: replace "aka" with "i.e." for clarity and consistency 📚

Author: oldratlee

README.md

@@ -82,11 +82,11 @@ Welcome 👏💖
     - Such as methods `allResultsFailFastOf` / `mSupplyFailFastAsync` / `thenMApplyMostSuccessAsync`
   - Support for directly running multiple `Action`s instead of wrapping them into `CompletableFuture`s first
     - Such as methods `mSupplyAsync` / `mRunFailFastAsync` / `thenMApplyAllSuccessAsync`
-    - Aka. multiple instruction, single data (`MISD`) style processing
+    - i.e. multiple instruction, single data (`MISD`) style processing
   - Support for async parallel processing of collection data,
     instead of wrapping data with actions into `CompletableFuture`s first
     - Such as methods `CfParallelUtils#parApplyFailFastAsync` / `CfParallelUtils#thenParAcceptAnySuccessAsync`
-    - Aka. single instruction, multiple data (`SIMD`) style processing
+    - i.e. single instruction, multiple data (`SIMD`) style processing
   - Support for inputting collections of `CF`s / `Action`s instead of converting them to array first
     - Such as methods `CfIterableUtils#allResultsFailFastOf` /
       `CfIterableUtils#mSupplyFailFastAsync` / `CfIterableUtils#thenMApplyMostSuccessAsync`
@@ -415,7 +415,7 @@ public class AnySuccessDemo {
 
 ### 2.4 support for setting the default business thread pool
 
-The default thread pool used by `CompletableFuture` async execution (aka. `*Async` methods)
+The default thread pool used by `CompletableFuture` async execution (i.e. `*Async` methods)
 is `ForkJoinPool.commonPool()`; using this default thread pool in business is very dangerous❗
 
 - `ForkJoinPool.commonPool()` has about as many threads as CPUs, suitable for executing CPU-intensive tasks;
@@ -808,29 +808,29 @@ Supports 3-parameter types for representing multiple `Action`s: varargs array, c
 
 - Multiple parameter varargs input, input type is **array type**
   - Corresponding method groups:
-    - `CompletableFutureUtils.M*` methods, aka. `Multi-Actions(M*) Methods`
-    - `CompletableFutureUtils.thenM*` methods, aka. `Then-Multi-Actions(thenM*) Methods`
+    - `CompletableFutureUtils.M*` methods, i.e. `Multi-Actions(M*) Methods`
+    - `CompletableFutureUtils.thenM*` methods, i.e. `Then-Multi-Actions(thenM*) Methods`
 - Collection parameter input, input type is **`Iterable`**
   - Corresponding method groups:
-    - `CfIterableUtils.M*`, aka. `Multi-Actions(M*) Methods`
-    - `CfIterableUtils.thenM*`, aka. `Then-Multi-Actions(thenM*) Methods`
+    - `CfIterableUtils.M*`, i.e. `Multi-Actions(M*) Methods`
+    - `CfIterableUtils.thenM*`, i.e. `Then-Multi-Actions(thenM*) Methods`
   - The method names and functionality of this group are the same as the "multiple parameter varargs input" above,
     but the parameter types for multiple `Action` inputs are different (`Iterable` vs. array)
 - Multiple `Action` inputs with different generic parameter types, input type is **`Tuple`**
   - Corresponding method groups:
-    - `CfTupleUtils.MTuple*`, aka. `Multi-Actions-Tuple(MTuple*) Methods`
-    - `CfTupleUtils.thenMTuple*`, aka. `Then-Multi-Actions-Tuple(thenMTuple*) Methods`
+    - `CfTupleUtils.MTuple*`, i.e. `Multi-Actions-Tuple(MTuple*) Methods`
+    - `CfTupleUtils.thenMTuple*`, i.e. `Then-Multi-Actions-Tuple(thenMTuple*) Methods`
 
-Multiple `Action`s perform asynchronous parallel processing on (single same) data, aka. Multiple Instruction, Single Data (`MISD`).
+Multiple `Action`s perform asynchronous parallel processing on (single same) data, i.e. Multiple Instruction, Single Data (`MISD`).
 
 2\) **Multiple Data Inputs**
 
-Asynchronous parallel processing of multiple data through a single same `Action`, aka. Single Instruction, Multiple Data (`SIMD`).
+Asynchronous parallel processing of multiple data through a single same `Action`, i.e. Single Instruction, Multiple Data (`SIMD`).
 
 Corresponding method groups:
 
-- `CfParallelUtils.Par*` methods, aka. `Multi-Data(Par*) Methods`
-- `CfParallelUtils.thenPar*` methods, aka. `Then-Multi-Data(thenPar*) Methods`
+- `CfParallelUtils.Par*` methods, i.e. `Multi-Data(Par*) Methods`
+- `CfParallelUtils.thenPar*` methods, i.e. `Then-Multi-Data(thenPar*) Methods`
 
 In business logic, collections should be used to hold multiple data rather than arrays;
 if business logic holds multiple data in array type, it can be easily converted to the collection type,
@@ -860,19 +860,19 @@ Including `Action`s in the form of `Lambda` literal.
 
 - When the number of `Action`s is fixed/known,
   use "multiple parameter varargs `Action`" methods, corresponding method groups:
-  - `CompletableFutureUtils.M*` methods, aka. `Multi-Actions(M*) Methods`
-  - `CompletableFutureUtils.thenM*` methods, aka. `Then-Multi-Actions(thenM*) Methods`
+  - `CompletableFutureUtils.M*` methods, i.e. `Multi-Actions(M*) Methods`
+  - `CompletableFutureUtils.thenM*` methods, i.e. `Then-Multi-Actions(thenM*) Methods`
 - When the number of `Action`s is not fixed,
   use "`Action` collection" methods, corresponding method groups:
-  - `CfIterableUtils.M*`, aka. `Multi-Actions(M*) Methods`
-  - `CfIterableUtils.thenM*`, aka. `Then-Multi-Actions(thenM*) Methods`
+  - `CfIterableUtils.M*`, i.e. `Multi-Actions(M*) Methods`
+  - `CfIterableUtils.thenM*`, i.e. `Then-Multi-Actions(thenM*) Methods`
 
 2\) When business processing logic has multiple data for asynchronous parallel processing
 
 Use "multiple data input" methods, corresponding method groups:
 
-- `CfParallelUtils.Par*` methods, aka. `Multi-Data(Par*) Methods`
-- `CfParallelUtils.thenPar*` methods, aka. `Then-Multi-Data(thenPar*) Methods`
+- `CfParallelUtils.Par*` methods, i.e. `Multi-Data(Par*) Methods`
+- `CfParallelUtils.thenPar*` methods, i.e. `Then-Multi-Data(thenPar*) Methods`
 
 3\) When business processing logic input only has multiple `CompletableFuture`s
 
@@ -898,7 +898,7 @@ Compared to the above method groups (multiple `Action`s/multiple data), these me
 > should be treated as lower-level basic methods, used only when necessary.
 >
 > In critical business logic, when using these methods, pay attention to
-> implementing good exception reporting logic (aka. don't swallow exceptions):
+> implementing good exception reporting logic, i.e. don't swallow exceptions:
 > - For implementation reference, see `cffu` implementation code, such as `CompletableFutureUtils.mSupplyFailFastAsync()`
 > - The `cffu` library provides support utility class [`SwallowedExceptionHandleUtils`](https://foldright.io/api-docs/cffu2/2.0.6/io/foldright/cffu2/eh/SwallowedExceptionHandleUtils.html)
     for implementing orchestration exception reporting

cffu-core/src/main/java/io/foldright/cffu2/BaseCffu.java

@@ -1296,8 +1296,8 @@ public final Cffu<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable a
      * Otherwise, the returned Cffu contains the same result as this Cffu.
      * <p>
      * <strong>"The exception from this Cffu"</strong> means the cause of the {@link ExecutionException}
-     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself;
-     * aka the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
+     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself,
+     * i.e. the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
      *
      * @param exceptionType the exception type that triggers use of {@code fallback}. The exception type is matched
      *                      against the exception from this Cffu. To avoid hiding bugs and other unrecoverable errors,
@@ -1317,8 +1317,8 @@ public final <X extends Throwable> F catching(Class<X> exceptionType, Function<?
      * Otherwise, the returned Cffu contains the same result as this Cffu.
      * <p>
      * <strong>"The exception from this Cffu"</strong> means the cause of the {@link ExecutionException}
-     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself;
-     * aka the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
+     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself,
+     * i.e. the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
      *
      * @param exceptionType the exception type that triggers use of {@code fallback}. The exception type is matched
      *                      against the exception from this Cffu. To avoid hiding bugs and other unrecoverable errors,
@@ -1339,8 +1339,8 @@ public final <X extends Throwable> F catchingAsync(
      * Otherwise, the returned Cffu contains the same result as this Cffu.
      * <p>
      * <strong>"The exception from this Cffu"</strong> means the cause of the {@link ExecutionException}
-     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself;
-     * aka the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
+     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself,
+     * i.e. the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
      *
      * @param exceptionType the exception type that triggers use of {@code fallback}. The exception type is matched
      *                      against the exception from this Cffu. To avoid hiding bugs and other unrecoverable errors,
@@ -1458,8 +1458,8 @@ public final F orTimeout(long timeout, TimeUnit unit) {
      * instead of this method. Using this method is appropriate only when:
      * <ul>
      * <li>the returned Cffu is only read explicitly(e.g. by get/join/resultNow methods),
-     * <li>and/or all subsequent actions of dependent Cffus/CompletableFutures are guaranteed to execute asynchronously
-     *    (i.e., the dependent Cffus/CompletableFutures are created using async methods).
+     * <li>and/or all subsequent actions of dependent Cffus/CompletableFutures are guaranteed to execute asynchronously,
+     *    i.e. the dependent Cffus/CompletableFutures are created using async methods.
      * </ul> In these cases, using this unsafe method avoids an unnecessary thread switching when timeout occurs; However,
      * these conditions are difficult to guarantee in practice, especially when the returned Cffu is used by others' codes.
      * <p>
@@ -1519,8 +1519,8 @@ public final F completeOnTimeout(@Nullable T value, long timeout, TimeUnit unit)
      * completeOnTimeout} instead of this method. Using this method is appropriate only when:
      * <ul>
      * <li>the returned Cffu is only read explicitly(e.g. by get/join/resultNow methods),
-     * <li>and/or all subsequent actions of dependent Cffus/CompletableFutures are guaranteed to execute asynchronously
-     *    (i.e., the dependent Cffus/CompletableFutures are created using async methods).
+     * <li>and/or all subsequent actions of dependent Cffus/CompletableFutures are guaranteed to execute asynchronously,
+     *    i.e. the dependent Cffus/CompletableFutures are created using async methods.
      * </ul> In these cases, using this unsafe method avoids an unnecessary thread switching when timeout occurs; However,
      * these conditions are difficult to guarantee in practice, especially when the returned Cffu is used by others' codes.
      *
@@ -1616,8 +1616,8 @@ public final <U> Cffu<U> thenComposeAsync(Function<? super T, ? extends Completi
      * is composed using the results of the supplied function applied to the exception from this Cffu.
      * <p>
      * <strong>"The exception from this Cffu"</strong> means the cause of the {@link ExecutionException}
-     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself;
-     * aka the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
+     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself,
+     * i.e. the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
      *
      * @param exceptionType the exception type that triggers use of {@code fallback}. The exception type is matched
      *                      against the exception from this Cffu. To avoid hiding bugs and other unrecoverable errors,
@@ -1637,8 +1637,8 @@ public final <X extends Throwable> F catchingCompose(
      * the results of the supplied function applied to the exception from this Cffu using {@link #defaultExecutor()}.
      * <p>
      * <strong>"The exception from this Cffu"</strong> means the cause of the {@link ExecutionException}
-     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself;
-     * aka the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
+     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself,
+     * i.e. the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
      *
      * @param exceptionType the exception type that triggers use of {@code fallback}. The exception type is matched
      *                      against the exception from this Cffu. To avoid hiding bugs and other unrecoverable errors,
@@ -1658,8 +1658,8 @@ public final <X extends Throwable> F catchingComposeAsync(
      * the results of the supplied function applied to the exception from this Cffu, using the supplied Executor.
      * <p>
      * <strong>"The exception from this Cffu"</strong> means the cause of the {@link ExecutionException}
-     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself;
-     * aka the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
+     * thrown by {@code get()} or, if {@code get()} throws a different kind of exception, that exception itself,
+     * i.e. the exception is unwrapped by {@link CompletableFutureUtils#unwrapCfException(Throwable)}.
      *
      * @param exceptionType the exception type that triggers use of {@code fallback}. The exception type is matched
      *                      against the exception from this Cffu. To avoid hiding bugs and other unrecoverable errors,
@@ -2471,7 +2471,7 @@ public final boolean isMinimalStage() {
 
     /**
      * Returns the estimated number of CompletableFuture(including Cffu wrapper)
-     * whose completions are awaiting completion of this Cffu(aka its underlying CompletableFuture).
+     * whose completions are awaiting completion of this Cffu, i.e. its underlying CompletableFuture.
      * This method is designed for use in monitoring system state, not for synchronization control.
      *
      * @return the estimated number of dependent CompletableFutures(including Cffu wrapper)
@@ -2580,7 +2580,7 @@ public final String toString() {
     /**
      * Returns a {@link CffuFactory.IterableOps} instance to access the {@link Iterable}-based variants
      * (including {@link Collection}, {@link List}, etc.) of same-named varargs methods from {@link Cffu}.
-     * These methods handle multiple actions and Futures with the same type (aka. homogeneous).
+     * These methods handle multiple actions and Futures with the same type, i.e. homogeneous.
      *
      * @see CfIterableUtils
      */
@@ -2602,7 +2602,7 @@ public final TupleOps tupleOps() {
     /**
      * The {@link Iterable}-based variants (including {@link Collection}, {@link List}, etc.) of
      * same-named varargs methods from {@link Cffu}.
-     * These methods handle multiple actions and Futures with the same type (aka. homogeneous).
+     * These methods handle multiple actions and Futures with the same type, i.e. homogeneous.
      */
     public final class IterableOps {
         ////////////////////////////////////////////////////////////

cffu-core/src/main/java/io/foldright/cffu2/CfIterableUtils.java

@@ -21,10 +21,10 @@
 /**
  * This utility class provides {@link Iterable}-based variants (including {@link Collection}, {@link List}, etc.) of
  * same-named varargs methods from {@link CompletableFutureUtils}. These methods handle multiple actions
- * and CompletableFutures with the same type (aka. homogeneous).
+ * and CompletableFutures with the same type, i.e. homogeneous.
  * <p>
  * While {@link CfTupleUtils} uses strongly typed tuples for handling different types of actions and
- * CompletableFutures (aka. heterogeneous), this class and {@link CompletableFutureUtils} work with homogeneous types,
+ * CompletableFutures, i.e. heterogeneous, this class and {@link CompletableFutureUtils} work with homogeneous types,
  * offering a flexible approach for handling collections of actions and CompletableFutures of the same type.
  *
  * @author Eric Lin (linqinghua4 at gmail dot com)

cffu-core/src/main/java/io/foldright/cffu2/CffuFactory.java

@@ -464,7 +464,7 @@ public final <T> MCffu<T, List<T>> allSuccessResultsOf(
 
     /**
      * Returns a new Cffu that is completed normally with a list containing the successful results of
-     * the given stages before the given timeout (aka as many results as possible in the given time);
+     * the given stages before the given timeout, i.e. as many results as possible in the given time;
      * The list of results is in the <strong>same order</strong> as the input list, and if any of given stages
      * complete exceptionally or are incomplete, their corresponding positions will contain {@code valueIfNotSuccess}
      * (which is indistinguishable from the stage having a successful value of {@code valueIfNotSuccess}).
@@ -937,7 +937,7 @@ public boolean forbidObtrudeMethods() {
     /**
      * Returns a {@link IterableOps} instance to access the {@link Iterable}-based variants
      * (including {@link Collection}, {@link List}, etc.) of same-named varargs methods from {@link CffuFactory}.
-     * These methods handle multiple actions and Futures with the same type (aka. homogeneous).
+     * These methods handle multiple actions and Futures with the same type, aka. homogeneous.
      *
      * @see BaseCffu#iterableOps()
      * @see CfIterableUtils
@@ -970,7 +970,7 @@ public TupleOps tupleOps() {
     /**
      * The {@link Iterable}-based variants (including {@link Collection}, {@link List}, etc.) of
      * same-named varargs methods from {@link CffuFactory}.
-     * These methods handle multiple actions and Futures with the same type (aka. homogeneous).
+     * These methods handle multiple actions and Futures with the same type, aka. homogeneous.
      */
     public final class IterableOps {
         ////////////////////////////////////////////////////////////