Reverse deforests (to direct iteration if nesting-level % 2 == 1)

jnape · jnape · commit 47eccfe0eeef · 2018-02-24T18:00:32.000-06:00
speeding up other tests
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java
@@ -1,7 +1,7 @@
 package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.lambda.functions.Fn1;
-import com.jnape.palatable.lambda.iteration.ReversingIterator;
+import com.jnape.palatable.lambda.iteration.ReversingIterable;
 
 /**
  * Given an <code>Iterable</code>, return a reversed representation of that <code>Iterable</code>. Note that reversing
@@ -18,7 +18,7 @@ private Reverse() {
 
     @Override
     public Iterable<A> apply(Iterable<A> as) {
-        return () -> new ReversingIterator<>(as.iterator());
+        return new ReversingIterable<>(as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/ReversingIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/ReversingIterable.java
@@ -0,0 +1,24 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.Iterator;
+
+public final class ReversingIterable<A> implements Iterable<A> {
+    private final Iterable<A> as;
+    private final boolean     reverse;
+
+    public ReversingIterable(Iterable<A> as) {
+        boolean reverse = true;
+        while (as instanceof ReversingIterable) {
+            ReversingIterable<A> nested = (ReversingIterable<A>) as;
+            as = nested.as;
+            reverse = !nested.reverse;
+        }
+        this.as = as;
+        this.reverse = reverse;
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        return reverse ? new ReversingIterator<>(as.iterator()) : as.iterator();
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/TailsTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/TailsTest.java
@@ -49,6 +49,6 @@ public void nonEmpty() {
 
     @Test
     public void largeNumberOfElements() {
-        assertEquals(just(emptyList()), last(tails(take(100000, repeat(1)))));
+        assertEquals(just(emptyList()), last(tails(take(10_000, repeat(1)))));
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/ConcatenatingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/ConcatenatingIteratorTest.java
@@ -85,7 +85,7 @@ public void nextPullsFromXsFirstThenFromYs() {
 
     @Test
     public void stackSafety() {
-        Integer stackBlowingNumber = 50000;
+        Integer stackBlowingNumber = 10_000;
         Iterable<Iterable<Integer>> xss = map(Collections::singleton, take(stackBlowingNumber, iterate(x -> x + 1, 1)));
         Iterable<Integer> deeplyNestedConcat = foldRight((xs, ys) -> () -> new ConcatenatingIterator<>(xs, ys),
                                                          (Iterable<Integer>) Collections.<Integer>emptySet(),
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/ConsingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/ConsingIteratorTest.java
@@ -50,7 +50,7 @@ public void doesNotHaveNextIfNoElementsLeft() {
 
     @Test
     public void stackSafety() {
-        Integer stackBlowingNumber = 1000000;
+        Integer stackBlowingNumber = 10_000;
         Iterable<Integer> ints = foldRight((x, acc) -> () -> new ConsingIterator<>(x, acc),
                                            (Iterable<Integer>) Collections.<Integer>emptyList(),
                                            take(stackBlowingNumber, iterate(x -> x + 1, 1)));
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/ReversingIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/ReversingIterableTest.java
@@ -0,0 +1,18 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Reverse.reverse;
+
+@RunWith(Traits.class)
+public class ReversingIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<Integer>, Iterable<Integer>> testSubject() {
+        return reverse();
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,6 @@ public void nonEmpty() {`
`49`	`49`
`50`	`50`	`@Test`
`51`	`51`	`public void largeNumberOfElements() {`
`52`		`- assertEquals(just(emptyList()), last(tails(take(100000, repeat(1)))));`
	`52`	`+ assertEquals(just(emptyList()), last(tails(take(10_000, repeat(1)))));`
`53`	`53`	`}`
`54`	`54`	`}`