Added IOFunctions.interactWhile and some sequence and traverse methods for Stream to support interactive IO from stdin to stdout

mperry · mperry · commit e727b77a9d6e · 2015-06-14T23:46:48.000+10:00
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
@@ -172,6 +172,8 @@ public A run() throws IOException {
         };
     }
 
+    public static final IO<Unit> ioUnit = unit(Unit.unit());
+
     public static final <A> IO<A> lazy(final F0<A> p) {
         return fromF(p);
     }
@@ -404,6 +406,18 @@ public static <A, B> IO<B> flatMap(final IO<A> io, final F<A, IO<B>> f) {
         return bind(io, f);
     }
 
+    /**
+     * Read lines from stdin until condition is not met, transforming each line and printing
+     * the result to stdout.
+     * @param condition Read lines until a line does not satisfy condition
+     * @param transform Function to change line value
+     */
+    public static IO<Unit> interactWhile(F<String, Boolean> condition, F<String, String> transform) {
+        Stream<IO<String>> s1 = Stream.repeat(IOFunctions.stdinReadLine());
+        IO<Stream<String>> io = sequenceWhile(s1, condition);
+        return () -> runSafe(io).foreach(s -> runSafe(stdoutPrintln(transform.f(s))));
+    }
+
     public static <A> IO<Stream<A>> sequenceWhileEager(final Stream<IO<A>> stream, final F<A, Boolean> f) {
         return new IO<Stream<A>>() {
             @Override
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
@@ -365,7 +365,7 @@ public final Stream<A> removeAll(final F<A, Boolean> f) {
    */
   public static <A, B> F<B, Stream<A>> sequence_(final Stream<F<B, A>> fs) {
     return fs.foldRight((baf, p1) -> Function.bind(baf, p1._1(), Function.curry((a, stream) -> cons(a, p(stream)))), Function
-        .<B, Stream<A>>constant(Stream.<A>nil()));
+            .<B, Stream<A>>constant(Stream.<A>nil()));
   }
 
   /**
@@ -527,6 +527,36 @@ public final <B> Stream<B> sequence(final Stream<B> bs) {
     return bind(c);
   }
 
+  /**
+   * Sequence through the Stream monad.
+   *
+   * @param io The IO stream to sequence.
+   * @return The stream of IOs after sequencing.
+   */
+  public static <A> Stream<IO<A>> sequence(final IO<Stream<A>> io) {
+    return IOFunctions.runSafe(io).map(a -> IOFunctions.unit(a));
+  }
+
+  /**
+   * Sequence through the Stream monad.
+   *
+   * @param p The lazy stream to sequence.
+   * @return The stream of (pre-calculated) lazy values after sequencing.
+   */
+  public static <A> Stream<P1<A>> sequence(final P1<Stream<A>> p) {
+    return p._1().map(a -> P.p(a));
+  }
+
+  /**
+   * Sequence through the Stream monad.
+   *
+   * @param o The optional stream to sequence.
+   * @return The stream of options after sequencing.
+   */
+  public static <A> Stream<Option<A>> sequence(final Option<Stream<A>> o) {
+    return o.isNone() ? Stream.nil() : o.some().map(a -> Option.some(a));
+  }
+
   /**
    * Performs function application within a stream (applicative functor pattern).
    *
@@ -1082,6 +1112,28 @@ public Stream<A> _1() {
            Stream.<A>nil();
   }
 
+  /**
+   * Traversable instance of Stream for IO.
+   *
+   * @return traversed value
+   */
+  public final <B> IO<Stream<B>> traverseIO(F<A, IO<B>> f) {
+    return this.foldRight1((a, acc) ->
+            IOFunctions.bind(acc, (Stream<B> bs) ->
+                    IOFunctions.map(f.f(a), b ->
+                            bs.cons(b))), IOFunctions.unit(Stream.<B>nil()));
+
+  }
+
+  /**
+   * Traversable instance of Stream for Option.
+   *
+   * @return traversed value
+   */
+  public final <B> Option<Stream<B>> traverseOption(F<A, Option<B>> f) {
+    return this.foldRight1((a, acc) -> acc.bind(bs -> f.f(a).map(b -> bs.cons(b))), some(Stream.<B>nil()));
+  }
+
   /**
    * Removes elements from the head of this stream that do not match the given predicate function
    * until an element is found that does match or the stream is exhausted.
diff --git a/demo/src/main/java/fj/demo/realworld/Chapter7.java b/demo/src/main/java/fj/demo/realworld/Chapter7.java
@@ -1,5 +1,7 @@
 package fj.demo.realworld;
 
+import fj.data.IO;
+import fj.data.IOFunctions;
 import fj.data.LazyString;
 import fj.data.Stream;
 
@@ -13,17 +15,36 @@
 public class Chapter7 {
 
     public static void main(String[] args) {
-        interactToUpper();
+//        toUpperLazy();
+//        toUpperByLine();
+        toUpperInteract();
     }
 
     /**
      * Lazy interact to upper, shows the first lazy string line.
      */
-    public static void interactToUpper() {
+    public static void toUpperLazy() {
         runSafe(interact(ls -> {
             Stream<String> stream = ls.lines().map((LazyString ls2) -> ls2.eval().toUpperCase());
             return LazyString.unlines(stream.map(s -> LazyString.str(s)));
         }));
     }
 
+    /**
+     * Read each line, convert to uppercase and print on stdout, until an empty line
+     */
+    public static void toUpperByLine() {
+        Stream<IO<String>> s1 = Stream.repeat(IOFunctions.stdinReadLine());
+        IO<Stream<String>> io = sequenceWhile(s1, s -> s.trim().length() > 0);
+        runSafe(io).foreachDoEffect(s -> runSafe(stdoutPrintln(s.toUpperCase())));
+    }
+
+    /**
+     * Read from stdin each line, whilst each line is not empty, print
+     * uppercase line to stdout
+     */
+    public static void toUpperInteract() {
+        runSafe(interactWhile(s -> s.trim().length() > 0, s -> s.toUpperCase()));
+    }
+
 }
