functionaljava · jbgi · Nov 3, 2019 · Oct 20, 2019 · Oct 20, 2019 · Oct 20, 2019
diff --git a/core/src/main/java/fj/Bounded.java b/core/src/main/java/fj/Bounded.java
@@ -0,0 +1,50 @@
+package fj;
+
+/**
+ * The Bounded class is used to name the upper and lower limits of a type.
+ * Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds.
+ */
+public final class Bounded<A> {
+
+    private final Definition<A> def;
+
+    /**
+     * Minimal definition of Bounded
+     */
+    public interface Definition<A> {
+        A min();
+
+        A max();
+    }
+
+    private Bounded(Definition<A> definition) {
+        this.def = definition;
+    }
+
+    public A min() {
+        return def.min();
+    }
+
+    public A max() {
+        return def.max();
+    }
+
+    public static <A> Bounded<A> boundedDef(Definition<A> def) {
+        return new Bounded<>(def);
+    }
+
+    public static <A> Bounded<A> bounded(A min, A max) {
+        return boundedDef(new Definition<A>() {
+            @Override
+            public A min() {
+                return min;
+            }
+
+            @Override
+            public A max() {
+                return max;
+            }
+        });
+    }
+
+}
diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
@@ -2,14 +2,7 @@
 
 import static fj.F1Functions.dimap;
 
-import fj.data.Array;
-import fj.data.DList;
-import fj.data.List;
-import fj.data.IO;
-import fj.data.Natural;
-import fj.data.Option;
-import fj.data.Set;
-import fj.data.Stream;
+import fj.data.*;
 
 import static fj.Function.*;
 import static fj.Semigroup.semigroupDef;
@@ -1090,7 +1083,7 @@ public Unit append(Unit a1, Unit a2) {
   });
 
   /**
-   * A monoid for sets.
+   * A union monoid for sets.
    *
    * @param o An order for set elements.
    * @return A monoid for sets whose elements have the given order.
@@ -1109,6 +1102,27 @@ public Set<A> append(Set<A> a1, Set<A> a2) {
     });
   }
 
+  /**
+   * A intersection monoid for sets.
+   *
+   * @param bounded A bound for all possible elements
+   * @param enumerator An enumerator for all possible elements
+   * @return A monoid for sets whose elements have the given order.
+   */
+  public static <A> Monoid<Set<A>> setIntersectionMonoid(final Bounded<A> bounded, final Enumerator<A> enumerator) {
+    return monoidDef(new Definition<Set<A>>() {
+      @Override
+      public Set<A> empty() {
+        return Set.iteratorSet(enumerator.order(), enumerator.toStream(bounded).iterator());
+      }
+
+      @Override
+      public Set<A> append(Set<A> a1, Set<A> a2) {
+        return a1.intersect(a2);
+      }
+    });
+  }
+
   /**
    * A monoid for the maximum of elements with ordering o.
    * @deprecated since 4.7. Use {@link Ord#maxMonoid(Object)}

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
@@ -621,12 +621,21 @@ public static <A> Semigroup<IO<A>> ioSemigroup(final Semigroup <A> sa) {
   public static final Semigroup<Unit> unitSemigroup = unitMonoid.semigroup();
 
   /**
-   * A semigroup for sets.
+   * A union semigroup for sets.
    *
    * @return a semigroup for sets.
    */
   public static <A> Semigroup<Set<A>> setSemigroup() {
     return semigroupDef(Set::union);
   }
 
