Add Semiring type class

modules/core/arrow-core-data/src/test/kotlin/arrow/extensions/NumberSemiringTest.kt

@@ -0,0 +1,25 @@
+package arrow.extensions
+
+import arrow.core.extensions.semiring
+import arrow.test.UnitSpec
+import arrow.test.laws.SemiringLaws
+import io.kotlintest.runner.junit4.KotlinTestRunner
+import org.junit.runner.RunWith
+
+@RunWith(KotlinTestRunner::class)
+class NumberSemiringTest : UnitSpec() {
+
+    companion object {
+        private const val A = 2
+        private const val B = 3
+        private const val C = 4
+    }
+
+    init {
+        testLaws(SemiringLaws.laws(Byte.semiring(), A.toByte(), B.toByte(), C.toByte()))
+        testLaws(SemiringLaws.laws(Double.semiring(), A.toDouble(), B.toDouble(), C.toDouble()))
+        testLaws(SemiringLaws.laws(Int.semiring(), A, B, C))
+        testLaws(SemiringLaws.laws(Short.semiring(), A.toShort(), B.toShort(), C.toShort()))
+        testLaws(SemiringLaws.laws(Float.semiring(), A.toFloat(), B.toFloat(), C.toFloat()))
+    }
+}

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/number.kt

@@ -13,6 +13,14 @@ interface ByteMonoid: Monoid<Byte>, ByteSemigroup {
   override fun empty(): Byte = 0
 }
 
+interface ByteSemiring: Semiring<Byte> {
+    override fun zero(): Byte = 0
+    override fun one(): Byte = 1
+
+    override fun Byte.combine(b: Byte): Byte = (this + b).toByte()
+    override fun Byte.combineMultiplicate(b: Byte): Byte = (this * b).toByte()
+}
+
 interface ByteOrder : Order<Byte> {
   override fun Byte.compare(b: Byte): Int = compareTo(b)
 }
@@ -47,6 +55,9 @@ fun Byte.Companion.semigroup(): Semigroup<Byte> =
 fun Byte.Companion.monoid(): Monoid<Byte> =
   object : ByteMonoid{}
 
+fun Byte.Companion.semiring(): Semiring<Byte> =
+  object : ByteSemiring{}
+
 //////////
 // Double
 //////////
@@ -59,6 +70,14 @@ interface DoubleMonoid: Monoid<Double>, DoubleSemigroup {
   override fun empty(): Double = .0
 }
 
+interface DoubleSemiring: Semiring<Double> {
+  override fun zero(): Double = .0
+  override fun one(): Double = 1.0
+
+  override fun Double.combine(b: Double): Double = this + b
+  override fun Double.combineMultiplicate(b: Double): Double = this * b
+}
+
 interface DoubleOrder : Order<Double> {
   override fun Double.compare(b: Double): Int = compareTo(b)
 }
@@ -93,6 +112,9 @@ fun Double.Companion.semigroup(): Semigroup<Double> =
 fun Double.Companion.monoid(): Monoid<Double> =
   object : DoubleMonoid{}
 
+fun Double.Companion.semiring(): Semiring<Double> =
+  object : DoubleSemiring{}
+
 //////////
 // Int
 //////////
@@ -104,6 +126,14 @@ interface IntMonoid: Monoid<Int>, IntSemigroup {
   override fun empty(): Int = 0
 }
 
+interface IntSemiring: Semiring<Int> {
+    override fun zero(): Int = 0
+    override fun one(): Int = 1
+
+    override fun Int.combine(b: Int): Int = this + b
+    override fun Int.combineMultiplicate(b: Int): Int = this * b
+}
+
 interface IntEq : Eq<Int> {
   override fun Int.eqv(b: Int): Boolean = this == b
 }
@@ -138,6 +168,9 @@ fun Int.Companion.semigroup(): Semigroup<Int> =
 fun Int.Companion.monoid(): Monoid<Int> =
   object : IntMonoid{}
 
+fun Int.Companion.semiring(): Semiring<Int> =
+  object : IntSemiring{}
+
 //////////
 // Long
 //////////
