Adding SortWith for sorting given a Comparator

jnape · jnape · commit 6dc922009fa0 · 2019-01-13T18:27:01.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,6 +11,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `CheckedFn1` now overrides all possible methods with covariant return type 
 - `MapLens#asCopy` has overload taking copy function
 - `MapLens#valueAt` has overload taking copy function
+- `SortWith` for sorting an `Iterable` given a `Comparator` over its elements
 
 ### Fixed
 - issue where certain ways to compose `Effect`s unintentionally nullified the effect 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Sort.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Sort.java
@@ -1,6 +1,8 @@
 package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.builtin.fn2.SortBy;
+import com.jnape.palatable.lambda.functions.builtin.fn2.SortWith;
 
 import java.util.List;
 
@@ -12,7 +14,8 @@
  * this is both eager and monolithic.
  *
  * @param <A> the input Iterable and output List element type
- * @see com.jnape.palatable.lambda.functions.builtin.fn2.SortBy
+ * @see SortBy
+ * @see SortWith
  */
 public final class Sort<A extends Comparable<A>> implements Fn1<Iterable<A>, List<A>> {
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortBy.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortBy.java
@@ -2,12 +2,12 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
+import com.jnape.palatable.lambda.functions.builtin.fn1.Sort;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Function;
 
-import static com.jnape.palatable.lambda.functions.builtin.fn2.ToCollection.toCollection;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.SortWith.sortWith;
 import static java.util.Comparator.comparing;
 
 /**
@@ -17,7 +17,8 @@
  *
  * @param <A> the input Iterable and output List element type
  * @param <B> the mapped Comparable type
- * @see com.jnape.palatable.lambda.functions.builtin.fn1.Sort
+ * @see Sort
+ * @see SortWith
  */
 public final class SortBy<A, B extends Comparable<B>> implements Fn2<Function<? super A, ? extends B>, Iterable<A>, List<A>> {
 
@@ -28,9 +29,7 @@ private SortBy() {
 
     @Override
     public List<A> apply(Function<? super A, ? extends B> fn, Iterable<A> as) {
-        List<A> result = toCollection(ArrayList::new, as);
-        result.sort(comparing(fn));
-        return result;
+        return sortWith(comparing(fn), as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortWith.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortWith.java
@@ -0,0 +1,48 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+import com.jnape.palatable.lambda.functions.builtin.fn1.Sort;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.ToCollection.toCollection;
+
+/**
+ * Given an {@link Iterable} and a {@link java.util.Comparator} over the {@link Iterable} element type, produce a
+ * sorted {@link List} of the original elements based on sorting applied by the {@link java.util.Comparator}. Note that
+ * this is both eager and monolithic.
+ *
+ * @param <A> the input Iterable and output List element type
+ * @see Sort
+ * @see SortBy
+ */
+public final class SortWith<A> implements Fn2<Comparator<? super A>, Iterable<A>, List<A>> {
+
+    private static final SortWith INSTANCE = new SortWith();
+
+    private SortWith() {
+    }
+
+    @Override
+    public List<A> apply(Comparator<? super A> comparator, Iterable<A> as) {
+        List<A> result = toCollection(ArrayList::new, as);
+        result.sort(comparator);
+        return result;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> SortWith<A> sortWith() {
+        return INSTANCE;
+    }
+
+    public static <A> Fn1<Iterable<A>, List<A>> sortWith(Comparator<? super A> comparator) {
+        return SortWith.<A>sortWith().apply(comparator);
+    }
+
+    public static <A> List<A> sortWith(Comparator<? super A> comparator, Iterable<A> as) {
+        return SortWith.<A>sortWith(comparator).apply(as);
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortWithTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortWithTest.java
@@ -0,0 +1,22 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import org.junit.Test;
+
+import java.util.Comparator;
+
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.SortWith.sortWith;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+
+public class SortWithTest {
+
+    @Test
+    public void sortsWithGivenComparator() {
+        assertEquals(asList(tuple("bar", 4), tuple("baz", 3), tuple("foo", 1), tuple("foo", 2)),
+                     sortWith(Comparator.<Tuple2<String, Integer>, String>comparing(Tuple2::_1)
+                                      .thenComparing(Tuple2::_2),
+                              asList(tuple("foo", 1), tuple("foo", 2), tuple("bar", 4), tuple("baz", 3))));
+    }
+}