+  /**
+   * A intersection semigroup for sets.
+   *
+   * @return a semigroup for sets.
+   */
+  public static <A> Semigroup<Set<A>> setIntersectionSemigroup() {
+    return semigroupDef(Set::intersect);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/Enumerator.java b/core/src/main/java/fj/data/Enumerator.java
@@ -1,16 +1,12 @@
 package fj.data;
 
-import fj.F;
+import fj.*;
 
 import static fj.Function.*;
 import static fj.data.Option.none;
 import static fj.data.Option.some;
 
-import fj.Function;
-import fj.Ord;
-
 import static fj.Ord.*;
-import fj.Ordering;
 import static fj.Ordering.*;
 
 import java.math.BigDecimal;
@@ -185,6 +181,18 @@ public Stream<A> toStream(final A a) {
     return Stream.fromFunction(this, id, a);
   }
 
+  /**
+   * Returns a stream of the values from this enumerator,
+   * starting at the min of given Bounded, ending at the max, counting up.
+   *
+   * @param bounded A value at which to begin the stream.
+   * @return a stream of the values from this enumerator, cut by bounded, counting up.
+   */
+  public Stream<A> toStream(final Bounded<A> bounded) {
+    final F<A, A> id = identity();
+    return Stream.fromFunction(this, id, bounded.min()).takeWhile(item -> order.isLessThanOrEqualTo(item, bounded.max()));
+  }
+
   /**
    * Create a new enumerator with the given minimum value.
    *

diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
@@ -1,6 +1,8 @@
 package fj;
 
+import fj.data.Enumerator;
 import fj.data.Option;
+import fj.data.Set;
 import fj.data.Stream;
 import org.junit.Test;
 
@@ -16,4 +18,41 @@ public void lifted_sum_of_two_numbers() {
     assertThat(optionMonoid.sum(some(3), some(5)), is(some(8)));
     assertThat(optionMonoid.sumLeft(Stream.arrayStream(some(3), some(5))), is(some(8)));
   }
+
+  @Test
+  public void intersection_monoid_test() {
+    Bounded<Integer> integersBounded = Bounded.bounded(0, 10);
+    Monoid<Set<Integer>> intersectionMonoid = Monoid.setIntersectionMonoid(integersBounded, Enumerator.intEnumerator);
+    Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
+    Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
+    Set<Integer> actual = intersectionMonoid.sum(first, second);
+    assertThat(actual, is(Set.set(Ord.intOrd, 3, 4)));
+  }
+
+  @Test
+  public void union_monoid_test() {
+    Monoid<Set<Integer>> unionMonoid = Monoid.setMonoid(Ord.intOrd);
+    Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
+    Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
+    Set<Integer> actual = unionMonoid.sum(first, second);
+    assertThat(actual, is(Set.set(Ord.intOrd, 1, 2, 3, 4, 5, 6)));
+  }
+
+  @Test
+  public void intersection_monoid_zero_test() {
+    Bounded<Integer> integersBounded = Bounded.bounded(0, 10);
+    Monoid<Set<Integer>> monoid = Monoid.setIntersectionMonoid(integersBounded, Enumerator.intEnumerator);
+    Set<Integer> set = Set.set(Ord.intOrd, 7, 8, 9, 10);
+    Set<Integer> zero = monoid.zero();
+    assertThat(monoid.sum(zero, set), is(set));
+  }
+
+  @Test
+  public void union_monoid_zero_test() {
+    Monoid<Set<Integer>> monoid = Monoid.setMonoid(Ord.intOrd);
+    Set<Integer> set = Set.set(Ord.intOrd, 1, 2, 3, 4);
+    Set<Integer> zero = monoid.zero();
+    assertThat(monoid.sum(zero, set), is(set));
+  }
+
 }
diff --git a/core/src/test/java/fj/SemigroupTest.java b/core/src/test/java/fj/SemigroupTest.java
@@ -0,0 +1,26 @@
+package fj;
+
+import fj.data.Set;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class SemigroupTest {
+
+    @Test
+    public void intersection_semigroup_test() {
+        Semigroup<Set<Integer>> intersectionSemigroup = Semigroup.setIntersectionSemigroup();
+        Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
+        Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
+        assertThat(intersectionSemigroup.sum(first, second), is(Set.set(Ord.intOrd, 3, 4)));
+    }
+
+    @Test
+    public void union_semigroup_test() {
+        Semigroup<Set<Integer>> unionSemigroup = Semigroup.setSemigroup();
+        Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
+        Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
+        assertThat(unionSemigroup.sum(first, second), is(Set.set(Ord.intOrd, 1, 2, 3, 4, 5, 6)));
+    }
+}