@@ -150,6 +183,14 @@ interface LongMonoid: Monoid<Long>, LongSemigroup {
   override fun empty(): Long = 0L
 }
 
+interface LongSemiring: Semiring<Long> {
+    override fun zero(): Long = 0
+    override fun one(): Long = 1
+
+    override fun Long.combine(b: Long): Long = this + b
+    override fun Long.combineMultiplicate(b: Long): Long = this * b
+}
+
 interface LongOrder : Order<Long> {
   override fun Long.compare(b: Long): Int = compareTo(b)
 }
@@ -184,6 +225,9 @@ fun Long.Companion.semigroup(): Semigroup<Long> =
 fun Long.Companion.monoid(): Monoid<Long> =
   object : LongMonoid{}
 
+fun Long.Companion.semiring(): Semiring<Long> =
+  object : LongSemiring{}
+
 //////////
 // Short
 //////////
@@ -196,6 +240,14 @@ interface ShortMonoid: Monoid<Short>, ShortSemigroup {
   override fun empty(): Short = 0
 }
 
+interface ShortSemiring: Semiring<Short> {
+    override fun zero(): Short = 0
+    override fun one(): Short = 1
+
+    override fun Short.combine(b: Short): Short = (this + b).toShort()
+    override fun Short.combineMultiplicate(b: Short): Short = (this * b).toShort()
+}
+
 interface ShortOrder : Order<Short> {
   override fun Short.compare(b: Short): Int = compareTo(b)
 }
@@ -230,6 +282,9 @@ fun Short.Companion.semigroup(): Semigroup<Short> =
 fun Short.Companion.monoid(): Monoid<Short> =
   object : ShortMonoid{}
 
+fun Short.Companion.semiring(): Semiring<Short> =
+  object : ShortSemiring{}
+
 //////////
 // Float
 //////////
@@ -242,6 +297,14 @@ interface FloatMonoid: Monoid<Float>, FloatSemigroup {
   override fun empty(): Float = 0f
 }
 
+interface FloatSemiring: Semiring<Float> {
+    override fun zero(): Float = 0f
+    override fun one(): Float = 1f
+
+    override fun Float.combine(b: Float): Float = this + b
+    override fun Float.combineMultiplicate(b: Float): Float = this * b
+}
+
 interface FloatOrder : Order<Float> {
   override fun Float.compare(b: Float): Int = compareTo(b)
 }
@@ -275,3 +338,6 @@ fun Float.Companion.semigroup(): Semigroup<Float> =
 
 fun Float.Companion.monoid(): Monoid<Float> =
   object : FloatMonoid{}
+
+fun Float.Companion.semiring(): Semiring<Float> =
+  object : FloatSemiring{}

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/option.kt

@@ -31,6 +31,32 @@ interface OptionMonoid<A> : Monoid<Option<A>>, OptionSemigroup<A> {
   override fun empty(): Option<A> = None
 }
 
