Dropping IterableFactory as its benefit was negligible

jnape · jnape · commit 4032f5f546ac · 2014-03-09T20:13:35.000-04:00
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Cycle.java b/src/main/java/com/jnape/palatable/lambda/functions/Cycle.java
@@ -5,7 +5,7 @@
 
 import java.util.Iterator;
 
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
+import static java.util.Arrays.asList;
 
 public final class Cycle<A> extends MonadicFunction<Iterable<A>, Iterable<A>> {
 
@@ -28,6 +28,6 @@ public static <A> Iterable<A> cycle(Iterable<A> as) {
     }
 
     public static <A> Iterable<A> cycle(A... as) {
-        return cycle(iterable(as));
+        return cycle(asList(as));
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/GroupingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/GroupingIterator.java
@@ -4,9 +4,6 @@
 import java.util.Iterator;
 import java.util.List;
 
-import static com.jnape.palatable.lambda.functions.Take.take;
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
-
 public class GroupingIterator<A> extends ImmutableIterator<Iterable<A>> {
     private final Integer     k;
     private final Iterator<A> asIterator;
@@ -24,8 +21,9 @@ public boolean hasNext() {
     @Override
     public Iterable<A> next() {
         List<A> group = new ArrayList<A>();
-        for (A a : take(k, iterable(asIterator)))
-            group.add(a);
+        int i = 0;
+        while (i++ < k && asIterator.hasNext())
+            group.add(asIterator.next());
         return group;
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/staticfactory/IterableFactory.java b/src/main/java/com/jnape/palatable/lambda/staticfactory/IterableFactory.java
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/CartesianProductTest.java b/src/test/java/com/jnape/palatable/lambda/functions/CartesianProductTest.java
@@ -12,7 +12,6 @@
 import testsupport.traits.Laziness;
 
 import static com.jnape.palatable.lambda.functions.CartesianProduct.cartesianProduct;
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
 import static com.jnape.palatable.lambda.tuples.Tuple2.tuple;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
@@ -24,7 +23,7 @@ public class CartesianProductTest {
 
     @TestTraits({Laziness.class, ImmutableIteration.class, EmptyIterableSupport.class, FiniteIteration.class})
     public MonadicFunction<Iterable<Object>, Iterable<Tuple2<Integer, Object>>> createTestSubject() {
-        return cartesianProduct(iterable(1, 2, 3));
+        return cartesianProduct(asList(1, 2, 3));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/FilterTest.java b/src/test/java/com/jnape/palatable/lambda/functions/FilterTest.java
@@ -13,7 +13,7 @@
 
 import static com.jnape.palatable.lambda.builtin.monadic.Always.always;
 import static com.jnape.palatable.lambda.functions.Filter.filter;
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
+import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -34,7 +34,7 @@ public Boolean apply(Integer integer) {
             }
         };
         assertThat(
-                filter(evens, iterable(1, 2, 3, 4, 5, 6)),
+                filter(evens, asList(1, 2, 3, 4, 5, 6)),
                 iterates(2, 4, 6)
         );
     }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/FoldLeftTest.java b/src/test/java/com/jnape/palatable/lambda/functions/FoldLeftTest.java
@@ -9,7 +9,6 @@
 import testsupport.traits.EmptyIterableSupport;
 
 import static com.jnape.palatable.lambda.functions.FoldLeft.foldLeft;
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
 import static java.util.Arrays.asList;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
@@ -25,7 +24,7 @@ public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
             public Iterable<Object> apply(Iterable<Object> objects, Object o) {
                 return objects;
             }
-        }, iterable(new Object()));
+        }, asList(new Object()));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/FoldRightTest.java b/src/test/java/com/jnape/palatable/lambda/functions/FoldRightTest.java
@@ -9,7 +9,6 @@
 import testsupport.traits.EmptyIterableSupport;
 
 import static com.jnape.palatable.lambda.functions.FoldRight.foldRight;
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
 import static java.util.Arrays.asList;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
@@ -25,7 +24,7 @@ public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
             public Iterable<Object> apply(Object o, Iterable<Object> objects) {
                 return objects;
             }
-        }, iterable(new Object()));
+        }, asList(new Object()));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/InGroupsOfTest.java b/src/test/java/com/jnape/palatable/lambda/functions/InGroupsOfTest.java
@@ -11,7 +11,6 @@
 import testsupport.traits.Laziness;
 
 import static com.jnape.palatable.lambda.functions.InGroupsOf.inGroupsOf;
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
@@ -29,13 +28,13 @@ public MonadicFunction<Iterable<Object>, Iterable<Iterable<Object>>> createTestS
     public void evenlyDistributesGroupedElementsOverIterable() {
         Iterable<Integer> oneThroughSix = asList(1, 2, 3, 4, 5, 6);
         Iterable<Iterable<Integer>> groups = inGroupsOf(2, oneThroughSix);
-        assertThat(groups, iterates(iterable(1, 2), iterable(3, 4), iterable(5, 6)));
+        assertThat(groups, iterates(asList(1, 2), asList(3, 4), asList(5, 6)));
     }
 
     @Test
     public void lastGroupIsUnfinishedIfIterableSizeNotEvenlyDivisibleByK() {
         Iterable<Integer> oneThroughFive = asList(1, 2, 3, 4, 5);
         Iterable<Iterable<Integer>> groups = inGroupsOf(2, oneThroughFive);
-        assertThat(groups, iterates(iterable(1, 2), iterable(3, 4), iterable(5)));
+        assertThat(groups, iterates(asList(1, 2), asList(3, 4), asList(5)));
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/MapTest.java b/src/test/java/com/jnape/palatable/lambda/functions/MapTest.java
@@ -12,7 +12,7 @@
 
 import static com.jnape.palatable.lambda.builtin.monadic.Identity.id;
 import static com.jnape.palatable.lambda.functions.Map.map;
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
+import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -33,7 +33,7 @@ public Integer apply(String string) {
             }
         };
         assertThat(
-                map(length, iterable("one", "two", "three")),
+                map(length, asList("one", "two", "three")),
                 iterates(3, 3, 5)
         );
     }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/TakeTest.java b/src/test/java/com/jnape/palatable/lambda/functions/TakeTest.java
