diff --git a/pom.xml b/pom.xml index f0cb6ee..b8203a7 100644 --- a/pom.xml +++ b/pom.xml @@ -2,7 +2,7 @@ 4.0.0 fi.solita.utils functional-utils - 0.8 + 0.9 diff --git a/src/main/java/fi/solita/utils/functional/Builder.java b/src/main/java/fi/solita/utils/functional/Builder.java index dbe1f0a..048c3c9 100644 --- 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 Builder newBuilder(Collection init(final T t) { - Map, Object> newValues = newMap(map(members, new Transformer, Pair,Object>>() { + Map, Object> newValues = newMap(map(new Transformer, Pair,Object>>() { @SuppressWarnings("unchecked") @Override public Pair,Object> transform(Apply source) { return (Pair,Object>)(Object)Pair.of(source, source.apply(t)); } - })); + }, members)); return new Builder(newValues, members, constructor); } @@ -61,7 +61,7 @@ private void checkMember(final Apply member) { } public final T build() throws IncompleteException { - return constructor.apply(Tuple.of(newArray(Object.class, map(members, new Transformer,Object>() { + return constructor.apply(Tuple.of(newArray(Object.class, map(new Transformer,Object>() { @Override public Object transform(Apply member) { if (values.containsKey(member)) { @@ -84,7 +84,7 @@ public Object transform(Apply member) { } throw new IncompleteException(member); } - })))); + }, members)))); } public static Builder of(Tuple1> members, Apply constructor) { diff --git a/src/main/java/fi/solita/utils/functional/Function2.java b/src/main/java/fi/solita/utils/functional/Function2.java index a8dce36..39e38be 100644 --- 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 extends MultiParamFunction, R> { +public abstract class Function2 extends MultiParamFunction, R> { public abstract R apply(T1 t1, T2 t2); @@ -18,11 +20,11 @@ public U apply(T1 t1, T2 t2) { } @Override - public final Function1, R> tuppled() { - return new Function1, R>() { + public final Function1, R> tuppled() { + return new Function1, R>() { @Override - public R apply(Tuple2 t) { - return Function2.this.apply(t._1, t._2); + public R apply(Map.Entry 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 index 6799708..7a37cbe 100644 --- 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 Iterable subtract(Iterable a, final Coll } public static final Option find(Apply predicate, Iterable xs) { - return FunctionalImpl.find(xs, predicate); + return FunctionalImpl.find(predicate, xs); } public static final Iterable filter(Apply predicate, Iterable xs) { - return FunctionalImpl.filter(xs, predicate); + return FunctionalImpl.filter(predicate, xs); } public static final Iterable map(Apply f, Iterable xs) { - return FunctionalImpl.map(xs, f); + return FunctionalImpl.map(f, xs); } public static final Iterable> map(Apply f1, Apply f2, Iterable xs) { - return FunctionalImpl.map(xs, f1, f2); + return FunctionalImpl.map(f1, f2, xs); } public static final Iterable> map(Apply f1, Apply f2, Apply f3, Iterable xs) { - return FunctionalImpl.map(xs, f1, f2, f3); + return FunctionalImpl.map(f1, f2, f3, xs); } public static final Iterable> map(Apply f1, Apply f2, Apply f3, Apply f4, Iterable xs) { - return FunctionalImpl.map(xs, f1, f2, f3, f4); + return FunctionalImpl.map(f1, f2, f3, f4, xs); } public static final FB fmap(Functor functor, Apply f, FA xs) { @@ -56,7 +57,7 @@ public static final FAD second(BiFunctor } public static final Iterable flatMap(Apply> f, Iterable xs) { - return FunctionalImpl.flatMap(xs, f); + return FunctionalImpl.flatMap(f, xs); } public static final Iterable flatten(Iterable> xs) { @@ -64,15 +65,15 @@ public static final Iterable flatten(Iterable void foreach(Apply procedure, Iterable xs) { - FunctionalImpl.foreach(xs, procedure); + FunctionalImpl.foreach(procedure, xs); } public static final void foreach(ApplyVoid procedure, Iterable xs) { - FunctionalImpl.foreach(xs, procedure); + FunctionalImpl.foreach(procedure, xs); } public static final Iterable> grouped(long groupSize, Iterable xs) { - return FunctionalImpl.grouped(xs, groupSize); + return FunctionalImpl.grouped(groupSize, xs); } public static final Iterable> group(Iterable xs) { @@ -80,7 +81,7 @@ public static final Iterable> group(Iterable xs) { } public static final Iterable> group(Apply, Boolean> comparator, Iterable xs) { - return FunctionalImpl.group(xs, comparator); + return FunctionalImpl.group(comparator, xs); } public static final T head(Iterable xs) { @@ -116,15 +117,15 @@ public static final Iterable drop(long amount, Iterable xs) { } public static final Iterable takeWhile(Apply predicate, Iterable xs) { - return FunctionalImpl.takeWhile(xs, predicate); + return FunctionalImpl.takeWhile(predicate, xs); } public static final Iterable dropWhile(Apply predicate, Iterable xs) { - return FunctionalImpl.dropWhile(xs, predicate); + return FunctionalImpl.dropWhile(predicate, xs); } public static final Pair, Iterable> span(Apply predicate, Iterable 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 boolean contains(T candidate, Iterable xs) { - return FunctionalImpl.exists(xs, Predicates.equalTo(candidate)); + return FunctionalImpl.exists(Predicates.equalTo(candidate), xs); } public static final boolean exists(Apply predicate, Iterable xs) { - return FunctionalImpl.exists(xs, predicate); + return FunctionalImpl.exists(predicate, xs); } public static final boolean forall(Apply predicate, Iterable xs) { - return FunctionalImpl.forall(xs, predicate); + return FunctionalImpl.forall(predicate, xs); } public static final Iterable cons(T x, Iterable xs) { @@ -160,7 +161,7 @@ public static final > Iterable sort(Iterable xs) { } public static final Iterable sort(Comparator comparator, Iterable xs) { - return FunctionalImpl.sort(xs, comparator); + return FunctionalImpl.sort(comparator, xs); } public static final > Option reduce(Iterable xs) { @@ -168,15 +169,15 @@ public static final > Option reduce(Iterable T reduce(Monoid m, Iterable xs) { - return FunctionalImpl.reduce(xs, m); + return FunctionalImpl.reduce(m, xs); } - public static final Z fold(Z zero, Apply, Z> f, Iterable xs) { - return FunctionalImpl.fold(zero, xs, f); + public static final Z fold(Z zero, Apply, Z> f, Iterable xs) { + return FunctionalImpl.fold(zero, f, xs); } - public static final Option fold(Apply, T> f, Iterable xs) { - return FunctionalImpl.fold(xs, f); + public static final Option fold(Apply, T> f, Iterable xs) { + return FunctionalImpl.fold(f, xs); } public static > Option min(Iterable xs) { @@ -238,7 +239,7 @@ public static final Iterable distinct(Iterable xs) { } public static final Iterable sequence(T value, Iterable> fs) { - return FunctionalImpl.sequence(fs, value); + return FunctionalImpl.sequence(value, fs); } public static final Iterable> transpose(Iterable> xs) { diff --git a/src/main/java/fi/solita/utils/functional/FunctionalA.java b/src/main/java/fi/solita/utils/functional/FunctionalA.java index 40fee9f..1a7b1a9 100644 --- a/src/main/java/fi/solita/utils/functional/FunctionalA.java +++ b/src/main/java/fi/solita/utils/functional/FunctionalA.java @@ -14,177 +14,133 @@ public abstract class FunctionalA extends FunctionalM { public static final Iterable subtract(T[] a, Collection b) { - return subtract(Arrays.asList(a), b); + return FunctionalImpl.subtract(Arrays.asList(a), b); } public static final Iterable subtract(Iterable a, T[] b) { - return subtract(a, newSet(b)); + return FunctionalImpl.subtract(a, newSet(b)); } public static final Iterable subtract(T[] a, T[] b) { - return subtract(Arrays.asList(a), newSet(b)); + return FunctionalImpl.subtract(Arrays.asList(a), newSet(b)); } - public static final Option find(T[] xs, Apply predicate) { - return find(Arrays.asList(xs), predicate); - } - public static final Option find(Apply predicate, T[] xs) { - return find(Arrays.asList(xs), predicate); + return FunctionalImpl.find(predicate, Arrays.asList(xs)); } - public static final Iterable filter(T[] xs, Apply predicate) { - return filter(Arrays.asList(xs), predicate); - } - public static final Iterable filter(Apply predicate, T[] xs) { - return filter(Arrays.asList(xs), predicate); + return FunctionalImpl.filter(predicate, Arrays.asList(xs)); } - public static final Iterable map(S[] xs, Apply f) { - return map(Arrays.asList(xs), f); - } - public static final Iterable map(Apply f, S[] xs) { - return map(Arrays.asList(xs), f); - } - - public static final Iterable> map(S[] xs, Apply f1, Apply f2) { - return map(Arrays.asList(xs), f1, f2); + return FunctionalImpl.map(f, Arrays.asList(xs)); } public static final Iterable> map(Apply f1, Apply f2, S[] elements) { - return map(Arrays.asList(elements), f1, f2); - } - - public static final Iterable> map(S[] xs, Apply f1, Apply f2, Apply f3) { - return map(Arrays.asList(xs), f1, f2, f3); + return FunctionalImpl.map(f1, f2, Arrays.asList(elements)); } public static final Iterable> map(Apply f1, Apply f2, Apply f3, S[] xs) { - return map(Arrays.asList(xs), f1, f2, f3); - } - - public static final Iterable> map(S[] xs, Apply f1, Apply f2, Apply f3, Apply f4) { - return map(Arrays.asList(xs), f1, f2, f3, f4); + return FunctionalImpl.map(f1, f2, f3, Arrays.asList(xs)); } public static final Iterable> map(Apply f1, Apply f2, Apply f3, Apply f4, S[] xs) { - return map(Arrays.asList(xs), f1, f2, f3, f4); + return FunctionalImpl.map(f1, f2, f3, f4, Arrays.asList(xs)); } - public static final Iterable flatMap(S[] xs, Apply> f) { - return flatMap(Arrays.asList(xs), f); - } - public static final Iterable flatMap(Apply> f, S[] xs) { - return flatMap(Arrays.asList(xs), f); + return FunctionalImpl.flatMap(f, Arrays.asList(xs)); } public static final Iterable flatten(T[][] xs) { - return flatten(map(xs, new Transformer>() { + return FunctionalImpl.flatten(map(new Transformer>() { @Override public Iterable transform(T[] source) { return Arrays.asList(source); } - })); + }, xs)); } public static final Iterable flatten(T[] x, T[]... xs) { - return flatten(map(cons(x, xs), new Transformer>() { + return FunctionalImpl.flatten(FunctionalImpl.map(new Transformer>() { @Override public Iterable transform(T[] source) { return Arrays.asList(source); } - })); + }, cons(x, xs))); } @SuppressWarnings("unchecked") public static final Iterable flatten(Iterable x1, Iterable x2) { - return flatten(Arrays.asList(x1, x2)); + return FunctionalImpl.flatten(Arrays.asList(x1, x2)); } @SuppressWarnings("unchecked") public static final Iterable flatten(Iterable x1, Iterable x2, Iterable x3) { - return flatten(Arrays.asList(x1, x2, x3)); + return FunctionalImpl.flatten(Arrays.asList(x1, x2, x3)); } @SuppressWarnings("unchecked") public static final Iterable flatten(Iterable x1, Iterable x2, Iterable x3, Iterable x4) { - return flatten(Arrays.asList(x1, x2, x3, x4)); + return FunctionalImpl.flatten(Arrays.asList(x1, x2, x3, x4)); } @SuppressWarnings("unchecked") public static final Iterable flatten(Iterable x1, Iterable x2, Iterable x3, Iterable x4, Iterable x5) { - return flatten(Arrays.asList(x1, x2, x3, x4, x5)); + return FunctionalImpl.flatten(Arrays.asList(x1, x2, x3, x4, x5)); } @SuppressWarnings("unchecked") public static final Iterable flatten(Iterable x1, Iterable x2, Iterable x3, Iterable x4, Iterable x5, Iterable x6) { - return flatten(Arrays.asList(x1, x2, x3, x4, x5, x6)); + return FunctionalImpl.flatten(Arrays.asList(x1, x2, x3, x4, x5, x6)); } @SuppressWarnings("unchecked") public static final Iterable flatten(Iterable x1, Iterable x2, Iterable x3, Iterable x4, Iterable x5, Iterable x6, Iterable... xs) { - return flatten(concat(Arrays.asList(x1, x2, x3, x4, x5, x6), xs)); + return FunctionalImpl.flatten(concat(Arrays.asList(x1, x2, x3, x4, x5, x6), xs)); } - public static final void foreach(T[] xs, Apply procedure) { - foreach(Arrays.asList(xs), procedure); - } - - public static final void foreach(T[] xs, ApplyVoid procedure) { - foreach(Arrays.asList(xs), procedure); - } - public static final void foreach(Apply procedure, T[] xs) { - foreach(Arrays.asList(xs), procedure); + FunctionalImpl.foreach(procedure, Arrays.asList(xs)); } public static final void foreach(ApplyVoid procedure, T[] xs) { - foreach(Arrays.asList(xs), procedure); + FunctionalImpl.foreach(procedure, Arrays.asList(xs)); } public static final Iterable> grouped(long groupSize, T[] xs) { - return grouped(Arrays.asList(xs), groupSize); + return FunctionalImpl.grouped(groupSize, Arrays.asList(xs)); } public static final Iterable> group(T[] xs) { - return group(Arrays.asList(xs)); - } - - public static final Iterable> group(T[] xs, Apply, Boolean> comparator) { - return group(Arrays.asList(xs), comparator); + return FunctionalImpl.group(Arrays.asList(xs)); } public static final Iterable> group(Apply, Boolean> comparator, T[] xs) { - return group(Arrays.asList(xs), comparator); + return FunctionalImpl.group(comparator, Arrays.asList(xs)); } - public static final Map> groupBy(T[] xs, Apply f) { - return groupBy(Arrays.asList(xs), f); - } - public static final Map> groupBy(Apply f, T[] xs) { - return groupBy(Arrays.asList(xs), f); + return FunctionalImpl.groupBy(f, Arrays.asList(xs)); } @@ -202,7 +158,7 @@ public static final Option headOption(T[] xs) { public static final Iterable tail(T[] xs) { - return tail(Arrays.asList(xs)); + return FunctionalImpl.tail(Arrays.asList(xs)); } @@ -220,7 +176,7 @@ public static final Option lastOption(T[] xs) { public static final Iterable init(T[] xs) { - return init(Arrays.asList(xs)); + return FunctionalImpl.init(Arrays.asList(xs)); } @@ -237,22 +193,14 @@ public static final Iterable drop(long amount, T[] xs) { - public static final Iterable takeWhile(T[] xs, Apply predicate) { - return takeWhile(Arrays.asList(xs), predicate); - } - public static final Iterable takeWhile(Apply predicate, T[] xs) { - return takeWhile(Arrays.asList(xs), predicate); + return FunctionalImpl.takeWhile(predicate, Arrays.asList(xs)); } - public static final Iterable dropWhile(T[] xs, Apply predicate) { - return dropWhile(Arrays.asList(xs), predicate); - } - public static final Iterable dropWhile(Apply predicate, T[] xs) { - return dropWhile(Arrays.asList(xs), predicate); + return FunctionalImpl.dropWhile(predicate, Arrays.asList(xs)); } @@ -270,27 +218,19 @@ public static final int size(T[] xs) { public static final boolean contains(T candidate, T[] xs) { - return FunctionalImpl.exists(Arrays.asList(xs), Predicates.equalTo(candidate)); + return FunctionalImpl.exists(Predicates.equalTo(candidate), Arrays.asList(xs)); } - public static final boolean exists(T[] xs, Apply predicate) { - return exists(Arrays.asList(xs), predicate); - } - public static final boolean exists(Apply predicate, T[] xs) { - return exists(Arrays.asList(xs), predicate); + return FunctionalImpl.exists(predicate, Arrays.asList(xs)); } - public static final boolean forall(T[] xs, Apply predicate) { - return forall(Arrays.asList(xs), predicate); - } - public static final boolean forall(Apply predicate, T[] xs) { - return forall(Arrays.asList(xs), predicate); + return FunctionalImpl.forall(predicate, Arrays.asList(xs)); } @@ -303,15 +243,15 @@ public static final Iterable cons(T x, T[] xs) { public static final Iterable concat(T[] a, Iterable b) { - return concat(Arrays.asList(a), b); + return FunctionalImpl.concat(Arrays.asList(a), b); } public static final Iterable concat(Iterable a, T[] b) { - return concat(a, Arrays.asList(b)); + return FunctionalImpl.concat(a, Arrays.asList(b)); } public static final Iterable concat(T[] a, T[] b) { - return concat(Arrays.asList(a), Arrays.asList(b)); + return FunctionalImpl.concat(Arrays.asList(a), Arrays.asList(b)); } @SuppressWarnings("unchecked") @@ -342,190 +282,170 @@ public static final Iterable concat(Iterable x1, Iterable> Iterable sort(T[] xs) { - return sort(Arrays.asList(xs)); + return FunctionalImpl.sort(Arrays.asList(xs)); } - public static final Iterable sort(T[] xs, Comparator comparator) { - return sort(Arrays.asList(xs), comparator); - } - public static final Iterable sort(Comparator comparator, T[] xs) { - return sort(Arrays.asList(xs), comparator); + return FunctionalImpl.sort(comparator, Arrays.asList(xs)); } @SuppressWarnings("unchecked") public static final > T reduce(T x1, T x2) { - return reduce(Arrays.asList(x1, x2)).get(); + return FunctionalImpl.reduce(Arrays.asList(x1, x2)).get(); } @SuppressWarnings("unchecked") public static final > T reduce(T x1, T x2, T x3) { - return reduce(Arrays.asList(x1, x2, x3)).get(); + return FunctionalImpl.reduce(Arrays.asList(x1, x2, x3)).get(); } @SuppressWarnings("unchecked") public static final > T reduce(T x1, T x2, T x3, T x4) { - return reduce(Arrays.asList(x1, x2, x3, x4)).get(); + return FunctionalImpl.reduce(Arrays.asList(x1, x2, x3, x4)).get(); } @SuppressWarnings("unchecked") public static final > T reduce(T x1, T x2, T x3, T x4, T x5) { - return reduce(Arrays.asList(x1, x2, x3, x4, x5)).get(); + return FunctionalImpl.reduce(Arrays.asList(x1, x2, x3, x4, x5)).get(); } @SuppressWarnings("unchecked") public static final > T reduce(T x1, T x2, T x3, T x4, T x5, T x6) { - return reduce(Arrays.asList(x1, x2, x3, x4, x5, x6)).get(); + return FunctionalImpl.reduce(Arrays.asList(x1, x2, x3, x4, x5, x6)).get(); } @SuppressWarnings("unchecked") public static final > T reduce(T x1, T x2, T x3, T x4, T x5, T x6, T... xs) { - return reduce(concat(Arrays.asList(x1, x2, x3, x4, x5, x6), xs)).get(); + return FunctionalImpl.reduce(concat(Arrays.asList(x1, x2, x3, x4, x5, x6), xs)).get(); } public static final > Option reduce(T[] xs) { - return reduce(Arrays.asList(xs)); - } - - public static final T reduce(T[] xs, Monoid m) { - return reduce(Arrays.asList(xs), m); + return FunctionalImpl.reduce(Arrays.asList(xs)); } public static final T reduce(Monoid m, T[] xs) { - return reduce(Arrays.asList(xs), m); + return FunctionalImpl.reduce(m, Arrays.asList(xs)); } - public static final Z fold(Z zero, T[] xs, Apply, Z> f) { - return fold(zero, Arrays.asList(xs), f); - } - - public static final Z fold(Z zero, Apply, Z> f, T[] xs) { - return fold(zero, Arrays.asList(xs), f); + public static final Z fold(Z zero, Apply, Z> f, T[] xs) { + return FunctionalImpl.fold(zero, f, Arrays.asList(xs)); } /** * @return None if elements is empty */ - public static final Option fold(T[] xs, Apply, T> f) { - return fold(Arrays.asList(xs), f); - } - - public static final Option fold(Apply, T> f, T[] xs) { - return fold(Arrays.asList(xs), f); + public static final Option fold(Apply, T> f, T[] xs) { + return FunctionalImpl.fold(f, Arrays.asList(xs)); } public static final > T min(T x, T... xs) { - return min(cons(x, xs)).get(); + return FunctionalImpl.min(cons(x, xs)).get(); } public static final > Option min(T[] xs) { - return min(Arrays.asList(xs)); + return FunctionalImpl.min(Arrays.asList(xs)); } public static final > T max(T x, T... xs) { - return max(cons(x, xs)).get(); + return FunctionalImpl.max(cons(x, xs)).get(); } public static final > Option max(T[] xs) { - return max(Arrays.asList(xs)); + return FunctionalImpl.max(Arrays.asList(xs)); } public static final Iterable> zip(A[] a, B[] b) { - return zip(Arrays.asList(a), Arrays.asList(b)); + return FunctionalImpl.zip(Arrays.asList(a), Arrays.asList(b)); } public static final Iterable> zip(A[] a, Iterable b) { - return zip(Arrays.asList(a), b); + return FunctionalImpl.zip(Arrays.asList(a), b); } public static final Iterable> zip(Iterable a, B[] b) { - return zip(a, Arrays.asList(b)); + return FunctionalImpl.zip(a, Arrays.asList(b)); } public static final Iterable> zip(A[] a, B[] b, C[] c) { - return zip(Arrays.asList(a), Arrays.asList(b), Arrays.asList(c)); + return FunctionalImpl.zip(Arrays.asList(a), Arrays.asList(b), Arrays.asList(c)); } public static final Iterable> zip(A[] a, Iterable b, Iterable c) { - return zip(Arrays.asList(a), b, c); + return FunctionalImpl.zip(Arrays.asList(a), b, c); } public static final Iterable> zip(Iterable a, B[] b, Iterable c) { - return zip(a, Arrays.asList(b), c); + return FunctionalImpl.zip(a, Arrays.asList(b), c); } public static final Iterable> zip(Iterable a, Iterable b, C[] c) { - return zip(a, b, Arrays.asList(c)); + return FunctionalImpl.zip(a, b, Arrays.asList(c)); } public static final Iterable> zip(A[] a, B[] b, Iterable c) { - return zip(Arrays.asList(a), Arrays.asList(b), c); + return FunctionalImpl.zip(Arrays.asList(a), Arrays.asList(b), c); } public static final Iterable> zip(Iterable a, B[] b, C[] c) { - return zip(a, Arrays.asList(b), Arrays.asList(c)); + return FunctionalImpl.zip(a, Arrays.asList(b), Arrays.asList(c)); } public static final Iterable> zip(A[] a, Iterable b, C[] c) { - return zip(Arrays.asList(a), b, Arrays.asList(c)); + return FunctionalImpl.zip(Arrays.asList(a), b, Arrays.asList(c)); } public static final Iterable> zipWithIndex(A[] a) { - return new ZippingIterable(range(Enumerables.ints, 0), Arrays.asList(a)); + return new ZippingIterable(FunctionalImpl.range(Enumerables.ints, 0), Arrays.asList(a)); } public static final CharSequence mkString(Character[] xs) { - return mkString(Arrays.asList(xs)); + return FunctionalImpl.mkString(Arrays.asList(xs)); } public static final CharSequence mkString(CharSequence delimiter, CharSequence[] xs) { - return mkString(delimiter, Arrays.asList(xs)); + return FunctionalImpl.mkString(delimiter, Arrays.asList(xs)); } public static final Iterable reverse(T[] xs) { - return reverse(Arrays.asList(xs)); + return FunctionalImpl.reverse(Arrays.asList(xs)); } public static Iterable distinct(T[] xs) { - return distinct(Arrays.asList(xs)); + return FunctionalImpl.distinct(Arrays.asList(xs)); } - public static final Iterable sequence(Apply[] fs, T value) { - return sequence(Arrays.asList(fs), value); - } - public static final Iterable sequence(T value, Apply[] fs) { - return sequence(Arrays.asList(fs), value); + return FunctionalImpl.sequence(value, Arrays.asList(fs)); } public static final Iterable> transpose(Iterable[] xs) { - return transpose(Arrays.asList(xs)); + return FunctionalImpl.transpose(Arrays.asList(xs)); } public static final CharSequence unlines(CharSequence[] xs) { - return unlines(Arrays.asList(xs)); + return FunctionalImpl.unlines(Arrays.asList(xs)); } } diff --git a/src/main/java/fi/solita/utils/functional/FunctionalC.java b/src/main/java/fi/solita/utils/functional/FunctionalC.java index 20b022a..b765627 100644 --- a/src/main/java/fi/solita/utils/functional/FunctionalC.java +++ b/src/main/java/fi/solita/utils/functional/FunctionalC.java @@ -6,6 +6,7 @@ import static fi.solita.utils.functional.Option.Some; import java.util.Comparator; +import java.util.Map; import fi.solita.utils.functional.Iterables.RepeatingIterable; import fi.solita.utils.functional.Iterables.ZippingIterable; @@ -39,13 +40,13 @@ public static final String subtract(String a, final String b) { public static final Option find(Apply predicate, CharSequence xs) { - return FunctionalImpl.find(it(xs), predicate); + return FunctionalImpl.find(predicate, it(xs)); } public static final CharSequence filter(Apply predicate, CharSequence xs) { - return it(FunctionalImpl.filter(it(xs), predicate)); + return it(FunctionalImpl.filter(predicate, it(xs))); } public static final String filter(Apply predicate, String xs) { @@ -55,61 +56,61 @@ public static final String filter(Apply predicate, String xs public static final Iterable map(Apply f, CharSequence xs) { - return FunctionalImpl.map(it(xs), f); + return FunctionalImpl.map(f, it(xs)); } public static final Iterable> map(Apply f1, Apply f2, CharSequence xs) { - return FunctionalImpl.map(it(xs), f1, f2); + return FunctionalImpl.map(f1, f2, it(xs)); } public static final Iterable> map(Apply f1, Apply f2, Apply f3, CharSequence xs) { - return FunctionalImpl.map(it(xs), f1, f2, f3); + return FunctionalImpl.map(f1, f2, f3, it(xs)); } public static final Iterable> map(Apply f1, Apply f2, Apply f3, Apply f4, CharSequence xs) { - return FunctionalImpl.map(it(xs), f1, f2, f3, f4); + return FunctionalImpl.map(f1, f2, f3, f4, it(xs)); } public static final Iterable flatMap(Apply> f, CharSequence xs) { - return FunctionalImpl.flatMap(it(xs), f); + return FunctionalImpl.flatMap(f, it(xs)); } public static final void foreach(Apply procedure, CharSequence xs) { - FunctionalImpl.foreach(it(xs), procedure); + FunctionalImpl.foreach(procedure, it(xs)); } public static final void foreach(ApplyVoid procedure, CharSequence xs) { - FunctionalImpl.foreach(it(xs), procedure); + FunctionalImpl.foreach(procedure, it(xs)); } public static final Iterable grouped(long groupSize, CharSequence xs) { - return map(FunctionalImpl.grouped(it(xs), groupSize), iterable2charSeq); + return FunctionalImpl.map(iterable2charSeq, FunctionalImpl.grouped(groupSize, it(xs))); } public static final Iterable grouped(long groupSize, String xs) { - return map(grouped(groupSize, (CharSequence)xs), Transformers.toString); + return FunctionalImpl.map(Transformers.toString, grouped(groupSize, (CharSequence)xs)); } public static final Iterable group(CharSequence xs) { - return map(FunctionalImpl.group(it(xs)), iterable2charSeq); + return FunctionalImpl.map(iterable2charSeq, FunctionalImpl.group(it(xs))); } public static final Iterable group(String xs) { - return map(group((CharSequence)xs), Transformers.toString); + return FunctionalImpl.map(Transformers.toString, group((CharSequence)xs)); } public static final Iterable group(Apply, Boolean> comparator, CharSequence xs) { - return map(FunctionalImpl.group(it(xs), comparator), iterable2charSeq); + return FunctionalImpl.map(iterable2charSeq, FunctionalImpl.group(comparator, it(xs))); } public static final Iterable group(Apply, Boolean> comparator, String xs) { - return map(group(comparator, (CharSequence)xs), Transformers.toString); + return FunctionalImpl.map(Transformers.toString, group(comparator, (CharSequence)xs)); } @@ -183,7 +184,7 @@ public static final String drop(long amount, String xs) { public static final CharSequence takeWhile(Apply predicate, CharSequence xs) { - return it(FunctionalImpl.takeWhile(it(xs), predicate)); + return it(FunctionalImpl.takeWhile(predicate, it(xs))); } public static final String takeWhile(Apply predicate, String xs) { @@ -193,7 +194,7 @@ public static final String takeWhile(Apply predicate, String public static final CharSequence dropWhile(Apply predicate, CharSequence xs) { - return it(FunctionalImpl.dropWhile(it(xs), predicate)); + return it(FunctionalImpl.dropWhile(predicate, it(xs))); } public static final String dropWhile(Apply predicate, String xs) { @@ -231,7 +232,7 @@ public static final long size(CharSequence xs) { } public static final boolean contains(char candidate, CharSequence xs) { - return FunctionalImpl.exists(it(xs), Predicates.equalTo(candidate)); + return FunctionalImpl.exists(Predicates.equalTo(candidate), it(xs)); } public static final boolean contains(char candidate, String xs) { @@ -239,17 +240,17 @@ public static final boolean contains(char candidate, String xs) { } public static final boolean exists(Apply predicate, CharSequence xs) { - return FunctionalImpl.exists(it(xs), predicate); + return FunctionalImpl.exists(predicate, it(xs)); } public static final boolean forall(Apply predicate, CharSequence xs) { - return FunctionalImpl.forall(it(xs), predicate); + return FunctionalImpl.forall(predicate, it(xs)); } public static final CharSequence cons(char x, CharSequence xs) { - return it(cons(x, it(xs))); + return it(FunctionalImpl.cons(x, it(xs))); } public static final String cons(char x, String xs) { @@ -259,7 +260,7 @@ public static final String cons(char x, String xs) { public static final CharSequence concat(CharSequence a, CharSequence b) { - return it(concat(it(a), it(b))); + return it(FunctionalImpl.concat(it(a), it(b))); } public static final String concat(String a, String b) { @@ -277,7 +278,7 @@ public static final String sort(String xs) { } public static final CharSequence sort(Comparator comparator, CharSequence xs) { - return it(FunctionalImpl.sort(it(xs), comparator)); + return it(FunctionalImpl.sort(comparator, it(xs))); } public static final String sort(Comparator comparator, String xs) { @@ -286,12 +287,12 @@ public static final String sort(Comparator comparator, String xs) { - public static final Z fold(Z zero, Apply, Z> f, CharSequence xs) { - return FunctionalImpl.fold(zero, it(xs), f); + public static final Z fold(Z zero, Apply, Z> f, CharSequence xs) { + return FunctionalImpl.fold(zero, f, it(xs)); } - public static final Option fold(Apply, Character> f, CharSequence xs) { - return FunctionalImpl.fold(it(xs), f); + public static final Option fold(Apply, Character> f, CharSequence xs) { + return FunctionalImpl.fold(f, it(xs)); } public static Option min(CharSequence xs) { @@ -334,12 +335,7 @@ public static final String mkString(CharSequence xs) { } public static final String mkString(CharSequence delimiter, CharSequence xs) { - return FunctionalImpl.mkString(delimiter, map(it(xs), new Transformer() { - @Override - public String transform(Character source) { - return source.toString(); - } - })); + return FunctionalImpl.mkString(delimiter, FunctionalImpl.map(Transformers.toString, it(xs))); } @@ -355,7 +351,7 @@ public static final String reverse(String xs) { public static CharSequence distinct(CharSequence xs) { - return filter(new DistinctPredicate(), xs); + return it(FunctionalImpl.distinct(it(xs))); } diff --git a/src/main/java/fi/solita/utils/functional/FunctionalImpl.java b/src/main/java/fi/solita/utils/functional/FunctionalImpl.java index ffe6d0f..10393b0 100644 --- a/src/main/java/fi/solita/utils/functional/FunctionalImpl.java +++ b/src/main/java/fi/solita/utils/functional/FunctionalImpl.java @@ -24,42 +24,42 @@ import fi.solita.utils.functional.Iterables.TransposingIterable; import fi.solita.utils.functional.Iterables.ZippingIterable; -public abstract class FunctionalImpl { +final class FunctionalImpl { /** * Returns a new iterable a - b, i.e. one that contains all elements of a that * don't exist in b. */ @SuppressWarnings("unchecked") - public static Iterable subtract(Iterable a, final Collection b) { - return (Iterable) filter(a, new Predicate() { + static Iterable subtract(Iterable a, final Collection b) { + return (Iterable) filter(new Predicate() { @Override public boolean accept(T object) { return !b.contains(object); } - }); + }, a); } - public static final Option find(Iterable xs, Apply predicate) { - return headOption(filter(xs, predicate)); + static final Option find(Apply predicate, Iterable xs) { + return headOption(filter(predicate, xs)); } - public static final Option find(Map map, K key) { + static final Option find(K key, Map map) { return Option.of(map.get(key)); } - public static final Iterable filter(Iterable xs, Apply predicate) { + static final Iterable filter(Apply predicate, Iterable xs) { return new FilteringIterable(xs, predicate); } - public static final Map filter(Map map, Apply, Boolean> predicate) { - return Collections.newMap(filter(map.entrySet(), predicate)); + static final Map filter(Apply, Boolean> predicate, Map map) { + return Collections.newMap(filter(predicate, map.entrySet())); } - public static final Iterable map(Iterable xs, Apply f) { + static final Iterable map(Apply f, Iterable xs) { return new TransformingIterable(xs, f); } - public static final Iterable> map(Iterable xs, final Apply f1, final Apply f2) { + static final Iterable> map(final Apply f1, final Apply f2, Iterable xs) { return new TransformingIterable>(xs, new Transformer>() { @Override public Pair transform(S source) { @@ -68,7 +68,7 @@ public Pair transform(S source) { }); } - public static final Iterable> map(Iterable xs, final Apply f1, final Apply f2, final Apply f3) { + static final Iterable> map(final Apply f1, final Apply f2, final Apply f3, Iterable xs) { return new TransformingIterable>(xs, new Transformer>() { @Override public Tuple3 transform(S source) { @@ -77,7 +77,7 @@ public Tuple3 transform(S source) { }); } - public static final Iterable> map(Iterable xs, final Apply f1, final Apply f2, final Apply f3, final Apply f4) { + static final Iterable> map(final Apply f1, final Apply f2, final Apply f3, final Apply f4, Iterable xs) { return new TransformingIterable>(xs, new Transformer>() { @Override public Tuple4 transform(S source) { @@ -86,33 +86,33 @@ public Tuple4 transform(S source) { }); } - public static final Map map(Map map, Apply, ? extends Map.Entry> f) { - return Collections.newMap(map(map.entrySet(), f)); + static final Map map(Apply, ? extends Map.Entry> f, Map map) { + return Collections.newMap(map(f, map.entrySet())); } - public static final Iterable flatMap(Iterable xs, Apply> f) { - return flatten(map(xs, f)); + static final Iterable flatMap(Apply> f, Iterable xs) { + return flatten(map(f, xs)); } - public static Iterable flatten(Iterable> xs) { + static Iterable flatten(Iterable> xs) { return new FlatteningIterable(xs); } - public static final void foreach(Iterable xs, Apply procedure) { + static final void foreach(Apply procedure, Iterable xs) { for (T t: xs) { procedure.apply(t); } } @SuppressWarnings("unchecked") - public static final void foreach(Iterable xs, ApplyVoid procedure) { - foreach(xs, (Apply)procedure); + static final void foreach(ApplyVoid procedure, Iterable xs) { + foreach((Apply)procedure, xs); } /** * Non-lazy */ - public static final Iterable> grouped(Iterable xs, long groupSize) { + static final Iterable> grouped(long groupSize, Iterable xs) { if (groupSize <= 0) { throw new IllegalArgumentException("size must be positive"); } @@ -135,8 +135,8 @@ public static final Iterable> grouped(Iterable xs, long groupSize } @SuppressWarnings("unchecked") - public static Iterable> group(Iterable xs) { - return group(xs, (Predicate>)(Object)tuple2elementsEqual); + static Iterable> group(Iterable xs) { + return group((Predicate>)(Object)tuple2elementsEqual, xs); } private static final Predicate> tuple2elementsEqual = new Predicate>() { @@ -146,18 +146,18 @@ public boolean accept(Tuple2 candidate) { } }; - public static final Iterable> group(Iterable xs, Apply, Boolean> comparator) { + static final Iterable> group(Apply, Boolean> comparator, Iterable xs) { return new Iterables.GroupingIterable(xs, comparator); } /** * Non-lazy */ - public static Map> groupBy(Iterable xs, Apply f) { + static Map> groupBy(Apply f, Iterable xs) { Map> target = newMap(); for (T t: xs) { G g = f.apply(t); - Option> groupOption = find(target, g); + Option> groupOption = find(g, target); List group; if (groupOption.isDefined()) { group = groupOption.get(); @@ -170,11 +170,11 @@ public static Map> groupBy(Iterable xs, Apply return target; } - public static T head(Iterable xs) { + static T head(Iterable xs) { return xs.iterator().next(); } - public static Option headOption(Iterable xs) { + static Option headOption(Iterable xs) { Iterator it = xs.iterator(); if (it.hasNext()) { return Some(it.next()); @@ -183,15 +183,15 @@ public static Option headOption(Iterable xs) { } } - public static Iterable tail(Iterable xs) { + static Iterable tail(Iterable xs) { return drop(1, xs); } - public static T last(Iterable xs) { + static T last(Iterable xs) { return lastOption(xs).get(); } - public static Option lastOption(Iterable xs) { + static Option lastOption(Iterable xs) { if (xs instanceof List) { if (((List) xs).isEmpty()) { return None(); @@ -211,19 +211,19 @@ public static Option lastOption(Iterable xs) { } } - public static Iterable init(Iterable xs) { + static Iterable init(Iterable xs) { return take(size(xs)-1, xs); } - public static Iterable take(long amount, Iterable xs) { + static Iterable take(long amount, Iterable xs) { return new Iterables.TakingIterable(xs, amount); } - public static Iterable drop(long amount, Iterable xs) { + static Iterable drop(long amount, Iterable xs) { return new Iterables.DroppingIterable(xs, amount); } - public static final Iterable takeWhile(final Iterable xs, final Apply predicate) { + static final Iterable takeWhile(final Apply predicate, final Iterable xs) { return new Iterable() { public Iterator iterator() { return new Iterator() { @@ -267,7 +267,7 @@ public void remove() { }; } - public static final Iterable dropWhile(final Iterable xs, final Apply predicate) { + static final Iterable dropWhile(final Apply predicate, final Iterable xs) { return new Iterable() { public Iterator iterator() { return new Iterator() { @@ -307,16 +307,16 @@ public void remove() { }; } - public static final Pair, Iterable> span(Iterable xs, Apply predicate) { + static final Pair, Iterable> span(Apply predicate, Iterable xs) { // TODO: a more efficient implementation - return Pair.of(takeWhile(xs, predicate), dropWhile(xs, predicate)); + return Pair.of(takeWhile(predicate, xs), dropWhile(predicate, xs)); } - public static boolean isEmpty(Iterable xs) { + static boolean isEmpty(Iterable xs) { return !xs.iterator().hasNext(); } - public static long size(Iterable xs) { + static long size(Iterable xs) { for (long size: Iterables.resolveSize.apply(xs)) { return size; } @@ -327,37 +327,37 @@ public static long size(Iterable xs) { return s; } - public static final boolean exists(Iterable xs, Apply predicate) { - return !isEmpty(filter(xs, predicate)); + static final boolean exists(Apply predicate, Iterable xs) { + return !isEmpty(filter(predicate, xs)); } - public static final boolean forall(Iterable xs, Apply predicate) { - return !exists(xs, Predicates.not(predicate)); + static final boolean forall(Apply predicate, Iterable xs) { + return !exists(Predicates.not(predicate), xs); } - public static > Iterable sort(Iterable xs) { - return sort(xs, Ordering.Natural()); + static > Iterable sort(Iterable xs) { + return sort(Ordering.Natural(), xs); } - public static final Iterable sort(Iterable xs, Comparator comparator) { + static final Iterable sort(Comparator comparator, Iterable xs) { if (isEmpty(xs)) { return emptyList(); } return new Iterables.SortingIterable(xs, comparator); } - public static > Option reduce(Iterable xs) { + static > Option reduce(Iterable xs) { if (isEmpty(xs)) { return None(); } - return fold(xs, head(xs)); + return fold(head(xs), xs); } - public static final T reduce(Iterable xs, Monoid m) { - return fold(cons(m.zero(), xs), m).get(); + static final T reduce(Monoid m, Iterable xs) { + return fold(m, cons(m.zero(), xs)).get(); } - public static final Z fold(Z zero, Iterable xs, Apply, Z> f) { + static final Z fold(Z zero, Apply, Z> f, Iterable xs) { Z ret = zero; for (T t : xs) { ret = f.apply(Tuple.of(ret, t)); @@ -368,7 +368,7 @@ public static final Z fold(Z zero, Iterable xs, ApplyNone if elements is empty */ - public static final Option fold(Iterable xs, Apply, T> f) { + static final Option fold(Apply, T> f, Iterable xs) { Option h = headOption(xs); if (h.isDefined()) { T ret = h.get(); @@ -380,30 +380,30 @@ public static final Option fold(Iterable xs, Apply xs) { - return reduce(xs, Monoids.longSum); + static long sum(Iterable xs) { + return reduce(Monoids.longSum, xs); } - public static long product(Iterable xs) { - return reduce(xs, Monoids.longProduct); + static long product(Iterable xs) { + return reduce(Monoids.longProduct, xs); } @SuppressWarnings("unchecked") - public static Iterable cons(T x, Iterable xs) { + static Iterable cons(T x, Iterable xs) { return concat(Arrays.asList(x), xs); } @SuppressWarnings("unchecked") - public static Iterable concat(Iterable a, Iterable b) { + static Iterable concat(Iterable a, Iterable b) { return new ConcatenatingIterable(Arrays.asList(a, b)); } @SuppressWarnings("unchecked") - public static > Option min(Iterable xs) { + static > Option min(Iterable xs) { if (isEmpty(xs)) { return None(); } - return Some(fold(head(xs), tail(xs), (Apply,T>)(Object)smaller)); + return Some(fold(head(xs), (Apply,T>)(Object)smaller, tail(xs))); } @SuppressWarnings("rawtypes") @@ -425,20 +425,20 @@ public Comparable apply(Comparable t1, Comparable t2) { }; @SuppressWarnings("unchecked") - public static > Option max(Iterable xs) { + static > Option max(Iterable xs) { if (isEmpty(xs)) { return None(); } - return Some(fold(head(xs), tail(xs), (Apply,T>)(Object)bigger)); + return Some(fold(head(xs), (Apply,T>)(Object)bigger, tail(xs))); } - public static Iterable> zip(Iterable a, Iterable b) { + static Iterable> zip(Iterable a, Iterable b) { return new ZippingIterable(a, b); } @SuppressWarnings("unchecked") - public static Iterable> zip(Iterable a, Iterable b, Iterable c) { - return map(zip(zip(a, b), c), ( Transformer, C>, Tuple3>)(Object)zip3Transformer); + static Iterable> zip(Iterable a, Iterable b, Iterable c) { + return map((Transformer, C>, Tuple3>)(Object)zip3Transformer, zip(zip(a, b), c)); } private static Transformer,Object>,Tuple3> zip3Transformer = new Transformer, Object>, Tuple3>() { @@ -448,15 +448,15 @@ public Tuple3 transform(Tuple2, O } }; - public static Iterable range(Enumerable enumeration, T from) { + static Iterable range(Enumerable enumeration, T from) { return new RangeIterable(enumeration, from, Option.None()); } - public static Iterable range(Enumerable enumeration, T from, T toInclusive) { + static Iterable range(Enumerable enumeration, T from, T toInclusive) { return new RangeIterable(enumeration, from, Some(toInclusive)); } - public static String mkString(Iterable xs) { + static String mkString(Iterable xs) { StringBuilder sb = new StringBuilder(); for (char c: xs) { sb.append(c); @@ -464,7 +464,7 @@ public static String mkString(Iterable xs) { return sb.toString(); } - public static String mkString(CharSequence delimiter, Iterable xs) { + static String mkString(CharSequence delimiter, Iterable xs) { if (isEmpty(xs)) { return ""; } @@ -477,12 +477,12 @@ public static String mkString(CharSequence delimiter, Iterable Iterable reverse(Iterable xs) { + static Iterable reverse(Iterable xs) { return new Iterables.ReversingIterable(xs); } - public static Iterable distinct(Iterable xs) { - return filter(xs, new DistinctPredicate()); + static Iterable distinct(Iterable xs) { + return filter(new DistinctPredicate(), xs); } protected static final class DistinctPredicate extends Predicate { @@ -495,28 +495,28 @@ public boolean accept(T candidate) { } }; - public static final Iterable sequence(Iterable> fs, final T value) { - return map(fs, new Transformer, R>() { + static final Iterable sequence(final T value, Iterable> fs) { + return map(new Transformer, R>() { @Override public R transform(Apply source) { return source.apply(value); } - }); + }, fs); } - public static Iterable> transpose(Iterable> xs) { + static Iterable> transpose(Iterable> xs) { return new TransposingIterable(xs); } - public static CharSequence unlines(Iterable xs) { + static CharSequence unlines(Iterable xs) { Iterable lineSeparators = Functional.repeat(System.getProperty("line.separator")); CharSequence first = head(xs); - Iterable rest = map(zip(lineSeparators, tail(xs)), new Transformer,CharSequence>() { + Iterable rest = map(new Transformer,CharSequence>() { @Override public CharSequence transform(Tuple2 source) { return Functional.concat(source._1, source._2); } - }); - return it(flatten(map(cons(first, rest), FunctionalC.charSeq2iterable))); + }, zip(lineSeparators, tail(xs))); + return it(flatten(map(FunctionalC.charSeq2iterable, cons(first, rest)))); } } \ No newline at end of file diff --git a/src/main/java/fi/solita/utils/functional/FunctionalM.java b/src/main/java/fi/solita/utils/functional/FunctionalM.java index 8365d2c..c68d0bc 100644 --- a/src/main/java/fi/solita/utils/functional/FunctionalM.java +++ b/src/main/java/fi/solita/utils/functional/FunctionalM.java @@ -6,24 +6,24 @@ import java.util.List; import java.util.Map; -public abstract class FunctionalM extends FunctionalImpl { +public abstract class FunctionalM { public static final Option find(K key, Map map) { - return FunctionalImpl.find(map, key); + return FunctionalImpl.find(key, map); } public static final Map filter(Apply, Boolean> predicate, Map map) { - return FunctionalImpl.filter(map, predicate); + return FunctionalImpl.filter(predicate, map); } public static final Map map(Apply, ? extends Map.Entry> f, Map map) { - return FunctionalImpl.map(map, f); + return FunctionalImpl.map(f, map); } public static final Map> groupBy(Apply f, Iterable xs) { - return FunctionalImpl.groupBy(xs, f); + return FunctionalImpl.groupBy(f, xs); } public static final Map with(K key, V value, Map map) { - return newMap(concat(map.entrySet(), newList(Pair.of(key, value)))); + return newMap(FunctionalImpl.concat(map.entrySet(), newList(Pair.of(key, value)))); } } diff --git a/src/main/java/fi/solita/utils/functional/FunctionalS.java b/src/main/java/fi/solita/utils/functional/FunctionalS.java index cf8784b..01d36be 100644 --- a/src/main/java/fi/solita/utils/functional/FunctionalS.java +++ b/src/main/java/fi/solita/utils/functional/FunctionalS.java @@ -38,11 +38,11 @@ public static final long product(long... xs) { } public static final long product(int... xs) { - return product(map(newArray(xs), Transformers.int2long)); + return product(map(Transformers.int2long, newArray(xs))); } public static final long product(short... xs) { - return product(map(newArray(xs), Transformers.short2long)); + return product(map(Transformers.short2long, newArray(xs))); } @@ -81,63 +81,63 @@ public static final Iterable range(long from, long toInclusive) { @SuppressWarnings("unchecked") public static final Set union(Set e1, Set e2) { - return reduce(Arrays.asList(e1, e2), Monoids.setUnion()); + return FunctionalImpl.reduce(Monoids.setUnion(), Arrays.asList(e1, e2)); } @SuppressWarnings("unchecked") public static final Set union(Set e1, Set e2, Set e3) { - return reduce(Arrays.asList(e1, e2, e3), Monoids.setUnion()); + return FunctionalImpl.reduce(Monoids.setUnion(), Arrays.asList(e1, e2, e3)); } @SuppressWarnings("unchecked") public static final Set union(Set e1, Set e2, Set e3, Set e4) { - return reduce(Arrays.asList(e1, e2, e3, e4), Monoids.setUnion()); + return FunctionalImpl.reduce(Monoids.setUnion(), Arrays.asList(e1, e2, e3, e4)); } @SuppressWarnings("unchecked") public static final Set union(Set e1, Set e2, Set e3, Set e4, Set e5) { - return reduce(Arrays.asList(e1, e2, e3, e4, e5), Monoids.setUnion()); + return FunctionalImpl.reduce(Monoids.setUnion(), Arrays.asList(e1, e2, e3, e4, e5)); } @SuppressWarnings("unchecked") public static final Set union(Set e1, Set e2, Set e3, Set e4, Set e5, Set e6) { - return reduce(Arrays.asList(e1, e2, e3, e4, e5, e6), Monoids.setUnion()); + return FunctionalImpl.reduce(Monoids.setUnion(), Arrays.asList(e1, e2, e3, e4, e5, e6)); } @SuppressWarnings("unchecked") public static final Set union(Set e1, Set e2, Set e3, Set e4, Set e5, Set e6, Set... es) { - return reduce(concat(Arrays.asList(e1, e2, e3, e4, e5, e6), Arrays.asList(es)), Monoids.setUnion()); + return FunctionalImpl.reduce(Monoids.setUnion(), FunctionalImpl.concat(Arrays.asList(e1, e2, e3, e4, e5, e6), Arrays.asList(es))); } @SuppressWarnings("unchecked") public static final Set intersection(Set e1, Set e2) { - return reduce(Arrays.asList(e1, e2), Monoids.setIntersection()); + return FunctionalImpl.reduce(Monoids.setIntersection(), Arrays.asList(e1, e2)); } @SuppressWarnings("unchecked") public static final Set intersection(Set e1, Set e2, Set e3) { - return reduce(Arrays.asList(e1, e2, e3), Monoids.setIntersection()); + return FunctionalImpl.reduce(Monoids.setIntersection(), Arrays.asList(e1, e2, e3)); } @SuppressWarnings("unchecked") public static final Set intersection(Set e1, Set e2, Set e3, Set e4) { - return reduce(Arrays.asList(e1, e2, e3, e4), Monoids.setIntersection()); + return FunctionalImpl.reduce(Monoids.setIntersection(), Arrays.asList(e1, e2, e3, e4)); } @SuppressWarnings("unchecked") public static final Set intersection(Set e1, Set e2, Set e3, Set e4, Set e5) { - return reduce(Arrays.asList(e1, e2, e3, e4, e5), Monoids.setIntersection()); + return FunctionalImpl.reduce(Monoids.setIntersection(), Arrays.asList(e1, e2, e3, e4, e5)); } @SuppressWarnings("unchecked") public static final Set intersection(Set e1, Set e2, Set e3, Set e4, Set e5, Set e6) { - return reduce(Arrays.asList(e1, e2, e3, e4, e5, e6), Monoids.setIntersection()); + return FunctionalImpl.reduce(Monoids.setIntersection(), Arrays.asList(e1, e2, e3, e4, e5, e6)); } @SuppressWarnings("unchecked") public static final Set intersection(Set e1, Set e2, Set e3, Set e4, Set e5, Set e6, Set... es) { - return reduce(concat(Arrays.asList(e1, e2, e3, e4, e5, e6), Arrays.asList(es)), Monoids.setIntersection()); + return FunctionalImpl.reduce(Monoids.setIntersection(), FunctionalImpl.concat(Arrays.asList(e1, e2, e3, e4, e5, e6), Arrays.asList(es))); } } diff --git a/src/main/java/fi/solita/utils/functional/Iterables.java b/src/main/java/fi/solita/utils/functional/Iterables.java index a366797..7757d8d 100644 --- a/src/main/java/fi/solita/utils/functional/Iterables.java +++ b/src/main/java/fi/solita/utils/functional/Iterables.java @@ -1,14 +1,14 @@ package fi.solita.utils.functional; import static fi.solita.utils.functional.Collections.newList; +import static fi.solita.utils.functional.Functional.forall; import static fi.solita.utils.functional.Functional.head; import static fi.solita.utils.functional.Functional.isEmpty; +import static fi.solita.utils.functional.Functional.map; +import static fi.solita.utils.functional.Functional.span; import static fi.solita.utils.functional.Functional.take; import static fi.solita.utils.functional.FunctionalA.max; import static fi.solita.utils.functional.FunctionalA.min; -import static fi.solita.utils.functional.FunctionalImpl.forall; -import static fi.solita.utils.functional.FunctionalImpl.map; -import static fi.solita.utils.functional.FunctionalImpl.span; import static fi.solita.utils.functional.Option.None; import static fi.solita.utils.functional.Option.Some; @@ -184,11 +184,11 @@ public TransposingIterable(Iterable> elements) { public Iterator> iterator() { return new Iterator>() { @SuppressWarnings("unchecked") - private final List> iterators = newList(map(elements, (Transformer,Iterator>)(Object)toIterator)); + private final List> iterators = newList(map((Transformer,Iterator>)(Object)toIterator, elements)); public boolean hasNext() { - return !iterators.isEmpty() && forall(iterators, hasNext); + return !iterators.isEmpty() && forall(hasNext, iterators); } @SuppressWarnings("unchecked") @@ -197,7 +197,7 @@ public Iterable next() { if (!hasNext()) { throw new NoSuchElementException(); } - return newList(map(iterators, (Transformer, T>)(Object)next)); + return newList(map((Transformer, T>)(Object)next, iterators)); } @@ -266,7 +266,7 @@ public ConcatenatingIterable(Iterable> elements) public Option sizeEstimate() { long s = 0; - for (Option size: map(elements, resolveSize)) { + for (Option size: map(resolveSize, elements)) { if (size.isDefined()) { s += size.get(); } else { @@ -280,7 +280,7 @@ public Option sizeEstimate() { public Iterator iterator() { return new Iterator() { @SuppressWarnings("unchecked") - private final Iterator> it = Functional.map(elements, (Transformer,Iterator>)(Object)toIterator).iterator(); + private final Iterator> it = Functional.map((Transformer,Iterator>)(Object)toIterator, elements).iterator(); private Iterator lastUsed = it.hasNext() ? it.next() : java.util.Collections.emptyList().iterator(); @@ -762,14 +762,14 @@ public Iterable next() { throw new NoSuchElementException(); } final T first = head(remaining); - Pair, Iterable> span = span(remaining, new Predicate() { + Pair, Iterable> s = span(new Predicate() { public boolean accept(T candidate) { return comparator.apply(Tuple.of(candidate, first)); } - }); - remaining = span.right; - return span.left; + }, remaining); + remaining = s.right; + return s.left; } diff --git a/src/main/java/fi/solita/utils/functional/Lens.java b/src/main/java/fi/solita/utils/functional/Lens.java index 10fd507..16c62b0 100644 --- a/src/main/java/fi/solita/utils/functional/Lens.java +++ b/src/main/java/fi/solita/utils/functional/Lens.java @@ -1,11 +1,13 @@ package fi.solita.utils.functional; +import java.util.Map; + public final class Lens { private final Apply getter; - private final Apply, T> setter; + private final Apply, T> setter; private final Builder builder; - private Lens(Apply getter, Apply, T> setter, Builder builder) { + private Lens(Apply getter, Apply, T> setter, Builder builder) { this.getter = getter; this.setter = setter; this.builder = builder; @@ -39,11 +41,11 @@ public T apply(T tt, O otherValue) { builder); } - private static final Apply,T> setter(final Apply field, final Builder builder) { - return new Apply, T>() { - public T apply(Tuple2 t) { - return builder.init(t._1) - .with(field, t._2) + private static final Apply,T> setter(final Apply field, final Builder builder) { + return new Apply, T>() { + public T apply(Map.Entry t) { + return builder.init(t.getKey()) + .with(field, t.getValue()) .build(); } }; diff --git a/src/main/java/fi/solita/utils/functional/Monoids.java b/src/main/java/fi/solita/utils/functional/Monoids.java index c3309df..5e1c07b 100644 --- a/src/main/java/fi/solita/utils/functional/Monoids.java +++ b/src/main/java/fi/solita/utils/functional/Monoids.java @@ -14,7 +14,7 @@ private Monoids() { public static final Monoid of(final SemiGroup sg, final Function0 zero) { return new Monoid() { - public T apply(Tuple2 t) { + public T apply(Map.Entry t) { return sg.apply(t); } diff --git a/src/main/java/fi/solita/utils/functional/MultiParamFunction.java b/src/main/java/fi/solita/utils/functional/MultiParamFunction.java index b9d5532..cf6997b 100644 --- a/src/main/java/fi/solita/utils/functional/MultiParamFunction.java +++ b/src/main/java/fi/solita/utils/functional/MultiParamFunction.java @@ -2,7 +2,7 @@ import java.io.Serializable; -public abstract class MultiParamFunction implements Apply, Serializable { +public abstract class MultiParamFunction implements Apply, Serializable { public abstract Function1 tuppled(); public final R apply(T t) { diff --git a/src/main/java/fi/solita/utils/functional/Ordering.java b/src/main/java/fi/solita/utils/functional/Ordering.java index ecd6847..c4080b7 100644 --- a/src/main/java/fi/solita/utils/functional/Ordering.java +++ b/src/main/java/fi/solita/utils/functional/Ordering.java @@ -3,6 +3,7 @@ import static fi.solita.utils.functional.Functional.reduce; import java.util.Comparator; +import java.util.Map; public abstract class Ordering implements Comparator, Monoid> { @@ -36,8 +37,8 @@ public final Ordering reverse() { return of(java.util.Collections.reverseOrder(this)); } - public final Ordering apply(Tuple2,Ordering> t) { - return of(Monoids.comparatorConcat().apply(t._1, t._2)); + public final Ordering apply(Map.Entry,Ordering> t) { + return of(Monoids.comparatorConcat().apply(t.getKey(), t.getValue())); } public final Ordering zero() { diff --git a/src/main/java/fi/solita/utils/functional/SemiGroup.java b/src/main/java/fi/solita/utils/functional/SemiGroup.java index cfb52e4..1d194d4 100644 --- a/src/main/java/fi/solita/utils/functional/SemiGroup.java +++ b/src/main/java/fi/solita/utils/functional/SemiGroup.java @@ -1,6 +1,8 @@ package fi.solita.utils.functional; +import java.util.Map; -public interface SemiGroup extends Apply, T> { + +public interface SemiGroup extends Apply, T> { } diff --git a/src/main/java/fi/solita/utils/functional/SemiGroups.java b/src/main/java/fi/solita/utils/functional/SemiGroups.java index d507181..f548cc1 100644 --- a/src/main/java/fi/solita/utils/functional/SemiGroups.java +++ b/src/main/java/fi/solita/utils/functional/SemiGroups.java @@ -119,12 +119,12 @@ public Set apply(Set first, final Set second) { if (second instanceof Monoids.SetIntersection.AllContainingSet) { return first; } - return newSet(filter(first, new Predicate() { + return newSet(filter(new Predicate() { @Override public boolean accept(T candidate) { return second.contains(candidate); } - })); + }, first)); } } diff --git a/src/main/java/fi/solita/utils/functional/Transformers.java b/src/main/java/fi/solita/utils/functional/Transformers.java index 7309e42..15c6bfd 100644 --- a/src/main/java/fi/solita/utils/functional/Transformers.java +++ b/src/main/java/fi/solita/utils/functional/Transformers.java @@ -50,7 +50,7 @@ public String transform(String source) { if (source == null) { return null; } - return Functional.mkString("", map(filter(it(source), not(whitespace)), toString)); + return Functional.mkString("", map(toString, filter(not(whitespace), it(source)))); } }; @@ -67,7 +67,7 @@ public static final Transformer mkString(final String delim, fina return new Transformer() { @Override public String transform(Tuple source) { - return Functional.mkString(delim, map(source.toArray(), toString)); + return Functional.mkString(delim, map(toString, source.toArray())); } }; } diff --git a/src/main/java/fi/solita/utils/functional/Tuple.java b/src/main/java/fi/solita/utils/functional/Tuple.java index 3339408..431f0f5 100644 --- a/src/main/java/fi/solita/utils/functional/Tuple.java +++ b/src/main/java/fi/solita/utils/functional/Tuple.java @@ -339,16 +339,9 @@ public static interface _22 { @Override public String toString() { - return "(" + mkString(",", map(toArray(), toString)) + ")"; + return "(" + mkString(",", map(Transformers.toString, toArray())) + ")"; } - private static final Transformer toString = new Transformer() { - @Override - public String transform(Object source) { - return source.toString(); - } - }; - @Override public int hashCode() { final int prime = 31; diff --git a/src/test/java/fi/solita/utils/functional/CompareExamples.java b/src/test/java/fi/solita/utils/functional/CompareExamples.java index 87040ec..4c70f94 100644 --- a/src/test/java/fi/solita/utils/functional/CompareExamples.java +++ b/src/test/java/fi/solita/utils/functional/CompareExamples.java @@ -38,22 +38,22 @@ public void examples() { Ordering<_1>> by_1 = Compare.by_1; List> listOfTuples = newList(); - sort(listOfTuples, by_1); + sort(by_1, listOfTuples); // Employee does not implement comparable, but we can first map to _2 and then to salary - sort(listOfTuples, Compare.by(Transformers._2().andThen(salary))); + sort(Compare.by(Transformers._2().andThen(salary)), listOfTuples); // sorted by the contents of an iterable - sort(Collections.>newList(), Compare.byIterable()); + sort(Compare.byIterable(), Collections.>newList()); // sorted by the contents of an Option - sort(Collections.>newList(), Compare.byOption()); + sort(Compare.byOption(), Collections.>newList()); // sorted by a function to an Option - sort(Collections.newList(), Compare.byOption(name)); + sort(Compare.byOption(name), Collections.newList()); // and the same with explicit comparators - sort(Collections.>newList(), Compare.byIterable(Compare.by(salary))); - sort(Collections.>newList(), Compare.byOption(Compare.by(salary))); - sort(Collections.newList(), Compare.byOption(name, Ordering.Natural())); + sort(Compare.byIterable(Compare.by(salary)), Collections.>newList()); + sort(Compare.byOption(Compare.by(salary)), Collections.>newList()); + sort(Compare.byOption(name, Ordering.Natural()), Collections.newList()); } } diff --git a/src/test/java/fi/solita/utils/functional/FunctionExamples.java b/src/test/java/fi/solita/utils/functional/FunctionExamples.java index ef5b86a..bea9f3e 100644 --- a/src/test/java/fi/solita/utils/functional/FunctionExamples.java +++ b/src/test/java/fi/solita/utils/functional/FunctionExamples.java @@ -4,6 +4,8 @@ import static fi.solita.utils.functional.Function.__; import static fi.solita.utils.functional.FunctionalImpl.map; +import java.util.Map; + import org.junit.Test; public class FunctionExamples { @@ -34,7 +36,7 @@ public void examples() { Function2 twoArg = mod; int applied = length.apply("foo"); - Iterable mappedOverFunction = map(newList("a", "aa"), f); + Iterable mappedOverFunction = map(f, newList("a", "aa")); Function0 partiallyApplied = length.ap("foo"); int result = partiallyApplied.apply(); @@ -53,7 +55,7 @@ public void examples() { // multi-param function can be views as a 1-arg function of a Tuple: Function2 m = mod; - Function1,Integer> tuppled = m.tuppled(); + Function1,Integer> tuppled = m.tuppled(); Function2 twoArgFunction = mod; Function1> curried = twoArgFunction.curried(); diff --git a/src/test/java/fi/solita/utils/functional/FunctionalExamples.java b/src/test/java/fi/solita/utils/functional/FunctionalExamples.java index ab1d359..b8f09e0 100644 --- a/src/test/java/fi/solita/utils/functional/FunctionalExamples.java +++ b/src/test/java/fi/solita/utils/functional/FunctionalExamples.java @@ -34,7 +34,6 @@ import static fi.solita.utils.functional.Functional.tail; import static fi.solita.utils.functional.Functional.take; import static fi.solita.utils.functional.Functional.takeWhile; -import static fi.solita.utils.functional.FunctionalA.flatten; import static fi.solita.utils.functional.FunctionalS.intersection; import static fi.solita.utils.functional.FunctionalS.product; import static fi.solita.utils.functional.FunctionalS.sum; diff --git a/src/test/java/fi/solita/utils/functional/FunctionalTest.java b/src/test/java/fi/solita/utils/functional/FunctionalTest.java index 6c264cb..8a227e3 100644 --- a/src/test/java/fi/solita/utils/functional/FunctionalTest.java +++ b/src/test/java/fi/solita/utils/functional/FunctionalTest.java @@ -14,7 +14,6 @@ import static fi.solita.utils.functional.Functional.size; import static fi.solita.utils.functional.Functional.take; import static fi.solita.utils.functional.Functional.transpose; -import static fi.solita.utils.functional.FunctionalC.group; import static fi.solita.utils.functional.FunctionalS.range; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.not; @@ -107,12 +106,12 @@ public void testRange() { public void testName() { @SuppressWarnings("unchecked") Iterable> a = flatMap(zipWithIndex, Arrays.asList(onceIterable)); - Iterable> b = map(a, new Transformer,Iterable>() { + Iterable> b = map(new Transformer,Iterable>() { @Override public Iterable transform(Tuple2 source) { return newList(source._2); } - }); + }, a); Iterable c = flatten(b); newList(c); } @@ -127,10 +126,10 @@ public Iterable> apply(Iterable t) { @Test public void testGrouped() { assertEquals(emptyList(), newList(group(emptyList()))); - assertEquals(newList("a"), newList(map(group("a"), Transformers.toString))); - assertEquals(newList("aaa"), newList(map(group("aaa"), Transformers.toString))); + assertEquals(newList("a"), newList(map(Transformers.toString, group("a")))); + assertEquals(newList("aaa"), newList(map(Transformers.toString, group("aaa")))); assertEquals(newList("M", "i", "ss", "i", "ss", "i", "pp", "i"), - newList(map(group("Mississippi"), Transformers.toString))); + newList(map(Transformers.toString, group("Mississippi")))); } private static final Iterable onceIterable = new Iterable() { diff --git a/src/test/java/fi/solita/utils/functional/MonoidExamples.java b/src/test/java/fi/solita/utils/functional/MonoidExamples.java index 8bb4a25..3365bbf 100644 --- a/src/test/java/fi/solita/utils/functional/MonoidExamples.java +++ b/src/test/java/fi/solita/utils/functional/MonoidExamples.java @@ -18,10 +18,10 @@ public void examples() { // Longs (if assumed unbounded), Booleans and Strings are monoids, // but they do not have "default instances of Monoid typeclass" so we // must give one as a parameter. - long three = reduce(longs, Monoids.longSum); - long two = reduce(longs, Monoids.longProduct); - boolean notTrue = reduce(newList(true, false), Monoids.booleanConjunction); - String foobar = reduce(newList("foo", "bar"), Monoids.stringConcat); + long three = reduce(Monoids.longSum, longs); + long two = reduce(Monoids.longProduct, longs); + boolean notTrue = reduce(Monoids.booleanConjunction, newList(true, false)); + String foobar = reduce(Monoids.stringConcat, newList("foo", "bar")); // For classes having a default (SemiGroup) instance, // no parameter is needed. @@ -30,7 +30,7 @@ public void examples() { Map first = newMap(); Map second = newMap(); - Map valuesSummed = reduce(newList(first, second), Monoids.mapCombine(SemiGroups.longSum)); + Map valuesSummed = reduce(Monoids.mapCombine(SemiGroups.longSum), newList(first, second)); } static class Distance implements SemiGroup { @@ -40,8 +40,8 @@ public Distance(int meters) { this.meters = meters; } - public Distance apply(final Tuple2 t) { - return new Distance(t._1.meters + t._2.meters); + public Distance apply(final Map.Entry t) { + return new Distance(t.getKey().meters + t.getValue().meters); } } } diff --git a/src/test/java/fi/solita/utils/functional/SortTest.java b/src/test/java/fi/solita/utils/functional/SortTest.java index cdd0528..4d388eb 100644 --- a/src/test/java/fi/solita/utils/functional/SortTest.java +++ b/src/test/java/fi/solita/utils/functional/SortTest.java @@ -39,12 +39,12 @@ public void testSort() { public void runSortOnce(int size, int firstToTake) { System.out.println("Testing for " + size + " elements"); - List data = newList(map(range(1, size), new Transformer() { + List data = newList(map(new Transformer() { @Override public TestClass transform(Integer source) { return new TestClass(); } - })); + }, range(1, size))); long start = System.nanoTime(); List regular = new ArrayList(data); @@ -55,7 +55,7 @@ public TestClass transform(Integer source) { System.out.println("Regular sort took " + ((end-start)/1000/1000) + " ms"); start = System.nanoTime(); - List lazy = newList(take(firstToTake, sort(data, Compare.by(accessor)))); + List lazy = newList(take(firstToTake, sort(Compare.by(accessor), data))); end = System.nanoTime(); System.out.println("Lazy sort took " + ((end-start)/1000/1000) + " ms"); diff --git a/src/test/java/fi/solita/utils/functional/TupleExamples.java b/src/test/java/fi/solita/utils/functional/TupleExamples.java index c03a8fa..51f47df 100644 --- a/src/test/java/fi/solita/utils/functional/TupleExamples.java +++ b/src/test/java/fi/solita/utils/functional/TupleExamples.java @@ -39,6 +39,6 @@ public void examples() { Tuple3 prefix3 = bigtuple.take3(); List> listOfTuples = newList(); - Iterable projection = map(listOfTuples, Transformers._2()); + Iterable projection = map(Transformers._2(), listOfTuples); } }