Implemented suggestons from @jbgi for PriorityQueue

mperry · mperry · commit a506f0619cff · 2016-06-20T00:15:03.000+10:00
diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
@@ -13,11 +13,15 @@
 import static fj.data.List.list;
 
 /**
- * A priority queue implementation backed by a {@link fj.data.fingertrees.FingerTree}.  The finger tree nodes are annotated with type K, are combined using a monoid of K and both the key and value are stored in the leaf.  Priorities of the same value are returned FIFO (first in, first out).
+ * A priority queue implementation backed by a
+ * {@link fj.data.fingertrees.FingerTree}.  The finger tree nodes are
+ * annotated with type K, are combined using a monoid of K and both the
+ * key and value are stored in the leaf.  Priorities of the same value
+ * are returned FIFO (first in, first out).
  *
  * Created by MarkPerry on 31 May 16.
  */
-public class PriorityQueue<K, A> {
+public final class PriorityQueue<K, A> {
 
     private final FingerTree<K, P2<K, A>> ftree;
     private final Equal<K> equal;
@@ -31,7 +35,7 @@ private PriorityQueue(Equal<K> e, FingerTree<K, P2<K, A>> ft) {
      * Creates a priority queue from a finger tree.
      */
     public static <K, A> PriorityQueue<K, A> priorityQueue(Equal<K> e, FingerTree<K, P2<K, A>> ft) {
-        return new PriorityQueue<K, A>(e, ft);
+        return new PriorityQueue<>(e, ft);
     }
 
     /**
@@ -41,23 +45,24 @@ public static <K, A> PriorityQueue<K, A> priorityQueue(Equal<K> e, FingerTree<K,
      * @param e A value to compare key equality.
      */
     public static <K, A> PriorityQueue<K, A> empty(Monoid<K> m, Equal<K> e) {
-        return priorityQueue(e, FingerTree.empty(m, (P2<K, A> p) -> p._1()));
+        return priorityQueue(e, FingerTree.empty(m, P2.__1()));
     }
 
     /**
      * An empty priority queue with integer priorities.
      */
     public static <A> PriorityQueue<Integer, A> emptyInt() {
-        return priorityQueue(Equal.intEqual, FingerTree.empty(Monoid.intMaxMonoid, (P2<Integer, A> p) -> p._1()));
+        return empty(Monoid.intMaxMonoid, Equal.intEqual);
     }
 
     /**
      * Maps the values in each node with function f.
      */
     public <B> PriorityQueue<K, B> map(F<A, B> f) {
         return priorityQueue(equal,
-                ftree.map(p2 -> p2.map2(a -> f.f(a)),
-                FingerTree.measured(ftree.measured().monoid(), (P2<K, B> p2) -> p2._1()))
+                ftree.map(P2.map2_(f),
+                        FingerTree.measured(ftree.measured().monoid(), P2.__1())
+                )
         );
     }
 
@@ -91,6 +96,9 @@ public Option<P2<K, A>> top() {
         return p._2().headOption();
     }
 
+    /**
+     * Returns all the elements of the queue with the highest (same) priority.
+     */
     public List<P2<K, A>> topN() {
         Stream<P2<K, A>> s = toStream();
         if (s.isEmpty()) {
@@ -153,7 +161,7 @@ public PriorityQueue<K, A> dequeue() {
     /**
      * Returns a tuple of the node with the highest priority and the rest of the priority queue.
      */
-    public P2<Option<P2<K, A>>, PriorityQueue<K, A>> dequeueTop() {
+    public P2<Option<P2<K, A>>, PriorityQueue<K, A>> topDequeue() {
         return P.p(top(), dequeue());
     }
 
diff --git a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
@@ -94,7 +94,6 @@ public Property sorted() {
         return property(arbPriorityQueueIntegerString, pq -> {
             List<P2<Integer, String>> expected = pq.toList().sort(Ord.p2Ord1(Ord.intOrd.reverse()));
             List<P2<Integer, String>> actual = pq.toList();
-            assertThat(actual, equalTo(expected));
             return prop(actual.equals(expected));
         });
     }

Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,6 @@ public Property sorted() {`
`94`	`94`	`return property(arbPriorityQueueIntegerString, pq -> {`
`95`	`95`	`List<P2<Integer, String>> expected = pq.toList().sort(Ord.p2Ord1(Ord.intOrd.reverse()));`
`96`	`96`	`List<P2<Integer, String>> actual = pq.toList();`
`97`		`- assertThat(actual, equalTo(expected));`
`98`	`97`	`return prop(actual.equals(expected));`
`99`	`98`	`});`
`100`	`99`	`}`