removed "the other parameter order"

solita · Feb 25, 2015 · c1f9a24 · c1f9a24
1 parent 81b5351
commit c1f9a24
Show file tree

Hide file tree

Showing 25 changed files with 304 additions and 387 deletions.
diff --git a/pom.xml b/pom.xml
@@ -2,7 +2,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>fi.solita.utils</groupId>
     <artifactId>functional-utils</artifactId>
-    <version>0.8</version>
+    <version>0.9</version>
     <build>
         <resources>
                 <resource>

diff --git a/src/main/java/fi/solita/utils/functional/Builder.java b/src/main/java/fi/solita/utils/functional/Builder.java
@@ -34,13 +34,13 @@ private static <T> Builder<T> newBuilder(Collection<? extends Apply<? super T, ?
     }
 
     public final Builder<T> init(final T t) {
-        Map<Apply<? super T, ? extends Object>, Object> newValues = newMap(map(members, new Transformer<Apply<? super T,? extends Object>, Pair<Apply<? super T,? extends Object>,Object>>() {
+        Map<Apply<? super T, ? extends Object>, Object> newValues = newMap(map(new Transformer<Apply<? super T,? extends Object>, Pair<Apply<? super T,? extends Object>,Object>>() {
             @SuppressWarnings("unchecked")
             @Override
             public Pair<Apply<? super T,? extends Object>,Object> transform(Apply<? super T,? extends Object> source) {
                 return (Pair<Apply<? super T,? extends Object>,Object>)(Object)Pair.of(source, source.apply(t));
             }
-        }));
+        }, members));
         return new Builder<T>(newValues, members, constructor);
     }
 
