Merge pull request #428 from kategory/simon-semigroup-fix

Semigroup cannot combineAll

Author: nomisRev

kategory-core/src/main/kotlin/kategory/typeclasses/Monoid.kt

@@ -6,8 +6,21 @@ interface Monoid<A> : Semigroup<A>, Typeclass {
      */
     fun empty(): A
 
+    /**
+     * Combine an array of [A] values.
+     */
+    fun combineAll(vararg elems: A): A = combineAll(elems.asList())
+
+    /**
+     * Combine a collection of [A] values.
+     */
+    fun combineAll(elems: Collection<A>): A =
+            if (elems.isEmpty()) empty() else elems.reduce { a, b -> combine(a, b) }
+
 }
 
 inline fun <reified A> A.empty(FT: Monoid<A> = monoid()): A = FT.empty()
 
+inline fun <reified A> Collection<A>.combineAll(FT: Monoid<A> = monoid()): A = FT.combineAll(this)
+
 inline fun <reified A> monoid(): Monoid<A> = instance(InstanceParametrizedType(Monoid::class.java, listOf(typeLiteral<A>())))

kategory-core/src/main/kotlin/kategory/typeclasses/Semigroup.kt

@@ -8,19 +8,8 @@ interface Semigroup<A> : Typeclass {
 
     fun maybeCombine(a: A, b: A?): A = Option.fromNullable(b).fold({ a }, { this.combine(a, it) })
 
-    /**
-     * Combine an array of [A] values.
-     */
-    fun combineAll(vararg elems: A): A = combineAll(elems.asList())
-
-    /**
-     * Combine a collection of [A] values.
-     */
-    fun combineAll(elems: Collection<A>): A = elems.reduce { a, b -> combine(a, b) }
 }
 
-inline fun <reified A> A.combine(FT: Semigroup<A> = semigroup(), b: A): A = FT.combine(this, b)
-
-inline fun <reified A> Collection<A>.combineAll(FT: Semigroup<A> = semigroup()): A = FT.combineAll(this)
+inline fun <reified A> A.combine(b: A, FT: Semigroup<A> = semigroup()): A = FT.combine(this, b)
 
 inline fun <reified A> semigroup(): Semigroup<A> = instance(InstanceParametrizedType(Semigroup::class.java, listOf(typeLiteral<A>())))

kategory-core/src/test/kotlin/kategory/typeclass/MonoidTest.kt

@@ -0,0 +1,22 @@
+package kategory.typeclass
+
+import io.kotlintest.KTestJUnitRunner
+import io.kotlintest.properties.forAll
+import kategory.UnitSpec
+import kategory.combineAll
+import org.junit.runner.RunWith
+
+@RunWith(KTestJUnitRunner::class)
+class MonoidTest : UnitSpec() {
+
+    init {
+
+        "Combining all for a list of ints should be same as sum" {
+            forAll({ ints: List<Int> ->
+                ints.combineAll() == ints.sum()
+            })
+        }
+
+    }
+
+}

kategory-docs/docs/docs/typeclasses/monoid/README.md

@@ -31,6 +31,10 @@ StringMonoid.empty()
 listOf("K", "Λ", "T", "E", "G", "O", "R", "Y").combineAll()
 ```
 
+```kotlin:ank
+listOf<Option<Int>>(Option.Some(1), Option.Some(1)).combineAll()
+```
+
 The advantage of using these type class provided methods, rather than the specific ones for each type, is that we can compose monoids to allow us to operate on more complex types, e.g.
 
 This is also true if we define our own instances. As an example, let's use `Foldable`'s `foldMap`, which maps over values accumulating the results, using the available `Monoid` for the type mapped onto.
@@ -57,7 +61,7 @@ To use this with a function that produces a tuple, we can define a Monoid for a
 fun <A, B> monoidTuple(MA: Monoid<A>, MB: Monoid<B>): Monoid<Tuple2<A, B>> =
   object: Monoid<Tuple2<A, B>> {
     override fun combine(x: Tuple2<A, B>, y: Tuple2<A, B>): Tuple2<A, B> {
-      println("monoitTuple#combine receiving ---> x: $x, y: $y")
+      println("monoidTuple#combine receiving ---> x: $x, y: $y")
       val (xa, xb) = x
       val (ya, yb) = y
       return Tuple2(MA.combine(xa, ya), MB.combine(xb, yb))

kategory-docs/docs/docs/typeclasses/semigroup/README.md

@@ -49,18 +49,4 @@ Option.monoid<Int>().combine(Option(1), Option.None)
 
 Many of these types have methods defined directly on them, which allow for such combining, e.g. `+` on `List`, but the value of having a `Semigroup` typeclass available is that these compose.
 
-There is also extension syntax available for Semigroup.
-
-```kotlin:ank
-listOf(Option(1), Option(2)).combineAll(Option.semigroup<Int>())
-```
-
-```kotlin:ank
-listOf(1, 2, 3).combineAll()
-```
-
-```kotlin:ank
-listOf("K", "Λ", "T", "E", "G", "O", "R", "Y").combineAll()
-```
-
 Contents partially adapted from [Scala Exercises Cat's Semigroup Tutorial](https://www.scala-exercises.org/cats/semigroup)

kategory-test/src/main/kotlin/kategory/laws/TraversalLaws.kt

@@ -31,7 +31,8 @@ object TraversalLaws {
             forAll(aGen, funcGen, { a, f ->
                 traversal.getAll(traversal.modify(a, f))
                         .zip(traversal.getAll(a).map(f), { b1, b2 -> EQB.eqv(b1, b2) })
-                        .combineAll(object : Semigroup<Boolean> {
+                        .combineAll(object : Monoid<Boolean> {
+                            override fun empty(): Boolean = true
                             override fun combine(a: Boolean, b: Boolean): Boolean = a && b
                         })
             })