From 7b1a783b749ab04ab8219ef28f9b1abb0ded6ca4 Mon Sep 17 00:00:00 2001
From: Carlo Zancanaro <carlo@zancanaro.id.au>
Date: Wed, 3 Jun 2015 14:32:07 +1000
Subject: Rename RoseTree to ShrinkTree (less confusing and more specific)

---
 .../java/au/id/zancanaro/javacheck/Generator.java  | 24 +++++++++++-----------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'src/main/java/au/id/zancanaro/javacheck/Generator.java')

diff --git a/src/main/java/au/id/zancanaro/javacheck/Generator.java b/src/main/java/au/id/zancanaro/javacheck/Generator.java
index 557cf97..9d88020 100644
--- a/src/main/java/au/id/zancanaro/javacheck/Generator.java
+++ b/src/main/java/au/id/zancanaro/javacheck/Generator.java
@@ -10,7 +10,7 @@ import java.util.function.Function;
  * trees in a controlled and deterministic way.
  *
  * A generator must implement one method: {@link #generate(Random, int)}. The
- * {@link RoseTree} it produces defines both the value to be returned, as well
+ * {@link ShrinkTree} it produces defines both the value to be returned, as well
  * as the shrink tree for that value.
  *
  * Generators form a "monad", and hence have the {@link #map(Function)} and
@@ -23,7 +23,7 @@ import java.util.function.Function;
 @SuppressWarnings("unused")
 public interface Generator<T> {
     /**
-     * Return a {@link RoseTree} containing a new random value of the required
+     * Return a {@link ShrinkTree} containing a new random value of the required
      * type, as well as its associated shrink tree.
      *
      * Generators also have an abstract notion of "size". Represented by an
@@ -33,10 +33,10 @@ public interface Generator<T> {
      *
      * @param random The random source for generation purposes
      * @param size   An integer specifying how "big" a thing to produce
-     * @return The {@link RoseTree} specifying the generated thing and its
+     * @return The {@link ShrinkTree} specifying the generated thing and its
      * shrink tree
      */
-    RoseTree<T> generate(Random random, int size);
+    ShrinkTree<T> generate(Random random, int size);
 
     /**
      * A generator which simply generates the provided value. Does not shrink.
@@ -46,7 +46,7 @@ public interface Generator<T> {
      * @return A {@link Generator} which generates the provided value
      */
     static <T> Generator<T> pure(T value) {
-        return (random, size) -> RoseTree.pure(value);
+        return (random, size) -> ShrinkTree.pure(value);
     }
 
     /**
@@ -66,12 +66,12 @@ public interface Generator<T> {
     static <T> Generator<List<T>> tuple(Generator<T>... generators) {
         return (random, size) -> {
             @SuppressWarnings("unchecked")
-            RoseTree<T>[] result = (RoseTree<T>[]) new RoseTree[generators.length];
+            ShrinkTree<T>[] result = (ShrinkTree<T>[]) new ShrinkTree[generators.length];
             int index = 0;
             for (Generator<T> generator : generators) {
                 result[index++] = generator.generate(random, size);
             }
-            return RoseTree.zip(Function.identity(), result);
+            return ShrinkTree.zip(Function.identity(), result);
         };
     }
 
@@ -81,8 +81,8 @@ public interface Generator<T> {
      *
      * Shrinking for this type involves attempting to remove terms and shrink
      * each subtree in turn, recursively. (If the length must remain fixed then
-     * the {@link RoseTree} produced by this generator should be filtered with
-     * {@link RoseTree#filter(java.util.function.Predicate)}.
+     * the {@link ShrinkTree} produced by this generator should be filtered with
+     * {@link ShrinkTree#filter(java.util.function.Predicate)}.
      *
      * @param count     The length of the list to generate
      * @param generator The generator to use for each term in the generated
@@ -93,11 +93,11 @@ public interface Generator<T> {
     static <T> Generator<List<T>> list(int count, Generator<T> generator) {
         return (random, size) -> {
             @SuppressWarnings("unchecked")
-            RoseTree<T>[] result = (RoseTree<T>[]) new RoseTree[count];
+            ShrinkTree<T>[] result = (ShrinkTree<T>[]) new ShrinkTree[count];
             for (int i = 0; i < count; ++i) {
                 result[i] = generator.generate(random, size);
             }
-            return RoseTree.shrink(Function.identity(), result);
+            return ShrinkTree.shrink(Function.identity(), result);
         };
     }
 
@@ -127,7 +127,7 @@ public interface Generator<T> {
      * result of this
      */
     default <R> Generator<R> flatMap(Function<T, Generator<R>> action) {
-        return (random, size) -> RoseTree.join(this.generate(random, size).map(action).map(g -> g.generate(random, size)));
+        return (random, size) -> ShrinkTree.join(this.generate(random, size).map(action).map(g -> g.generate(random, size)));
     }
 
     default Iterator<T> sample(Random random, int maxSize) {
-- 
cgit v1.2.3