+@extension
+interface OptionSemiring<A> : Semiring<Option<A>> {
+
+  fun SG(): Semiring<A>
+  override fun zero(): Option<A> = None
+  override fun one(): Option<A> = None
+
+  override fun Option<A>.combine(b: Option<A>): Option<A> =
+          when (this) {
+            is Some<A> -> when (b) {
+              is Some<A> -> Some(SG().run { t.combine(b.t) })
+              None -> this
+            }
+            None -> b
+          }
+
+  override fun Option<A>.combineMultiplicate(b: Option<A>): Option<A> =
+          when (this) {
+            is Some<A> -> when (b) {
+              is Some<A> -> Some(SG().run { t.combineMultiplicate(b.t) })
+              None -> this
+            }
+            None -> b
+          }
+}
+
 @extension
 interface OptionApplicativeError: ApplicativeError<ForOption, Unit>, OptionApplicative {
   override fun <A> raiseError(e: Unit): Option<A> =

modules/core/arrow-test/src/main/kotlin/arrow/test/laws/SemiringLaws.kt

@@ -0,0 +1,44 @@
+package arrow.test.laws
+
+import arrow.typeclasses.Semiring
+import io.kotlintest.shouldBe
+
+object SemiringLaws {
+
+    fun <F> laws(SG: Semiring<F>, A: F, B: F, C: F): List<Law> =
+            listOf(
+                    Law("Semiring: Additive commutativity") { SG.semiringAdditiveCommutativity(A, B) },
+                    Law("Semiring: Multiplicative commutativity") { SG.semiringMultiplicativeCommutativity(A, B) },
+                    Law("Semiring: Right distributivity") { SG.semiringRightDistributivity(A, B, C) },
+                    Law("Semiring: Left distributivity") { SG.semiringLeftDistributivity(A, B, C) },
+                    Law("Semiring: Multiplicative left identity") { SG.semiringMultiplicativeLeftIdentity(A, C) },
+                    Law("Semiring: Multiplicative right identity") { SG.semiringMultiplicativeRightIdentity(A) },
+                    Law("Semiring: Multiplicative left absorption") { SG.semiringMultiplicativeLeftAbsorption(A, C) },
+                    Law("Semiring: Multiplicative right absorption") { SG.semiringMultiplicativeRightAbsorption(A, C) }
+            )
+
+    fun <F> Semiring<F>.semiringAdditiveCommutativity(A: F, B: F) =
+            A.combine(B).shouldBe(B.combine(A))
+
+    fun <F> Semiring<F>.semiringMultiplicativeCommutativity(A: F, B: F) =
+            A.combineMultiplicate(B).shouldBe(B.combineMultiplicate(A))
+
+    fun <F> Semiring<F>.semiringRightDistributivity(A: F, B: F, C: F) =
+            (A.combine(B)).combineMultiplicate(C).shouldBe((A.combineMultiplicate(C)).combine(B.combineMultiplicate(C)))
+
+    fun <F> Semiring<F>.semiringLeftDistributivity(A: F, B: F, C: F) =
+            A.combine(B.combineMultiplicate(C)).shouldBe((A.combineMultiplicate(B)).combine(A.combineMultiplicate(C)))
+
+    fun <F> Semiring<F>.semiringMultiplicativeLeftIdentity(A: F, C: F) =
+            (one().combineMultiplicate(A)).shouldBe(A)
+
+    fun <F> Semiring<F>.semiringMultiplicativeRightIdentity(A: F) =
+            A.combineMultiplicate(one()).shouldBe(A)
+
+    fun <F> Semiring<F>.semiringMultiplicativeLeftAbsorption(A: F, C: F) =
+            (zero().combineMultiplicate(A)).shouldBe(zero())
+
+    fun <F> Semiring<F>.semiringMultiplicativeRightAbsorption(A: F, C: F) =
+            A.combineMultiplicate(zero()).shouldBe(zero())
+
+}

modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Semiring.kt

@@ -0,0 +1,35 @@
+package arrow.typeclasses
+
+import arrow.core.Option
+
+/**
+ * ank_macro_hierarchy(arrow.typeclasses.Semiring)
+ */
+interface Semiring<A> : Monoid<A> {
+
+    /**
+     * A zero value for this A
+     */
+    fun zero(): A
+
+    /**
+     * A one value for this A
+     */
+    fun one(): A
+
+    /**
+     * Multiplicatively combine two [A] values.
+     */
+    fun A.combineMultiplicate(b: A): A
+
+    override fun empty(): A = one()
+
+    operator fun A.times(b: A): A =
+            this.combineMultiplicate(b)
+
+    /**
+     * Maybe multiplicatively combine two [A] values.
+     */
+    fun A.maybeCombineMultiplicate(b: A?): A =
+            Option.fromNullable(b).fold({ this }, { combineMultiplicate(it) })
+}

modules/docs/arrow-docs/docs/_data/sidebar.yml

@@ -236,6 +236,9 @@ options:
       - title: Monoid
         url: /docs/arrow/typeclasses/monoid/
 
+      - title: Semiring
+        url: /docs/arrow/typeclasses/semiring/
+
       - title: Foldable
         url: /docs/arrow/typeclasses/foldable/