Add wrapper for SortedMap

kategory-core/src/main/kotlin/kategory/data/SortedMapKW.kt

@@ -0,0 +1,78 @@
+package kategory
+
+import java.util.*
+
+@higherkind
+data class SortedMapKW<A: Comparable<A>, B>(val map: SortedMap<A, B>) : SortedMapKWKind<A, B>, SortedMap<A, B> by map {
+
+    fun <C> map(f: (B) -> C): SortedMapKW<A, C> =
+            this.map.map { it.key to f(it.value) }.toMap().toSortedMap().k()
+
+    fun <C, Z> map2(fc: SortedMapKW<A, C>, f: (B, C) -> Z): SortedMapKW<A, Z> =
+            if (fc.isEmpty()) sortedMapOf<A, Z>().k()
+            else this.map.flatMap { (a, b) ->
+                fc.getOption(a).map { Tuple2(a, f(b, it)) }.k().asIterable()
+            }.k()
+
+    fun <C, Z> map2Eval(fc: Eval<SortedMapKW<A, C>>, f: (B, C) -> Z): Eval<SortedMapKW<A, Z>> =
+            if (fc.isEmpty()) Eval.now(sortedMapOf<A, Z>().k())
+            else fc.map { c -> this.map2(c, f) }
+
+    fun <C> ap(ff: SortedMapKW<A, (B) -> C>): SortedMapKW<A, C> =
+            ff.flatMap { this.map(it) }
+
+    fun <C, Z> ap2(f: SortedMapKW<A, (B, C) -> Z>, fc: SortedMapKW<A, C>): SortedMap<A, Z> =
+            f.map.flatMap { (k, f) ->
+                this.flatMap { a -> fc.flatMap { c -> sortedMapOf(k to f(a, c)).k() } }
+                        .getOption(k).map { Tuple2(k, it) }.k().asIterable()
+            }.k()
+
+    fun <C> flatMap(f: (B) -> SortedMapKW<A, C>): SortedMapKW<A, C> =
+            this.map.flatMap { (k, v) ->
+                f(v).getOption(k).map { Tuple2(k, it) }.k().asIterable()
+            }.k()
+
+    fun <C> foldR(c: Eval<C>, f: (B, Eval<C>) -> Eval<C>): Eval<C> =
+            this.map.values.iterator().iterateRight(c)(f)
+
+    fun <C> foldL(c: C, f: (C, B) -> C): C = this.map.values.fold(c, f)
+
+    fun <C> foldLeft(c: SortedMapKW<A, C>, f: (SortedMapKW<A, C>, Tuple2<A, B>) -> SortedMapKW<A, C>): SortedMapKW<A, C> =
+            this.map.foldLeft(c) { m: SortedMap<A, C>, (a, b) -> f(m.k(), Tuple2(a, b)) }.k()
+
+    fun <G, C> traverse(f: (B) -> HK<G, C>, GA: Applicative<G>): HK<G, SortedMapKW<A, C>> =
+        Foldable.iterateRight(this.map.iterator(), Eval.always { GA.pure(sortedMapOf<A, C>().k()) })({
+            kv, lbuf ->
+            GA.map2Eval(f(kv.value), lbuf) { (mapOf(kv.key to it.a).k() + it.b).toSortedMap().k() }
+        }).value()
+
+    companion object
+}
+
+fun <A: Comparable<A>, B> SortedMap<A, B>.k(): SortedMapKW<A, B> = SortedMapKW(this)
+
+fun <A: Comparable<A>, B> Option<Tuple2<A, B>>.k(): SortedMapKW<A, B> = this.fold(
+        { sortedMapOf<A, B>().k() },
+        { mapEntry -> sortedMapOf<A, B>(mapEntry.a to mapEntry.b).k() }
+)
+
+fun <A: Comparable<A>, B> List<Map.Entry<A, B>>.k(): SortedMapKW<A, B> =
+        this.map { it.key to it.value }.toMap().toSortedMap().k()
+
+fun <A, B> SortedMap<A, B>.getOption(k: A): Option<B> = Option.fromNullable(this[k])
+
+fun <A: Comparable<A>, B> SortedMapKW<A, B>.updated(k: A, value: B): SortedMapKW<A, B> {
+    val sortedMutableMap = this.toSortedMap()
+    sortedMutableMap.put(k, value)
+
+    return sortedMutableMap.k()
+}
+
+fun <A, B, C> SortedMap<A, B>.foldLeft(b: SortedMap<A, C>, f: (SortedMap<A, C>, Map.Entry<A, B>) -> SortedMap<A, C>): SortedMap<A, C> {
+    var result = b
+    this.forEach { result = f(result, it) }
+    return result
+}
+
+fun <A: Comparable<A>, B, C> SortedMap<A, B>.foldRight(b: SortedMap<A, C>, f: (Map.Entry<A, B>, SortedMap<A, C>) -> SortedMap<A, C>): SortedMap<A, C> =
+        this.entries.reversed().k().map.foldLeft(b) { x: SortedMap<A, C>, y -> f(y, x) }

kategory-core/src/main/kotlin/kategory/instances/SortedMapKWInstances.kt

