Implemented Equal, Hash, Arbitrary, and Shrink for Natural as well as the equals, hashCode and toString methods on Natural. Also fixed the subtract method on Natural as well as the Javadoc on the Natural Semigroup for addition.

bakeemawaytoys · jbgi · commit 09b6713407a2 · 2016-06-15T21:38:10.000+02:00
diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
@@ -149,6 +149,11 @@ public static <A> Equal<A> anyEqual() {
    */
   public static final Equal<Short> shortEqual = anyEqual();
 
+  /**
+   * An equal instance for the <code>Natural</code> type.
+   */
+  public static final Equal<Natural> naturalEqual = bigintEqual.contramap(Natural::bigIntegerValue);
+
   /**
    * An equal instance for the {@link String} type.
    */
diff --git a/core/src/main/java/fj/Hash.java b/core/src/main/java/fj/Hash.java
@@ -115,6 +115,11 @@ public static <A> Hash<A> anyHash() {
    */
   public static final Hash<BigDecimal> bigdecimalHash = anyHash();
 
+  /**
+   * A hash instance for the {@link Natural} type.
+   */
+  public static final Hash<Natural> naturalHash = bigintHash.contramap(Natural::bigIntegerValue);
+
   /**
    * A hash instance for the <code>String</code> type.
    */
@@ -535,4 +540,5 @@ public static <A> Hash<V7<A>> v7Hash(final Hash<A> ea) {
   public static <A> Hash<V8<A>> v8Hash(final Hash<A> ea) {
     return streamHash(ea).contramap(V8.toStream_());
   }
+
 }
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
@@ -219,7 +219,7 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
       semigroup(Natural::multiply);
 
   /**
-   * A semigroup that multiplies natural numbers.
+   * A semigroup that adds natural numbers.
    */
   public static final Semigroup<Natural> naturalAdditionSemigroup =
       semigroup(Natural::add);
diff --git a/core/src/main/java/fj/data/Natural.java b/core/src/main/java/fj/data/Natural.java
@@ -1,11 +1,16 @@
 package fj.data;
 
 import static fj.Bottom.error;
+
+import fj.Equal;
 import fj.F;
 
 import static fj.Monoid.naturalAdditionMonoid;
 import static fj.Monoid.naturalMultiplicationMonoid;
 import static fj.Function.curry;
+
+import fj.Hash;
+import fj.Show;
 import fj.data.vector.V2;
 import fj.data.vector.V;
 
@@ -121,7 +126,7 @@ public Natural add(final Natural n) {
    * @return The difference between the two numbers, if this number is larger than the given one. Otherwise none.
    */
   public Option<Natural> subtract(final Natural n) {
-    return natural(n.value.subtract(value));
+    return natural(value.subtract(n.value));
   }
 
   /**
@@ -286,4 +291,20 @@ public static Natural sum(final List<Natural> ns) {
   public static Natural product(final List<Natural> ns) {
     return naturalMultiplicationMonoid.sumLeft(ns);
   }
+
+
+  @Override
+  public int hashCode() {
+    return Hash.naturalHash.hash(this);
+  }
+
+  @Override
+  public boolean equals(final Object that) {
+    return Equal.equals0(Natural.class, this, that, Equal.naturalEqual);
+  }
+
+  @Override
+  public String toString() {
+    return Show.naturalShow.showS(this);
+  }
 }
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -1,6 +1,8 @@
 package fj.test;
 
+import fj.Equal;
 import fj.F;
+import fj.F1Functions;
 import fj.F2;
 import fj.F3;
 import fj.F4;
@@ -11,6 +13,7 @@
 import fj.Function;
 import fj.Bottom;
 
+import static fj.Equal.longEqual;
 import static fj.Function.compose;
 import static fj.P.p;
 
@@ -37,9 +40,12 @@
 import fj.data.List;
 import fj.data.Set;
 import fj.data.TreeMap;
+import fj.function.Booleans;
 import fj.function.Effect1;
+import fj.function.Longs;
 
 import static fj.data.Stream.range;
+import static fj.function.Booleans.not;
 import static fj.test.Gen.choose;
 import static fj.test.Gen.elements;
 import static fj.test.Gen.fail;
@@ -469,6 +475,12 @@ public Gen<Short> f(final Integer i) {
     }
   });
 
+  /**
+   * An arbitrary implementation for naturals.
+   */
+  public static final Gen<Natural> arbNatural = arbLong.filter(not(longEqual.eq(Long.MIN_VALUE)))
+      .map(Longs.abs).map(Natural::natural).map(o -> o.some());
+
   /**
    * An arbitrary implementation for character values.
    */
@@ -760,7 +772,7 @@ public static <A> Gen<ArrayList<A>> arbArrayList(final Gen<A> aa) {
   /**
    * Returns an arbitrary implementation for a Java enumeration.
    *
-   * @param clazz The type of enum to return an arbtrary of.
+   * @param clazz The type of enum to return an arbitrary of.
    * @return An arbitrary for instances of the supplied enum type.
    */
   public static <A extends Enum<A>> Gen<A> arbEnumValue(final Class<A> clazz) {
@@ -1337,4 +1349,5 @@ public static <A, B, C, D, E> Gen<P5<A, B, C, D, E>> arbP5(final Gen<A> aa, fina
     return aa.bind(ab, ac, ad, ae, af, ag, ah,
         a -> b -> c -> d -> e -> f -> g -> h -> p(a, b, c, d, e, f, g, h));
   }
+
 }
diff --git a/quickcheck/src/main/java/fj/test/Shrink.java b/quickcheck/src/main/java/fj/test/Shrink.java
@@ -30,6 +30,7 @@
 import fj.data.Either;
 import fj.data.Java;
 import fj.data.List;
+import fj.data.Natural;
 import fj.data.Option;
 import fj.data.Stream;
 
@@ -181,6 +182,11 @@ public static <A> Shrink<A> empty() {
    */
   public static final Shrink<Double> shrinkDouble = shrinkLong.map(Long_Double, Double_Long);
 
+  /**
+   * A shrink strategy for naturals.
+   */
+  public static final Shrink<Natural> shrinkNatural = shrinkLong.map(l -> Natural.natural(l).orSome(Natural.ZERO), Natural::longValue);
+
   /**
    * Returns a shrink strategy for optional values. A 'no value' is already fully
    * shrunk, otherwise, the shrinking occurs on the value with the given shrink strategy.
@@ -846,4 +852,5 @@ public static <A, B, C, D, E> Shrink<P5<A, B, C, D, E>> shrinkP5(final Shrink<A>
                           sg.shrink(p._7()), sh.shrink(p._8()), p8);
             });
   }
+
 }
