Added State traverse and sequence. Tested State for RNGs.

mperry · mperry · commit 9c12c3def9ba · 2014-08-07T00:48:01.000+10:00
diff --git a/core/src/main/java/fj/RNG.java b/core/src/main/java/fj/RNG.java
@@ -10,7 +10,13 @@ public abstract class RNG {
     public abstract P2<RNG, Long> nextLong();
 
     public P2<RNG, Integer> range(int low, int high) {
-        return nextInt().map2(x -> (Math.abs(x) % (high - low + 1)) + low);
+        return nextNatural().map2(x -> (x % (high - low + 1)) + low);
     }
 
+
+	public P2<RNG, Integer> nextNatural() {
+		return nextInt().map2(x -> x < 0 ? -(x + 1) : x);
+	}
+
+
 }
diff --git a/core/src/main/java/fj/SimpleRNG.java b/core/src/main/java/fj/SimpleRNG.java
@@ -23,7 +23,8 @@ public P2<RNG, Integer> nextInt() {
         return P.p(p._1(), i);
 	}
 
-    public P2<RNG, Long> nextLong() {
+
+	public P2<RNG, Long> nextLong() {
         P2<Long, Long> p = nextLong(seed);
         return P.p(new SimpleRNG(p._1()), p._2());
     }
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
@@ -2,6 +2,8 @@
 
 import fj.*;
 
+import java.util.*;
+
 import static fj.P.p;
 
 /**
@@ -96,4 +98,23 @@ public static <S, A> State<S, A> gets(F<S, A> f) {
 		return State.<S>init().map(s -> f.f(s));
 	}
 
+	/**
+	 * Evaluate each action in the sequence from left to right, and collect the results.
+	 */
+	public static <S, A> State<S, List<A>> sequence(List<State<S, A>> list) {
+		return list.foldLeft((State<S, List<A>> acc, State<S, A> ma) ->
+			acc.flatMap((List<A> xs) -> ma.map((A x) -> xs.snoc(x))
+		), constant(List.<A>nil()));
+	}
+
+	/**
+	 * Map each element of a structure to an action, evaluate these actions from left to right
+	 * and collect the results.
+	 */
+	public static <S, A, B> State<S, List<B>> traverse(List<A> list, F<A, State<S, B>> f) {
+		return list.foldLeft((State<S, List<B>> acc, A a) ->
+			acc.flatMap(bs -> f.f(a).map(b -> bs.snoc(b))
+		), constant(List.<B>nil()));
+	}
+
 }
diff --git a/core/src/test/java/fj/data/StateDemo_Rng.java b/core/src/test/java/fj/data/StateDemo_Rng.java
@@ -0,0 +1,62 @@
+package fj.data;
+
+import fj.*;
+import fj.data.State;
+import fj.data.Stream;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static fj.data.Option.some;
+import static fj.data.Stream.unfold;
+
+/**
+ * Created by mperry on 4/08/2014.
+ */
+public class StateDemo_Rng {
+
+	static String expected1 = "<4,4,2,2,2,5,3,3,1,5>";
+	static int size = 10;
+
+    static RNG initRNG() {
+        return new SimpleRNG(1);
+    }
+
+	@Test
+    public void testUnfold() {
+        Stream<Integer> s = unfold(r -> some(num(r).swap()), initRNG());
+		Assert.assertTrue(s.take(size).toList().toString().equals(expected1));
+    }
+
+	@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) -> {
+				State<RNG, Integer> s = f.f(p2._2());
+				return P.p(p2._1().snoc(p2._2()), s);
+			}
+				, P.p(List.nil(),  defaultState())
+		);
+		List<Integer> ints = p._1().map(s -> s.eval(initRNG()));
+		Assert.assertTrue(ints.toString().equals(expected1));
+    }
+
+
+    static P2<RNG, Integer> num(RNG r) {
+        return r.range(1, 5);
+    }
+
+	static State<RNG, Integer> defaultState() {
+		return State.unit(s -> num(s));
+	}
+
+    static F<State<RNG, Integer>, State<RNG, Integer>> nextState() {
+        return s -> s.mapState(p2 -> num(p2._1()));
+    }
+
+	@Test
+	public void testSequence() {
+		List<Integer> list = State.sequence(List.replicate(size, defaultState())).eval(initRNG());
+		Assert.assertTrue(list.toString().equals(expected1));
+	}
+
+}
diff --git a/demo/src/main/java/fj/demo/StateDemo_Rng.java b/demo/src/main/java/fj/demo/StateDemo_Rng.java

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,13 @@ public abstract class RNG {`
`10`	`10`	`public abstract P2<RNG, Long> nextLong();`
`11`	`11`
`12`	`12`	`public P2<RNG, Integer> range(int low, int high) {`
`13`		`- return nextInt().map2(x -> (Math.abs(x) % (high - low + 1)) + low);`
	`13`	`+ return nextNatural().map2(x -> (x % (high - low + 1)) + low);`
`14`	`14`	`}`
`15`	`15`
	`16`	`+`
	`17`	`+ public P2<RNG, Integer> nextNatural() {`
	`18`	`+ return nextInt().map2(x -> x < 0 ? -(x + 1) : x);`
	`19`	`+ }`
	`20`	`+`
	`21`	`+`
`16`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,8 @@ public P2<RNG, Integer> nextInt() {`
`23`	`23`	`return P.p(p._1(), i);`
`24`	`24`	`}`
`25`	`25`
`26`		`- public P2<RNG, Long> nextLong() {`
	`26`	`+`
	`27`	`+ public P2<RNG, Long> nextLong() {`
`27`	`28`	`P2<Long, Long> p = nextLong(seed);`
`28`	`29`	`return P.p(new SimpleRNG(p._1()), p._2());`
`29`	`30`	`}`