#77: Improved show for list, tree, set, treemap, stream, array, V arity 2 to 8, HList

mperry · mperry · commit f8af461afee9 · 2015-01-11T19:45:05.000+10:00
diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
@@ -8,6 +8,8 @@
 import fj.data.NonEmptyList;
 import fj.data.Option;
 import fj.data.Stream;
+import fj.data.Set;
+import fj.data.TreeMap;
 import fj.data.Tree;
 import fj.data.Validation;
 import fj.data.hlist.HList;
@@ -282,7 +284,7 @@ public static <A, B> Show<Validation<A, B>> validationShow(final Show<A> sa, fin
    * @return A show instance for the {@link Stream} type.
    */
   public static <A> Show<List<A>> listShow(final Show<A> sa) {
-    return show(as -> streamShow(sa).show(as.toStream()));
+    return show(as -> streamShow(sa, "List(", ",", ")").show(as.toStream()));
   }
 
   /**
@@ -303,21 +305,91 @@ public static <A> Show<NonEmptyList<A>> nonEmptyListShow(final Show<A> sa) {
    */
   public static <A> Show<Tree<A>> treeShow(final Show<A> sa) {
     return show(a -> {
-      final Stream<Character> b = sa.f.f(a.root())
-          .append(p1Show(streamShow(Show.<A>treeShow(sa))).f.f(a.subForest()))
-          .snoc(')');
-      return cons('(', p(b));
+      Stream<Character> result = sa.f.f(a.root());
+      if (!a.subForest()._1().isEmpty()) {
+        result = result.append(fromString(",")).append(streamShow(treeShow(sa), "", ",", "").f.f(a.subForest()._1()));
+      }
+      return fromString("Tree(").append(p(result)).append(fromString(")"));
     });
   }
 
+  /**
+   * A show instance for the {@link Set} type.
+   *
+   * @param sa Show for the elements of the set.
+   * @return A show instance for the {@link Set} type.
+   */
+  public static <A> Show<Set<A>> setShow(final Show<A> sa) {
+    return show(s -> streamShow(sa, "Set(", ",", ")").show(s.toStream()));
+  }
+
+  /**
+   * A show instance for the {@link TreeMap} type.
+   *
+   * @param sk Show for the keys of the TreeMap.
+   * @param sv Show for the values of the TreeMap.
+   * @return A show instance for the {@link TreeMap} type.
+   */
+  public static <K, V> Show<TreeMap<K, V>> treeMapShow(final Show<K> sk, final Show<V> sv) {
+    return show(tm -> {
+      Stream<P2<K, V>> stream = Stream.iteratorStream(tm.iterator());
+      return streamShow(Show.p2MapShow(sk, sv), "TreeMap(", ",", ")").show(stream);
+    });
+  }
+
+  /**
+   * A show instance for the {@link P2 tuple-2} type in the style of a mapping from A to B.
+   *
+   * @param sa Show for the first element of the tuple.
+   * @param sb Show for the second element of the tuple.
+   * @return A show instance for the {@link P2 tuple-2} type.
+   */
+  public static <A, B> Show<P2<A, B>> p2MapShow(final Show<A> sa, final Show<B> sb) {
+    return p2Show(sa, sb, "(", ":", ")");
+  }
+
+  /**
+   * A show instance for the {@link P2 tuple-2} type.
+   *
+   * @param sa Show for the first element of the tuple.
+   * @param sb Show for the second element of the tuple.
+   * @param start Prefix string for the show.
+   * @param sep Separator string between elements of the tuple.
+   * @param end Suffix string for the show.
+   * @return A show instance for the {@link P2 tuple-2} type.
+   */
+  public static <A, B> Show<P2<A, B>> p2Show(final Show<A> sa, final Show<B> sb, String start, String sep, String end) {
+    return show(p -> fromString(start).append(p(sa.show(p._1()))).append(fromString(sep)).append(sb.show(p._2())).append(fromString(end)));
+  }
+
   /**
    * A show instance for the {@link Stream} type.
    *
    * @param sa Show for the elements of the stream.
    * @return A show instance for the {@link Stream} type.
    */
   public static <A> Show<Stream<A>> streamShow(final Show<A> sa) {
-    return show(as -> join(as.map(sa.show_()).intersperse(fromString(",")).cons(fromString("<")).snoc(p(fromString(">")))));
+    return streamShow(sa, "Stream(", ",", ")");
+  }
+
+  /**
+   * A show instance for the {@link Stream} type.
+   *
+   * @param sa Show for the first element of the tuple.
+   * @param start Prefix string for the show.
+   * @param sep Separator string between elements of the stream.
+   * @param end Suffix string for the show.
+   * @return A show instance for the {@link Stream} type.
+   */
+  public static <A> Show<Stream<A>> streamShow(final Show<A> sa, String start, String sep, String end) {
+    return show(streamShow_(sa, start, sep, end));
+  }
+
+  /**
+   * Returns the transformation equivalent for the stream show.
+   */
+  public static <A> F<Stream<A>, Stream<Character>> streamShow_(final Show<A> sa, String start, String sep, String end) {
+    return as -> join(as.map(sa.show_()).intersperse(fromString(sep)).cons(fromString(start)).snoc(p(fromString(end))));
   }
 
   /**
@@ -334,12 +406,12 @@ public static <A> Show<Array<A>> arrayShow(final Show<A> sa) {
         b = b.append(sa.f.f(as.get(i)));
 
         if (i != as.length() - 1)
-          b = b.snoc(',');
+          b = b.append(fromString(","));
       }
 
-      b = b.snoc('}');
+      b = b.append(fromString("Array("));
 
-      return cons('{', p(b));
+      return fromString(")").append(p(b));
     });
   }
 
@@ -370,7 +442,7 @@ public static <A> Show<P1<A>> p1Show(final Show<A> sa) {
    * @return A show instance for the {@link P2 tuple-2} type.
    */
   public static <A, B> Show<P2<A, B>> p2Show(final Show<A> sa, final Show<B> sb) {
-    return show(p -> cons('(', p(sa.show(p._1()))).snoc(',').append(sb.show(p._2())).snoc(')'));
+      return p2Show(sa, sb, "(", ",", ")");
   }
 
   /**
@@ -487,7 +559,7 @@ public static <A, B, C, D, E> Show<P5<A, B, C, D, E>> p5Show(final Show<A> sa, f
    * @return A show instance for a vector-2.
    */
   public static <A> Show<V2<A>> v2Show(final Show<A> ea) {
-    return streamShow(ea).comap(V2.<A>toStream_());
+    return streamShow(ea, "V2(", ",", ")").comap(V2.<A>toStream_());
   }
 
   /**
@@ -497,7 +569,7 @@ public static <A> Show<V2<A>> v2Show(final Show<A> ea) {
    * @return A show instance for a vector-3.
    */
   public static <A> Show<V3<A>> v3Show(final Show<A> ea) {
-    return streamShow(ea).comap(V3.<A>toStream_());
+    return streamShow(ea, "V3(", ",", ")").comap(V3.<A>toStream_());
   }
 
   /**
@@ -507,7 +579,7 @@ public static <A> Show<V3<A>> v3Show(final Show<A> ea) {
    * @return A show instance for a vector-4.
    */
   public static <A> Show<V4<A>> v4Show(final Show<A> ea) {
-    return streamShow(ea).comap(V4.<A>toStream_());
+    return streamShow(ea, "V4(", ",", ")").comap(V4.<A>toStream_());
   }
 
   /**
@@ -517,7 +589,7 @@ public static <A> Show<V4<A>> v4Show(final Show<A> ea) {
    * @return A show instance for a vector-5.
    */
   public static <A> Show<V5<A>> v5Show(final Show<A> ea) {
-    return streamShow(ea).comap(V5.<A>toStream_());
+    return streamShow(ea, "V5(", ",", ")").comap(V5.<A>toStream_());
   }
 
   /**
@@ -527,7 +599,7 @@ public static <A> Show<V5<A>> v5Show(final Show<A> ea) {
    * @return A show instance for a vector-6.
    */
   public static <A> Show<V6<A>> v6Show(final Show<A> ea) {
-    return streamShow(ea).comap(V6.<A>toStream_());
+    return streamShow(ea, "V6(", ",", ")").comap(V6.<A>toStream_());
   }
 
   /**
@@ -537,7 +609,7 @@ public static <A> Show<V6<A>> v6Show(final Show<A> ea) {
    * @return A show instance for a vector-7.
    */
   public static <A> Show<V7<A>> v7Show(final Show<A> ea) {
-    return streamShow(ea).comap(V7.<A>toStream_());
+    return streamShow(ea, "V7(", ",", ")").comap(V7.<A>toStream_());
   }
 
   /**
@@ -547,7 +619,7 @@ public static <A> Show<V7<A>> v7Show(final Show<A> ea) {
    * @return A show instance for a vector-8.
    */
   public static <A> Show<V8<A>> v8Show(final Show<A> ea) {
-    return streamShow(ea).comap(V8.<A>toStream_());
+    return streamShow(ea, "V8(", ",", ")").comap(V8.<A>toStream_());
   }
 
   /**
@@ -583,6 +655,6 @@ public static <A> Show<Stream<A>> unlineShow(final Show<A> sa) {
    * @return a show instance for heterogeneous Streams.
    */
   public static <E, L extends HList<L>> Show<HList.HCons<E, L>> HListShow(final Show<E> e, final Show<L> l) {
-    return show(c -> e.show(c.head()).cons('[').append(l.show(c.tail())).snoc(']'));
+    return show(c -> fromString("HList(").append(e.show(c.head())).append(l.show(c.tail())).append(fromString(")")));
   }
 }
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
@@ -1587,21 +1587,21 @@ public static <A> Stream<A> iterateWhile(final F<A, A> f, final F<A, Boolean> p,
    * @return A stream from the given iterable.
    */
   public static <A> Stream<A> iterableStream(final Iterable<A> i) {
-    final class Util {
-      public <A> Stream<A> iteratorStream(final Iterator<A> i) {
-        if (i.hasNext()) {
-          final A a = i.next();
-          return cons(a, new P1<Stream<A>>() {
-            public Stream<A> _1() {
-              return iteratorStream(i);
-            }
-          });
-        } else
-          return nil();
-      }
-    }
+    return iteratorStream(i.iterator());
+  }
 
-    return new Util().iteratorStream(i.iterator());
+  /**
+   * Takes the given iterator to a stream.
+   *
+   * @param i The iterator to take to a stream.
+   * @return A stream from the given iterator.
+   */
+  public static <A> Stream<A> iteratorStream(final Iterator<A> i) {
+    if (i.hasNext()) {
+      final A a = i.next();
+      return cons(a, P.lazy(u -> iteratorStream(i)));
+    } else
+      return nil();
   }
 
   /**
diff --git a/core/src/test/java/fj/data/TestRngState.java b/core/src/test/java/fj/data/TestRngState.java
@@ -22,8 +22,9 @@
  */
 public class TestRngState {
 
-	static String expected1 = "<4,4,2,2,2,5,3,3,1,5>";
+	static List<Integer> expected1 = List.list(4,4,2,2,2,5,3,3,1,5);
 	static int size = 10;
+    static final Equal<List<Integer>> listIntEqual = Equal.listEqual(Equal.intEqual);
 
     static Rng defaultRng() {
         return new LcgRng(1);
@@ -48,10 +49,10 @@ static P2<Rng, Integer> num(Rng r, int x) {
 	@Test
     public void testUnfold() {
         Stream<Integer> s = unfold(r -> some(num(r).swap()), defaultRng());
-		Assert.assertTrue(s.take(size).toList().toString().equals(expected1));
+		Assert.assertTrue(listIntEqual.eq(s.take(size).toList(), expected1));
     }
 
-	@Test
+    @Test
     public void testTransitions() {
 		P2<List<State<Rng, Integer>>, State<Rng, Integer>> p = List.replicate(size, nextState()).foldLeft(
 			(P2<List<State<Rng, Integer>>, State<Rng, Integer>> p2, F<State<Rng, Integer>, State<Rng, Integer>> f) -> {
@@ -61,21 +62,21 @@ public void testTransitions() {
 				, P.p(List.nil(),  defaultState())
 		);
 		List<Integer> ints = p._1().map(s -> s.eval(defaultRng()));
-		Assert.assertTrue(ints.toString().equals(expected1));
+		Assert.assertTrue(listIntEqual.eq(ints, expected1));
     }
 
 	@Test
 	public void testSequence() {
 		List<Integer> list = State.sequence(List.replicate(size, defaultState())).eval(defaultRng());
-		Assert.assertTrue(list.toString().equals(expected1));
+		Assert.assertTrue(listIntEqual.eq(list, expected1));
 	}
 
     @Test
     public void testTraverse() {
         List<Integer> list = State.traverse(List.range(1, 10), a -> (State.unit((Rng s) -> num(s, a)))).eval(defaultRng());
 //        System.out.println(list.toString());
-        String expected = "<1,2,3,5,6,7,7,9,10>";
-        Assert.assertTrue(list.toString().equals(expected));
+        List<Integer> expected = List.list(1,2,3,5,6,7,7,9,10);
+        Assert.assertTrue(listIntEqual.eq(list, expected));
     }
 
     public static Arbitrary<State<LcgRng, Integer>> arbState() {
