#177: Implemented toListReverse and toStreamReverse for Set and TreeMap

mperry · mperry · commit 87db1bd86d94 · 2015-08-30T20:55:52.000+10:00
diff --git a/core/src/main/java/fj/data/Set.java b/core/src/main/java/fj/data/Set.java
@@ -269,6 +269,19 @@ public final <B> B foldMap(final F<A, B> f, final Monoid<B> m) {
            m.sum(m.sum(l().foldMap(f, m), f.f(head())), r().foldMap(f, m));
   }
 
+    /**
+     * Folds this Set from the right using the given monoid.
+     *
+     * @param f A transformation from this Set's elements, to the monoid.
+     * @param m The monoid to fold this Set with.
+     * @return The result of folding the Set from the right with the given monoid.
+     */
+    public final <B> B foldMapRight(final F<A, B> f, final Monoid<B> m) {
+        return isEmpty() ?
+                m.zero() :
+                m.sum(m.sum(r().foldMapRight(f, m), f.f(head())), l().foldMapRight(f, m));
+    }
+
   /**
    * Returns a list representation of this set.
    *
@@ -278,6 +291,15 @@ public final List<A> toList() {
     return foldMap(List.cons(List.<A>nil()), Monoid.<A>listMonoid());
   }
 
+    /**
+     * Returns a list representation of this set in reverse order.
+     *
+     * @return a list representation of this set in reverse order.
+     */
+    public final List<A> toListReverse() {
+        return foldMapRight(List.cons(List.<A>nil()), Monoid.<A>listMonoid());
+    }
+
   /**
    * Returns a stream representation of this set.
    *
@@ -293,6 +315,21 @@ public final Stream<A> toStream() {
         }
     }
 
+    /**
+     * Returns a stream representation of this set in reverse order.
+     *
+     * @return a stream representation of this set in reverse order.
+     */
+    public final Stream<A> toStreamReverse() {
+        if (isEmpty()) {
+            return Stream.nil();
+        } else if (r().isEmpty()) {
+            return Stream.cons(head(), () -> l().toStreamReverse());
+        } else {
+            return r().toStreamReverse().append(Stream.cons(head(), () -> l().toStreamReverse()));
+        }
+    }
+
     /**
    * Binds the given function across this set.
    *
diff --git a/core/src/main/java/fj/data/TreeMap.java b/core/src/main/java/fj/data/TreeMap.java
@@ -186,10 +186,18 @@ public Stream<P2<K, V>> toStream() {
         return tree.toStream().map(p -> p.map2(o -> o.some()));
     }
 
+    public Stream<P2<K, V>> toStreamReverse() {
+        return tree.toStreamReverse().map(p -> p.map2(o -> o.some()));
+    }
+
     public List<P2<K, V>> toList() {
         return tree.toList().map(p -> p.map2(o -> o.some()));
     }
 
+    public List<P2<K, V>> toListReverse() {
+        return tree.toListReverse().map(p -> p.map2(o -> o.some()));
+    }
+
   /**
    * An immutable projection of the given mutable map.
    *
diff --git a/props-core/src/test/java/fj/data/properties/SetProperties.java b/props-core/src/test/java/fj/data/properties/SetProperties.java
@@ -21,19 +21,30 @@
 @CheckParams(maxSize = 10000)
 public class SetProperties {
 
-    public final static Arbitrary<Set<Integer>> as = Arbitrary.arbSet(Ord.intOrd, Arbitrary.arbInteger, 5);
+    public final static int maxSize = 20;
+    public final static Arbitrary<Set<Integer>> as = Arbitrary.arbSet(Ord.intOrd, Arbitrary.arbInteger, maxSize);
+    public final static Equal<List<Integer>> eq = Equal.listEqual(Equal.intEqual);
 
 	Property setToListIsSorted() {
 		return property(as, s -> prop(s.toList().equals(s.toList().sort(Ord.intOrd))));
 	}
 
     Property stream() {
         return property(as, s -> {
-            Equal<List<Integer>> eq = Equal.listEqual(Equal.intEqual);
             List<Integer> l1 = s.toList();
             List<Integer> l2 = s.toStream().toList();
             return prop(eq.eq(l1, l2));
         });
     }
 
+    Property listReverse() {
+        return property(as, s -> {
+            return prop(eq.eq(s.toList().reverse(), s.toListReverse()));
+        });
+    }
+
+    Property streamReverse() {
+        return property(as, s -> prop(eq.eq(s.toStream().toList().reverse(), s.toStreamReverse().toList())));
+    }
+
 }

Original file line number	Diff line number	Diff line change
`@@ -186,10 +186,18 @@ public Stream<P2<K, V>> toStream() {`
`186`	`186`	`return tree.toStream().map(p -> p.map2(o -> o.some()));`
`187`	`187`	`}`
`188`	`188`
	`189`	`+ public Stream<P2<K, V>> toStreamReverse() {`
	`190`	`+ return tree.toStreamReverse().map(p -> p.map2(o -> o.some()));`
	`191`	`+ }`
	`192`	`+`
`189`	`193`	`public List<P2<K, V>> toList() {`
`190`	`194`	`return tree.toList().map(p -> p.map2(o -> o.some()));`
`191`	`195`	`}`
`192`	`196`
	`197`	`+ public List<P2<K, V>> toListReverse() {`
	`198`	`+ return tree.toListReverse().map(p -> p.map2(o -> o.some()));`
	`199`	`+ }`
	`200`	`+`
`193`	`201`	`/**`
`194`	`202`	`* An immutable projection of the given mutable map.`
`195`	`203`	`*`