Various changes from feedback

- reorder functionIsApplicative
- add assertion
- change type signature
- add timeout for applicativeRepresentsParallelism
- add comments

Author: t-rutten

src/test/java/com/jnape/palatable/lambdakoans/AboutApplicatives.java

@@ -7,7 +7,6 @@
 import com.jnape.palatable.lambda.functions.Fn3;
 import com.jnape.palatable.lambda.functions.builtin.fn3.LiftA2;
 import com.jnape.palatable.lambda.functions.builtin.fn4.LiftA3;
-import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.builtin.Lazy;
 import com.jnape.palatable.lambda.io.IO;
 import com.jnape.palatable.lambda.traversable.LambdaIterable;
@@ -40,6 +39,7 @@ public void applicativesZipEmbeddedValuesWithEmbeddedFunctions() {
 
         assertThat(just(9).zip(just(inc)), equalTo(just(10)));
         assertThat(just(15).zip(just(inc)), equalTo(just(__)));
+        assertThat(just(7).zip(nothing()), equalTo(nothing()));
         // Explicit types help the compiler
         assertThat(Maybe.<Integer>nothing().zip(just(inc)), equalTo(__));
 
@@ -50,7 +50,7 @@ public void applicativesZipEmbeddedValuesWithEmbeddedFunctions() {
 
         // Moving on to LambdaIterables, where "zipping" is more obvious
         LambdaIterable<Integer> oneThroughThree = LambdaIterable.wrap(asList(1, 2, 3));
-        Applicative<Fn1<? super Integer, ? extends Integer>, LambdaIterable<?>> wrappedInc = LambdaIterable.wrap(asList(inc));
+        LambdaIterable<Fn1<? super Integer, ? extends Integer>> wrappedInc = LambdaIterable.wrap(asList(inc));
         assertThat(oneThroughThree.zip(wrappedInc).unwrap(), iterates(2, 3, 4));
 
         Fn1<Integer, Integer> dec = x -> x - 1;
@@ -62,6 +62,30 @@ public void applicativesZipEmbeddedValuesWithEmbeddedFunctions() {
         assertThat(oneThroughThree.zip(allFunctions).unwrap(), iterates(__()));
     }
 
+    @Test
+    public void functionIsApplicative() {
+        Fn1<String, Integer> strLen = String::length;
+        Fn1<String, String> toUpper = String::toUpperCase;
+
+        // Result of unary function calls are passed to mapping function as arguments
+        Fn1<String, Tuple2<Integer, String>> lengthAndUppercase = LiftA2.liftA2(Tuple2::tuple, strLen, toUpper);
+        assertThat(lengthAndUppercase.apply("hello world"), equalTo(tuple(11, "HELLO WORLD")));
+
+        Fn1<Integer, Integer> mod3 = i -> i % 3;
+        Fn1<Integer, Integer> div3 = i -> i / 3;
+
+        Fn1<Integer, String> showDivision = LiftA2.liftA2((divided, remainder) -> String.format("%d * 3 + %d", divided, remainder), div3, mod3);
+        assertThat(showDivision.apply(10), equalTo(__));
+
+
+        Fn1<String, Integer> findStart = s -> s.indexOf('j');
+        Fn1<String, Integer> findEnd = s -> s.indexOf(' ');
+        Fn3<String, Integer, Integer, String> cutString = String::substring;
+
+        Fn1<String, String> transformAndCut = LiftA3.liftA3(cutString, toUpper, findStart, findEnd);
+        assertThat(transformAndCut.apply("hellojava world"), equalTo(__));
+    }
+
     @Test
     public void lazyApplicatives() {
         // Zipping LambdaIterables is lazy because LambdaIterables are lazy
@@ -85,44 +109,21 @@ public void lazyApplicatives() {
         Lazy<Maybe<Fn1<? super Integer, ? extends String>>> lazyGetToString = lazy(() ->
                 expensiveWayToGetMaybeToString.apply(100_000_000));
 
-        // ...then apply it with lazyZip
+        // ...then apply it with lazyZip.
         Maybe<Integer> nothing = nothing();
+        // Note: unlike LambdaIterables, the Maybe inside is not itself lazy
         Lazy<Maybe<String>> lazyNothingToString = nothing.lazyZip(lazyGetToString);
 
         assertThat(lazyNothingToString.value(), equalTo(__));
         assertThat(computed.get(), equalTo(__));
 
-        // zip, however, we've eagerly generated a mapping function
+        // zip, however, eagerly generates a mapping function
         Maybe<String> nothingToString = nothing.zip(expensiveWayToGetMaybeToString.apply(100_000));
         assertThat(nothingToString, equalTo(__));
         assertThat(computed.get(), equalTo(__));
     }
 
-    @Test
-    public void functionIsApplicative() {
-        Fn1<String, Integer> strLen = String::length;
-        Fn1<String, String> toUpper = String::toUpperCase;
-
-        // Result of unary function calls are passed to mapping function as arguments
-        Fn1<String, Tuple2<Integer, String>> lengthAndUppercase = LiftA2.liftA2(Tuple2::tuple, strLen, toUpper);
-        assertThat(lengthAndUppercase.apply("hello world"), equalTo(tuple(11, "HELLO WORLD")));
-
-        Fn1<Integer, Integer> mod3 = i -> i % 3;
-        Fn1<Integer, Integer> div3 = i -> i / 3;
-
-        Fn1<Integer, String> showDivision = LiftA2.liftA2((divided, remainder) -> String.format("%d * 3 + %d", divided, remainder), div3, mod3);
-        assertThat(showDivision.apply(10), equalTo(__));
-
-
-        Fn1<String, Integer> findStart = s -> s.indexOf('j');
-        Fn1<String, Integer> findEnd = s -> s.indexOf(' ');
-        Fn3<String, Integer, Integer, String> cutString = String::substring;
-
-        Fn1<String, String> transformAndCut = LiftA3.liftA3(cutString, toUpper, findStart, findEnd);
-        assertThat(transformAndCut.apply("hellojava world"), equalTo(__));
-    }
-
-    @Test
+    @Test(timeout = 6500)
     public void applicativeRepresentsParallelism() throws ExecutionException, InterruptedException {
         IO<Integer> foo = IO.io(() -> {
             Thread.sleep(2_000);
@@ -149,7 +150,8 @@ public void applicativeRepresentsParallelism() throws ExecutionException, Interr
 
         applicativeInIo
                 .flatMap(result -> IO.io(() -> assertThat(result, equalTo(__))))
-                .unsafePerformAsyncIO(Executors.newFixedThreadPool(2))
+                // How many threads should we use?
+                .unsafePerformAsyncIO(Executors.newFixedThreadPool(__()))
                 .get();
 
         System.out.printf("Multiple thread execution took %d seconds%n", (System.currentTimeMillis() - multipleThreadStart) / 1000);