@@ -11,7 +11,7 @@
 import testsupport.traits.Laziness;
 
 import static com.jnape.palatable.lambda.functions.Take.take;
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
+import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -25,18 +25,18 @@ public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
 
     @Test
     public void takesElementsUpToLimit() {
-        Iterable<String> names = iterable("Moe", "Larry", "Curly", "Shemp");
+        Iterable<String> names = asList("Moe", "Larry", "Curly", "Shemp");
         assertThat(take(3, names), iterates("Moe", "Larry", "Curly"));
     }
 
     @Test
     public void iteratesEntireIterableIfLessElementsThanLimit() {
-        Iterable<Integer> oneTwoThree = iterable(1, 2, 3);
+        Iterable<Integer> oneTwoThree = asList(1, 2, 3);
         assertThat(take(4, oneTwoThree), iterates(1, 2, 3));
     }
 
     @Test
     public void takesNothingFromEmptyIterable() {
-        assertThat(take(1, iterable()), iterates());
+        assertThat(take(1, asList()), iterates());
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/TakeWhileTest.java b/src/test/java/com/jnape/palatable/lambda/functions/TakeWhileTest.java
@@ -13,7 +13,7 @@
 
 import static com.jnape.palatable.lambda.builtin.monadic.Always.always;
 import static com.jnape.palatable.lambda.functions.TakeWhile.takeWhile;
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
+import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -33,15 +33,15 @@ public Boolean apply(Integer integer) {
                 return integer < 3;
             }
         };
-        Iterable<Integer> numbers = takeWhile(lessThan3, iterable(1, 2, 3, 4, 5));
+        Iterable<Integer> numbers = takeWhile(lessThan3, asList(1, 2, 3, 4, 5));
         assertThat(numbers, iterates(1, 2));
     }
 
     @Test
     public void takesAllElementsIfPredicateNeverFails() {
         String[] requirements = {"fast", "good", "cheap"};
         assertThat(
-                takeWhile(always(true), iterable(requirements)),
+                takeWhile(always(true), asList(requirements)),
                 iterates(requirements)
         );
     }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/ZipTest.java b/src/test/java/com/jnape/palatable/lambda/functions/ZipTest.java