@@ -0,0 +1,38 @@
+package kategory
+
+@instance(SortedMapKW::class)
+interface SortedMapKWFunctorInstance<A: Comparable<A>> : Functor<SortedMapKWKindPartial<A>> {
+    override fun <B, C> map(fb: HK<SortedMapKWKindPartial<A>, B>, f: (B) -> C): SortedMapKW<A, C> =
+            fb.ev().map(f)
+}
+
+@instance(SortedMapKW::class)
+interface SortedMapKWFoldableInstance<A: Comparable<A>> : Foldable<SortedMapKWKindPartial<A>> {
+    override fun <B, C> foldL(fb: HK<SortedMapKWKindPartial<A>, B>, c: C, f: (C, B) -> C): C =
+            fb.ev().foldL(c, f)
+
+    override fun <B, C> foldR(fb: HK<SortedMapKWKindPartial<A>, B>, lc: Eval<C>, f: (B, Eval<C>) -> Eval<C>): Eval<C> =
+            fb.ev().foldR(lc, f)
+}
+
+@instance(SortedMapKW::class)
+interface SortedMapKWTraverseInstance<A: Comparable<A>> : SortedMapKWFoldableInstance<A>, Traverse<SortedMapKWKindPartial<A>> {
+    override fun <G, B, C> traverse(fb: HK<SortedMapKWKindPartial<A>, B>, f: (B) -> HK<G, C>, GA: Applicative<G>): HK<G, HK<SortedMapKWKindPartial<A>, C>> =
+            fb.ev().traverse(f, GA)
+}
+
+@instance(SortedMapKW::class)
+interface SortedMapKWSemigroupInstance<A: Comparable<A>, B> : Semigroup<SortedMapKWKind<A, B>> {
+    fun SG(): Semigroup<B>
+
+    override fun combine(a: SortedMapKWKind<A, B>, b: SortedMapKWKind<A, B>): SortedMapKWKind<A, B> =
+            if (a.ev().size < b.ev().size) a.ev().foldLeft<B> (b.ev(), { my, (k, b) ->
+                my.updated(k, SG().maybeCombine(b, my[k]))
+            })
+            else b.ev().foldLeft<B> (a.ev(), { my: SortedMapKW<A, B>, (k, a) -> my.updated(k, SG().maybeCombine(a, my[k])) })
+}
+
+@instance(SortedMapKW::class)
+interface SortedMapKWMonoidInstance<A: Comparable<A>, B> : SortedMapKWSemigroupInstance<A, B>, Monoid<SortedMapKWKind<A, B>> {
+    override fun empty(): SortedMapKW<A, B> = sortedMapOf<A, B>().k()
+}

kategory-core/src/test/kotlin/kategory/data/SortedMapKWTest.kt

@@ -0,0 +1,43 @@
+package kategory
+
+import io.kotlintest.KTestJUnitRunner
+import io.kotlintest.matchers.shouldNotBe
+import io.kotlintest.properties.forAll
+import org.junit.runner.RunWith
+
+@RunWith(KTestJUnitRunner::class)
+class SortedMapKWTest : UnitSpec() {
+
+    val EQ: Eq<HK2<SortedMapKWHK, String, Int>> = object : Eq<HK2<SortedMapKWHK, String, Int>> {
+        override fun eqv(a: HK2<SortedMapKWHK, String, Int>, b: HK2<SortedMapKWHK, String, Int>): Boolean =
+            a.ev().get("key") == b.ev().get("key")
+    }
+
+    init {
+
+        "instances can be resolved implicitly" {
+            functor<SortedMapKWHK>() shouldNotBe null
+            foldable<SortedMapKWHK>() shouldNotBe null
+            traverse<SortedMapKWHK>() shouldNotBe null
+            semigroup<SortedMapKWKind<String, Int>>() shouldNotBe null
+            monoid<SortedMapKWKind<String, Int>>() shouldNotBe null
+        }
+
+
+        testLaws(
+                MonoidLaws.laws(SortedMapKW.monoid<String, Int>(), sortedMapOf("key" to 1).k(), EQ),
+                SemigroupLaws.laws(SortedMapKW.monoid<String, Int>(),
+                    sortedMapOf("key" to 1).k(),
+                    sortedMapOf("key" to 2).k(),
+                    sortedMapOf("key" to 3).k(),
+                    EQ),
+                TraverseLaws.laws(
+                    SortedMapKW.traverse<String>(),
+                    SortedMapKW.traverse<String>(),
+                    { a: Int -> sortedMapOf("key" to a).k() },
+                    EQ))
+
+    }
+
+
+}

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

@@ -0,0 +1,17 @@
+package kategory
+
+object MonoidLaws {
+
+    inline fun <reified F> laws(M: Monoid<F>, A: F, EQ: Eq<F>): List<Law> =
+            listOf(
+                    Law("Monoid Laws: Left identity", { monoidLeftIdentity(M, A, EQ) }),
+                    Law("Monoid Laws: Right identity", { monoidRightIdentity(M, A, EQ) })
+            )
+
+    inline fun <reified F> monoidLeftIdentity(M: Monoid<F>, A: F, EQ: Eq<F>): Boolean =
+            M.combine(M.empty(), A).equalUnderTheLaw(A, EQ)
+
+    inline fun <reified F> monoidRightIdentity(M: Monoid<F>, A: F, EQ: Eq<F>): Boolean =
+            M.combine(A, M.empty()).equalUnderTheLaw(A, EQ)
+
+}

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

@@ -0,0 +1,11 @@
+package kategory
+
+object SemigroupLaws {
+
+    inline fun <reified F> laws(SG: Semigroup<F>, A: F, B: F, C:F, EQ: Eq<F>): List<Law> =
+            listOf(Law("Semigroup: associativity", { semigroupAssociative(SG, A, B, C, EQ) }))
+
+    inline fun <reified F> semigroupAssociative(SG: Semigroup<F>, A: F, B: F, C: F, EQ: Eq<F>): Boolean =
+            SG.combine(SG.combine(A, B), C).equalUnderTheLaw(SG.combine(A, SG.combine(B, C)), EQ)
+
+}