Minor changes to the visibility of internal methods & doc fixes

Author: vsilaev

src/main/java/net/tascalate/concurrent/AsyncCloseable.java

@@ -19,15 +19,15 @@
 import java.util.function.Function;
 
 /**
- * An object that may hold resources that must be explicitly released, where the release may be
- * performed asynchronously.
+ * An object that may hold resources that must be explicitly released, and the release operation 
+ * should be performed asynchronously.
  *
  * <p>
- * Examples of such resources are manually managed memory, open file handles, socket descriptors
+ * Examples of such resources are database connections, open file handles, socket descriptors
  * etc. While similar to {@link AutoCloseable}, this interface should be used when the resource
- * release operation may possibly be async. For example, if an object is thread-safe and has many
- * consumers, an implementation may require all current ongoing operations to complete before
- * resources are relinquished. 
+ * release operation may possibly be asynchronous. For example, if an object is thread-safe and 
+ * has many consumers, an implementation may require all current ongoing operations to complete 
+ * before resources are relinquished. 
  *
  * <p>
  * May be used with the methods {@link Promises#tryApplyEx(CompletionStage, Function)},
@@ -38,10 +38,10 @@
 @FunctionalInterface
 public interface AsyncCloseable {
   /**
-   * Relinquishes any resources associated with this object.
+   * Release any resources associated with this object.
    *
    * @return a {@link CompletionStage} that completes when all resources associated with this object
-   *         have been released, or with an exception if the resources cannot be released.
+   *         have been released, or settled with an exception if the resources cannot be released.
    */
   CompletionStage<Void> close();
 }

src/main/java/net/tascalate/concurrent/CompletablePromise.java

@@ -59,7 +59,7 @@ public Promise<T> completeAsync(Supplier<? extends T> supplier) {
             return result; // use what is provided
         } else {
             // defaultExecutor might be changed in ad-hoc manner via subclassing
-            // let take back to the actual default executor
+            // let us take back to the actual default executor
             return result.dependent()
                          .thenApplyAsync(Function.identity()) 
                          .unwrap();

src/main/java/net/tascalate/concurrent/DependentPromise.java

@@ -48,17 +48,17 @@
  * <p>In the example <code>p2</code> is created with specifying <code>p1</code> as origin (last argument is <code>true</code>).
  * Now when canceling <code>p2</code> both <code>p2</code> and <code>p1</code> will be cancelled if not completed yet. 
  * 
- * <p>The class add overloads to all composition methods declared in {@link CompletionStage} interface.
+ * <p>The class add overloads to all composition methods declared in {@link CompletionStage} and {@link Promise} interface.
  * 
  * <p>The ones that accepts another {@link CompletionStage} as argument (named <code>*Both*</code> and
  * <code>*Either*</code> are overloaded with a set of @{link {@link PromiseOrigin} as an argument to let
  * you specify what to enlist as origin: "this" related to the method call or the parameter.
  * 
- * <p>Rest of methods from  {@link CompletionStage} API are overloaded with boolean argument 
+ * <p>Rest of methods from {@link CompletionStage} and {@link Promise} API are overloaded with boolean argument 
  * <code>enlistOrigin</code> that specify whether or not the {@link Promise} object whose
  * method is invoked should be added as an origin to result.
  * 
- * <p>All methods originally  specified in {@link CompletionStage} does not add "this" as an origin to
+ * <p>All methods originally specified in {@link CompletionStage} does not add "this" as an origin to
  * resulting promise.
  * 
  * @author vsilaev

src/main/java/net/tascalate/concurrent/Promise.java

@@ -175,7 +175,7 @@ default Promise<T> onTimeout(Supplier<? extends T> supplier, Duration duration,
      * created DependentPromise
      */
     default DependentPromise<T> dependent() {
-    	return DependentPromise.from(this);
+    	return ConfigurableDependentPromise.from(this);
     }
 
     /**
@@ -190,7 +190,7 @@ default DependentPromise<T> dependent() {
      * created DependentPromise
      */
     default DependentPromise<T> dependent(Set<PromiseOrigin> defaultEnlistOptions) {
-        return DependentPromise.from(this, defaultEnlistOptions);
+        return ConfigurableDependentPromise.from(this, defaultEnlistOptions);
     }
 
     default Promise<T> defaultAsyncOn(Executor executor) {

src/main/java/net/tascalate/concurrent/core/CurrentCompletionStageAPI.java

@@ -15,9 +15,11 @@
  */
 package net.tascalate.concurrent.core;
 
-class CurrentCompletionStageAPI {
+final class CurrentCompletionStageAPI {
     static final CompletionStageAPI INSTANCE;
 
+    private CurrentCompletionStageAPI() {}
+    
     private static int getJavaVersion() {
         String version = System.getProperty("java.version");
 

src/main/java/net/tascalate/concurrent/core/J12CompletionStageAPI.java

@@ -20,7 +20,10 @@
 import java.util.concurrent.Executor;
 import java.util.function.Function;
 
-public class J12CompletionStageAPI implements CompletionStageAPI {
+class J12CompletionStageAPI implements CompletionStageAPI {
+    
+    J12CompletionStageAPI() {}
+    
     @Override
     public boolean defaultExecutorOverridable() {
         return true;

src/main/java/net/tascalate/concurrent/core/J8CompletionStageAPI.java

@@ -21,7 +21,9 @@
 import java.util.concurrent.ForkJoinPool;
 import java.util.function.Function;
 
-public class J8CompletionStageAPI implements CompletionStageAPI {
+class J8CompletionStageAPI implements CompletionStageAPI {
+    
+    J8CompletionStageAPI() {}
 
     @Override
     public boolean defaultExecutorOverridable() {

src/main/java/net/tascalate/concurrent/core/J9CompletionStageAPI.java

@@ -20,6 +20,8 @@
 
 class J9CompletionStageAPI extends J8CompletionStageAPI {
 
+    J9CompletionStageAPI() {}
+    
     @Override
     public boolean defaultExecutorOverridable() {
         return true;