Add Each instances for java_util

arrow-kt · Feb 9, 2018 · 1b7aa81 · 1b7aa81
1 parent cc4039d
commit 1b7aa81
Show file tree

Hide file tree

Showing 2 changed files with 63 additions and 0 deletions.
diff --git a/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/EachInstancesJavaUtil.kt b/modules/optics/arrow-optics/src/main/kotlin/arrow/optics/instances/EachInstancesJavaUtil.kt
@@ -0,0 +1,44 @@
+package java_util
+
+import arrow.Kind
+import arrow.data.ListK
+import arrow.data.MapK
+import arrow.data.extract
+import arrow.data.k
+import arrow.data.traverse
+import arrow.optics.Traversal
+import arrow.optics.typeclasses.Each
+import arrow.typeclasses.Applicative
+
+interface ListEachInstance<A> : Each<List<A>, A> {
+    override fun each() = object : Traversal<List<A>, A> {
+        override fun <F> modifyF(FA: Applicative<F>, s: List<A>, f: (A) -> Kind<F, A>): Kind<F, List<A>> =
+                ListK.traverse().traverse(s.k(), f, FA).let {
+                    FA.map(it) {
+                        it.list
+                    }
+                }
+    }
+}
+
+object ListEachInstanceImplicits {
+    @JvmStatic
+    fun <A> instance(): Each<List<A>, A> = object : ListEachInstance<A> {}
+}
+
+interface MapKEachInstance<K, V> : Each<Map<K, V>, V> {
+    override fun each() = object : Traversal<Map<K, V>, V> {
+        override fun <F> modifyF(FA: Applicative<F>, s: Map<K, V>, f: (V) -> Kind<F, V>): Kind<F, Map<K, V>> =
+            MapK.traverse<K>().traverse(s.k(), f, FA).let {
+                FA.map(it) {
+                    it.extract().map
+                }
+            }
+
+    }
+}
+
+object MapEachInstanceImplicits {
+    @JvmStatic
+    fun <K, V> instance(): Each<Map<K, V>, V> = object : MapKEachInstance<K, V> {}
+}
diff --git a/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/instances/EachInstanceTest.kt b/modules/optics/arrow-optics/src/test/kotlin/arrow/optics/instances/EachInstanceTest.kt
@@ -15,6 +15,7 @@ import arrow.test.generators.genMapK
 import arrow.test.generators.genOption
 import arrow.test.generators.genTry
 import arrow.test.laws.TraversalLaws
+import arrow.typeclasses.Eq
 import io.kotlintest.KTestJUnitRunner
 import io.kotlintest.matchers.shouldNotBe
 import io.kotlintest.properties.Gen
@@ -27,7 +28,9 @@ class EachInstanceTest : UnitSpec() {
         "instances can be resolved implicitly" {
             each<EitherPartialOf<String>, String>() shouldNotBe null
             each<ListK<String>, String>() shouldNotBe null
+            each<List<String>, String>() shouldNotBe null
             each<MapK<Int, String>, String>() shouldNotBe null
+            each<Map<Int, String>, String>() shouldNotBe null
             each<Option<String>, String>() shouldNotBe null
             each<Try<String>, String>() shouldNotBe null
         }
@@ -46,13 +49,29 @@ class EachInstanceTest : UnitSpec() {
                 funcGen = genFunctionAToB(Gen.string())
         ))
 
+        testLaws(TraversalLaws.laws(
+                traversal = each<List<String>, String>().each(),
+                aGen = Gen.list(Gen.string()),
+                bGen = Gen.string(),
+                funcGen = genFunctionAToB(Gen.string()),
+                EQA = Eq.any()
+        ))
+
         testLaws(TraversalLaws.laws(
                 traversal = each<MapK<Int, String>, String>().each(),
                 aGen = genMapK(Gen.int(), Gen.string()),
                 bGen = Gen.string(),
                 funcGen = genFunctionAToB(Gen.string())
         ))
 
+        testLaws(TraversalLaws.laws(
+                traversal = each<Map<Int, String>, String>().each(),
+                aGen = Gen.map(Gen.int(), Gen.string()),
+                bGen = Gen.string(),
+                funcGen = genFunctionAToB(Gen.string()),
+                EQA = Eq.any()
+        ))
+
         testLaws(TraversalLaws.laws(
                 traversal = each<Option<String>, String>().each(),
                 aGen = genOption(Gen.string()),