@@ -1,7 +1,6 @@
 package com.jnape.palatable.lambda.functions;
 
 import com.jnape.palatable.lambda.MonadicFunction;
-import com.jnape.palatable.lambda.staticfactory.IterableFactory;
 import com.jnape.palatable.lambda.tuples.Tuple2;
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.runners.Traits;
@@ -11,6 +10,8 @@
 import testsupport.traits.ImmutableIteration;
 import testsupport.traits.Laziness;
 
+import java.util.Arrays;
+
 import static com.jnape.palatable.lambda.functions.Zip.zip;
 import static com.jnape.palatable.lambda.tuples.Tuple2.tuple;
 import static java.util.Arrays.asList;
@@ -22,7 +23,7 @@ public class ZipTest {
 
     @TestTraits({Laziness.class, FiniteIteration.class, ImmutableIteration.class})
     public MonadicFunction<Iterable<Object>, Iterable<Tuple2<Object, Object>>> createTestSubject() {
-        return zip(IterableFactory.<Object>iterable(1, 2, 3));
+        return zip(Arrays.<Object>asList(1, 2, 3));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/ZipWithTest.java b/src/test/java/com/jnape/palatable/lambda/functions/ZipWithTest.java
@@ -13,7 +13,6 @@
 
 import static com.jnape.palatable.lambda.functions.Zip.zip;
 import static com.jnape.palatable.lambda.functions.ZipWith.zipWith;
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
 import static com.jnape.palatable.lambda.tuples.Tuple2.tuple;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
@@ -29,7 +28,7 @@ public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
             public Object apply(Object o, Object o2) {
                 return new Object();
             }
-        }, iterable(1, 2, 3));
+        }, asList(1, 2, 3));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/CyclicIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/CyclicIteratorTest.java
@@ -2,23 +2,23 @@
 
 import org.junit.Test;
 
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
+import static java.util.Arrays.asList;
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
 
 public class CyclicIteratorTest {
 
     @Test
     public void alwaysHasNext() {
-        CyclicIterator<Integer> cyclicIterator = new CyclicIterator<Integer>(iterable(1, 2).iterator());
+        CyclicIterator<Integer> cyclicIterator = new CyclicIterator<Integer>(asList(1, 2).iterator());
         cyclicIterator.next();
         cyclicIterator.next();
         assertThat(cyclicIterator.hasNext(), is(true));
     }
 
     @Test
     public void cyclesThroughElements() {
-        CyclicIterator<String> strings = new CyclicIterator<String>(iterable("bait", "switch").iterator());
+        CyclicIterator<String> strings = new CyclicIterator<String>(asList("bait", "switch").iterator());
         strings.next();
         strings.next();
         assertThat(strings.next(), is("bait"));
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIteratorTest.java
@@ -5,7 +5,7 @@
 
 import java.util.NoSuchElementException;
 
-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;
+import static java.util.Arrays.asList;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
 
@@ -20,14 +20,14 @@ public Boolean apply(String s) {
 
     @Test
     public void hasNextIfPredicateSucceedsForNextElement() {
-        Iterable<String> words = iterable("four", "three", "two", "one");
+        Iterable<String> words = asList("four", "three", "two", "one");
         PredicatedTakingIterator<String> predicatedTakingIterator = new PredicatedTakingIterator<String>(HAS_FOUR_LETTERS, words.iterator());
         assertThat(predicatedTakingIterator.hasNext(), is(true));
     }
 
     @Test
     public void stopsTakingAfterFirstPredicateFailure() {
-        Iterable<String> words = iterable("once", "upon", "a", "time");
+        Iterable<String> words = asList("once", "upon", "a", "time");
         PredicatedTakingIterator<String> predicatedTakingIterator = new PredicatedTakingIterator<String>(HAS_FOUR_LETTERS, words.iterator());
         predicatedTakingIterator.next();
         predicatedTakingIterator.next();
@@ -36,14 +36,14 @@ public void stopsTakingAfterFirstPredicateFailure() {
 
     @Test
     public void doesNotHaveNextIfFirstElementFailsPredicate() {
-        Iterable<String> words = iterable("I", "have", "a", "dream");
+        Iterable<String> words = asList("I", "have", "a", "dream");
         PredicatedTakingIterator<String> predicatedTakingIterator = new PredicatedTakingIterator<String>(HAS_FOUR_LETTERS, words.iterator());
         assertThat(predicatedTakingIterator.hasNext(), is(false));
     }
 
     @Test
     public void doesNotHaveNextIfTakenAllElements() {
-        Iterable<String> words = iterable("four", "four");
+        Iterable<String> words = asList("four", "four");
         PredicatedTakingIterator<String> predicatedTakingIterator = new PredicatedTakingIterator<String>(HAS_FOUR_LETTERS, words.iterator());
         predicatedTakingIterator.next();
         predicatedTakingIterator.next();
@@ -52,14 +52,14 @@ public void doesNotHaveNextIfTakenAllElements() {
 
     @Test(expected = NoSuchElementException.class)
     public void throwsExceptionIfNextAfterFailedPredicate() {
-        Iterable<String> words = iterable("no");
+        Iterable<String> words = asList("no");
         PredicatedTakingIterator<String> predicatedTakingIterator = new PredicatedTakingIterator<String>(HAS_FOUR_LETTERS, words.iterator());
         predicatedTakingIterator.next();
     }
 
     @Test
     public void takesEverythingIfPredicateNeverFails() {
-        Iterable<String> words = iterable("yeah");
+        Iterable<String> words = asList("yeah");
         PredicatedTakingIterator<String> predicatedTakingIterator = new PredicatedTakingIterator<String>(HAS_FOUR_LETTERS, words.iterator());
         assertThat(predicatedTakingIterator.next(), is("yeah"));
         assertThat(predicatedTakingIterator.hasNext(), is(false));
diff --git a/src/test/java/com/jnape/palatable/lambda/staticfactory/IterableFactoryTest.java b/src/test/java/com/jnape/palatable/lambda/staticfactory/IterableFactoryTest.java
diff --git a/src/test/java/testsupport/traits/FiniteIteration.java b/src/test/java/testsupport/traits/FiniteIteration.java
diff --git a/src/test/java/testsupport/traits/InfiniteIteration.java b/src/test/java/testsupport/traits/InfiniteIteration.java

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`import java.util.Iterator;`
`7`	`7`
`8`		`-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;`
	`8`	`+import static java.util.Arrays.asList;`
`9`	`9`
`10`	`10`	`public final class Cycle<A> extends MonadicFunction<Iterable<A>, Iterable<A>> {`
`11`	`11`
`@@ -28,6 +28,6 @@ public static <A> Iterable<A> cycle(Iterable<A> as) {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`public static <A> Iterable<A> cycle(A... as) {`
`31`		`- return cycle(iterable(as));`
	`31`	`+ return cycle(asList(as));`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,6 @@`
`9`	`9`	`import testsupport.traits.EmptyIterableSupport;`
`10`	`10`
`11`	`11`	`import static com.jnape.palatable.lambda.functions.FoldLeft.foldLeft;`
`12`		`-import static com.jnape.palatable.lambda.staticfactory.IterableFactory.iterable;`
`13`	`12`	`import static java.util.Arrays.asList;`
`14`	`13`	`import static org.hamcrest.core.Is.is;`
`15`	`14`	`import static org.junit.Assert.assertThat;`
`@@ -25,7 +24,7 @@ public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {`
`25`	`24`	`public Iterable<Object> apply(Iterable<Object> objects, Object o) {`
`26`	`25`	`return objects;`
`27`	`26`	`}`
`28`		`- }, iterable(new Object()));`
	`27`	`+ }, asList(new Object()));`
`29`	`28`	`}`
`30`	`29`
`31`	`30`	`@Test`