@@ -61,7 +61,7 @@ private void checkMember(final Apply<T, ?> member) {
     }
 
     public final T build() throws IncompleteException {
-        return constructor.apply(Tuple.of(newArray(Object.class, map(members, new Transformer<Apply<? super T,? extends Object>,Object>() {
+        return constructor.apply(Tuple.of(newArray(Object.class, map(new Transformer<Apply<? super T,? extends Object>,Object>() {
             @Override
             public Object transform(Apply<? super T, ? extends Object> member) {
                 if (values.containsKey(member)) {
@@ -84,7 +84,7 @@ public Object transform(Apply<? super T, ? extends Object> member) {
                 }
                 throw new IncompleteException(member);
             }
-        }))));
+        }, members))));
     }
 
     public static <T,F1> Builder<T> of(Tuple1<? extends Apply<? super T,F1>> members, Apply<F1,T> constructor) {

diff --git a/src/main/java/fi/solita/utils/functional/Function2.java b/src/main/java/fi/solita/utils/functional/Function2.java
@@ -1,9 +1,11 @@
 package fi.solita.utils.functional;
 
+import java.util.Map;
+
 import fi.solita.utils.functional.Function.GivenEvenLater;
 import fi.solita.utils.functional.Function.GivenLater;
 
-public abstract class Function2<T1, T2, R> extends MultiParamFunction<Tuple2<T1,T2>, R> {
+public abstract class Function2<T1, T2, R> extends MultiParamFunction<Map.Entry<T1,T2>, R> {
 
     public abstract R apply(T1 t1, T2 t2);
 
@@ -18,11 +20,11 @@ public U apply(T1 t1, T2 t2) {
     }
 
     @Override
-    public final Function1<Tuple2<T1, T2>, R> tuppled() {
-        return new Function1<Tuple2<T1, T2>, R>() {
+    public final Function1<Map.Entry<T1, T2>, R> tuppled() {
+        return new Function1<Map.Entry<T1, T2>, R>() {
             @Override
-            public R apply(Tuple2<T1, T2> t) {
-                return Function2.this.apply(t._1, t._2);
+            public R apply(Map.Entry<T1, T2> t) {
+                return Function2.this.apply(t.getKey(), t.getValue());
             }
         };
     }

diff --git a/src/main/java/fi/solita/utils/functional/Functional.java b/src/main/java/fi/solita/utils/functional/Functional.java
@@ -5,6 +5,7 @@
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Map;
 
 import fi.solita.utils.functional.Iterables.RepeatingIterable;
 import fi.solita.utils.functional.Iterables.ZippingIterable;
@@ -16,27 +17,27 @@ public static final <T> Iterable<T> subtract(Iterable<? extends T> a, final Coll
     }
 
     public static final <T> Option<T> find(Apply<? super T, Boolean> predicate, Iterable<T> xs) {
-        return FunctionalImpl.find(xs, predicate);
+        return FunctionalImpl.find(predicate, xs);
     }
 
     public static final <T> Iterable<T> filter(Apply<? super T, Boolean> predicate, Iterable<T> xs) {
-        return FunctionalImpl.filter(xs, predicate);
+        return FunctionalImpl.filter(predicate, xs);
     }
 
     public static final <S, T> Iterable<T> map(Apply<? super S, ? extends T> f, Iterable<S> xs) {
-        return FunctionalImpl.map(xs, f);
+        return FunctionalImpl.map(f, xs);
     }
 
     public static final <S, T1, T2> Iterable<Pair<T1,T2>> map(Apply<? super S, T1> f1, Apply<? super S, T2> f2, Iterable<S> xs) {
-        return FunctionalImpl.map(xs, f1, f2);
+        return FunctionalImpl.map(f1, f2, xs);
     }
 
     public static final <S, T1, T2, T3> Iterable<Tuple3<T1,T2,T3>> map(Apply<? super S, T1> f1, Apply<? super S, T2> f2, Apply<? super S, T3> f3, Iterable<S> xs) {
-        return FunctionalImpl.map(xs, f1, f2, f3);
+        return FunctionalImpl.map(f1, f2, f3, xs);
     }
 
     public static final <S, T1, T2, T3, T4> Iterable<Tuple4<T1,T2,T3,T4>> map(Apply<? super S, T1> f1, Apply<? super S, T2> f2, Apply<? super S, T3> f3, Apply<? super S, T4> f4, Iterable<S> xs) {
-        return FunctionalImpl.map(xs, f1, f2, f3, f4);
+        return FunctionalImpl.map(f1, f2, f3, f4, xs);
     }
 
     public static final <F, A, B, FA extends F, FB extends F> FB fmap(Functor<F, A, B, FA, FB> functor, Apply<A,B> f, FA xs) {
@@ -56,31 +57,31 @@ public static final <F, C, D, FAC extends F, FAD extends F> FAD second(BiFunctor
     }
 
     public static final <S, T> Iterable<T> flatMap(Apply<? super S, ? extends Iterable<? extends T>> f, Iterable<S> xs) {
-        return FunctionalImpl.flatMap(xs, f);
+        return FunctionalImpl.flatMap(f, xs);
     }
 
     public static final <T> Iterable<T> flatten(Iterable<? extends Iterable<? extends T>> xs) {
         return FunctionalImpl.flatten(xs);
     }
 
     public static final <T> void foreach(Apply<? super T, Void> procedure, Iterable<T> xs) {
-        FunctionalImpl.foreach(xs, procedure);
+        FunctionalImpl.foreach(procedure, xs);
     }
 
     public static final <T> void foreach(ApplyVoid<? super T> procedure, Iterable<T> xs) {
-        FunctionalImpl.foreach(xs, procedure);
+        FunctionalImpl.foreach(procedure, xs);
     }
 
     public static final <T> Iterable<List<T>> grouped(long groupSize, Iterable<T> xs) {
-        return FunctionalImpl.grouped(xs, groupSize);
+        return FunctionalImpl.grouped(groupSize, xs);
     }
 
     public static final <T> Iterable<Iterable<T>> group(Iterable<T> xs) {
         return FunctionalImpl.group(xs);
     }
 
     public static final <T> Iterable<Iterable<T>> group(Apply<Tuple2<T,T>, Boolean> comparator, Iterable<T> xs) {
-        return FunctionalImpl.group(xs, comparator);
+        return FunctionalImpl.group(comparator, xs);
     }
 
     public static final <T> T head(Iterable<T> xs) {
@@ -116,15 +117,15 @@ public static final <T> Iterable<T> drop(long amount, Iterable<T> xs) {
     }
 
     public static final <T> Iterable<T> takeWhile(Apply<? super T, Boolean> predicate, Iterable<T> xs) {
-        return FunctionalImpl.takeWhile(xs, predicate);
+        return FunctionalImpl.takeWhile(predicate, xs);
     }
 
     public static final <T> Iterable<T> dropWhile(Apply<? super T, Boolean> predicate, Iterable<T> xs) {
-        return FunctionalImpl.dropWhile(xs, predicate);
+        return FunctionalImpl.dropWhile(predicate, xs);
     }
 
     public static final <T> Pair<Iterable<T>, Iterable<T>> span(Apply<? super T, Boolean> predicate, Iterable<T> xs) {
-        return FunctionalImpl.span(xs, predicate);
+        return FunctionalImpl.span(predicate, xs);
     }
 
     public static final boolean isEmpty(Iterable<?> xs) {
@@ -136,15 +137,15 @@ public static final long size(Iterable<?> xs) {
     }
 
     public static final <T> boolean contains(T candidate, Iterable<T> xs) {
-        return FunctionalImpl.exists(xs, Predicates.equalTo(candidate));
+        return FunctionalImpl.exists(Predicates.equalTo(candidate), xs);
     }
 
     public static final <T> boolean exists(Apply<? super T, Boolean> predicate, Iterable<T> xs) {
-        return FunctionalImpl.exists(xs, predicate);
+        return FunctionalImpl.exists(predicate, xs);
     }
 
     public static final <T> boolean forall(Apply<? super T, Boolean> predicate, Iterable<T> xs) {
-        return FunctionalImpl.forall(xs, predicate);
+        return FunctionalImpl.forall(predicate, xs);
     }
 
     public static final <T> Iterable<T> cons(T x, Iterable<? extends T> xs) {
@@ -160,23 +161,23 @@ public static final <T extends Comparable<T>> Iterable<T> sort(Iterable<T> xs) {
     }
 
     public static final <T> Iterable<T> sort(Comparator<? super T> comparator, Iterable<T> xs) {
-        return FunctionalImpl.sort(xs, comparator);
+        return FunctionalImpl.sort(comparator, xs);
     }
 
     public static final <T extends SemiGroup<T>> Option<T> reduce(Iterable<? extends T> xs) {
         return FunctionalImpl.reduce(xs);
     }
 
     public static final <T> T reduce(Monoid<T> m, Iterable<? extends T> xs) {
-        return FunctionalImpl.reduce(xs, m);
+        return FunctionalImpl.reduce(m, xs);
     }
 
-    public static final <T,Z> Z fold(Z zero, Apply<Tuple2<Z,T>, Z> f, Iterable<? extends T> xs) {
-        return FunctionalImpl.fold(zero, xs, f);
+    public static final <T,Z> Z fold(Z zero, Apply<Map.Entry<Z,T>, Z> f, Iterable<? extends T> xs) {
+        return FunctionalImpl.fold(zero, f, xs);
     }
 
-    public static final <T> Option<T> fold(Apply<Tuple2<T,T>, T> f, Iterable<? extends T> xs) {
-        return FunctionalImpl.fold(xs, f);
+    public static final <T> Option<T> fold(Apply<Map.Entry<T,T>, T> f, Iterable<? extends T> xs) {
+        return FunctionalImpl.fold(f, xs);
     }
 
     public static <T extends Comparable<T>> Option<T> min(Iterable<T> xs) {
@@ -238,7 +239,7 @@ public static final <T> Iterable<T> distinct(Iterable<T> xs) {
     }
 
     public static final <T,R> Iterable<R> sequence(T value, Iterable<? extends Apply<? super T,? extends R>> fs) {
-        return FunctionalImpl.sequence(fs, value);
+        return FunctionalImpl.sequence(value, fs);
     }
 
     public static final <T> Iterable<Iterable<T>> transpose(Iterable<? extends Iterable<T>> xs) {