Minor improvements

src/main/java/dev/yila/functional/Pair.java

@@ -4,7 +4,7 @@
 import java.util.function.BiFunction;
 
 /**
- * Class to store 2 sorted values, also known as couple
+ * Class to store 2 sorted values, also known as couple.
  * @param <L> left
  * @param <R> right
  */

src/main/java/dev/yila/functional/Result.java

@@ -14,7 +14,8 @@
 import java.util.stream.Collectors;
 
 /**
- * Class to store the result value or the failure
+ * Class to store the result value or the failure.
+ * This class is immutable and returns a new instance after any modifying operation.
  * @param <T> Type of result value
  */
 public class Result<T> {

src/main/java/dev/yila/functional/agent/Agent.java

@@ -3,12 +3,15 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
 
+/**
+ * Utility class to create and operate Store classes.
+ */
 public class Agent {
 
     private Agent() {}
 
     /**
-     * Store object and returns reference to get it.
+     * Store value and returns reference to it.
      * @param value to store, immutable if possible
      * @return Id
      */
@@ -21,7 +24,7 @@ public static <T> Store<T> create(T value) {
     }
 
     /**
-     * Store completable future and returns reference to get the result.
+     * Store completable future and returns reference to result.
      * @param completableFuture
      * @return
      * @param <T>
@@ -35,7 +38,7 @@ public static <T> Store<T> create(CompletableFuture<T> completableFuture) {
     }
 
     /**
-     * Get immutable object stored for an store.
+     * Get immutable value stored.
      * @param store
      * @return
      * @param <T>
@@ -45,7 +48,7 @@ public static <T> T get(Store<T> store) {
     }
 
     /**
-     * Change object saved in the store.
+     * Change value saved in the store.
      * @param store
      * @param function
      * @return

src/main/java/dev/yila/functional/agent/Store.java

@@ -3,6 +3,12 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
 
+/**
+ * Store values that can not be updated concurrently.
+ * Creating and update values in the store is done asynchronously.
+ * Only blocks when you get the value stored.
+ * @param <T>
+ */
 public class Store<T> {
 
     private volatile CompletableFuture<T> completableFuture;

src/test/java/dev/yila/functional/agent/AgentTest.java

@@ -8,6 +8,7 @@
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.IntStream;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -90,4 +91,36 @@ void storeAndUpdateImmutable() {
         assertEquals(25, updated.intValue());
         assertNotSame(bigDecimal, updated);
     }
+
+    @Test
+    void notBlockingCreatingStore() {
+        AtomicInteger atomicInteger = new AtomicInteger(0);
+        Agent.create(CompletableFuture.supplyAsync(() -> {
+            try {
+                Thread.sleep(100);
+                atomicInteger.set(1);
+                return "hello";
+            } catch (InterruptedException ie) {
+                throw new RuntimeException(ie);
+            }
+        }));
+
+        assertEquals(0, atomicInteger.get());
+    }
+    @Test
+    void notBlockingUpdatingStore() {
+        Store<String> string = Agent.create("hello");
+        AtomicInteger atomicInteger = new AtomicInteger(0);
+
+        Agent.update(string, (value) -> {
+            try {
+                Thread.sleep(100);
+                atomicInteger.set(1);
+                return value.toUpperCase();
+            } catch (InterruptedException ie) {
+                throw new RuntimeException(ie);
+            }
+        });
+        assertEquals(0, atomicInteger.get());
+    }
 }