Optics based on kotlin.reflect

arrow-libs/optics/arrow-optics-reflect/build.gradle.kts

@@ -0,0 +1,32 @@
+plugins {
+  id(libs.plugins.kotlin.multiplatform.get().pluginId)
+  alias(libs.plugins.arrowGradleConfig.kotlin)
+  alias(libs.plugins.arrowGradleConfig.publish)
+}
+
+apply(plugin = "io.kotest.multiplatform")
+
+apply(from = property("TEST_COVERAGE"))
+apply(from = property("ANIMALSNIFFER_MPP"))
+
+kotlin {
+  sourceSets {
+    jvmMain {
+      dependencies {
+        api(projects.arrowCore)
+        api(projects.arrowOptics)
+        api(libs.kotlin.stdlibCommon)
+        implementation(libs.kotlin.stdlibJDK8)
+        api(libs.kotlin.reflect)
+      }
+    }
+    jvmTest {
+      dependencies {
+        implementation(projects.arrowOpticsTest)
+        implementation(libs.kotlin.stdlibJDK8)
+        implementation(libs.junitJupiterEngine)
+        implementation(libs.kotlin.reflect)
+      }
+    }
+  }
+}

arrow-libs/optics/arrow-optics-reflect/gradle.properties

@@ -0,0 +1,4 @@
+# Maven publishing configuration
+pom.name=Arrow Optics for Kotlin Reflection
+# Build configuration
+kapt.incremental.apt=false

arrow-libs/optics/arrow-optics-reflect/src/jvmMain/kotlin/arrow/optics/Reflection.kt

@@ -0,0 +1,64 @@
+package arrow.optics
+
+import arrow.core.Either
+import arrow.core.left
+import arrow.core.right
+import kotlin.reflect.*
+import kotlin.reflect.full.instanceParameter
+import kotlin.reflect.full.memberFunctions
+
+/** Focuses on those elements of the specified [klass] */
+public fun <S: Any, A: S> instance(klass: KClass<A>): Prism<S, A> =
+  object: Prism<S, A> {
+    override fun getOrModify(source: S): Either<S, A> =
+      klass.safeCast(source)?.right() ?: source.left()
+    override fun reverseGet(focus: A): S = focus
+  }
+
+/** Focuses on those elements of the specified class */
+public inline fun <S: Any, reified A: S> instance(): Prism<S, A> =
+  object: Prism<S, A> {
+    override fun getOrModify(source: S): Either<S, A> =
+      (source as? A)?.right() ?: source.left()
+    override fun reverseGet(focus: A): S = focus
+  }
+
+/** Focuses on a given field */
+public val <S, A> ((S) -> A).ogetter: Getter<S, A>
+  get() = Getter { s -> this(s) }
+
+/**
+ * [Lens] that focuses on a field in a data class
+ *
+ * WARNING: this should only be called on data classes,
+ *          but that is checked only at runtime!
+ */
+public val <S, A> KProperty1<S, A>.lens: Lens<S, A>
+  get() = PLens(
+    get = this,
+    set = { s, a -> clone(this, s, a) }
+  )
+
+/** [Optional] that focuses on a nullable field */
+public val <S, A> KProperty1<S, A?>.optional: Optional<S, A>
+  get() = lens compose Optional.nullable()
+
+public val <S, A> ((S) -> Iterable<A>).iter: Fold<S, A>
+  get() = ogetter compose Fold.iterable()
+
+public val <S, A> KProperty1<S, List<A>>.every: Every<S, A>
+  get() = lens compose Every.list()
+
+public val <S, K, A> KProperty1<S, Map<K, A>>.values: Every<S, A>
+  get() = lens compose Every.map()
+
+private fun <S, A> clone(prop: KProperty1<S, A>, value: S, newField: A): S {
+  // based on https://stackoverflow.com/questions/49511098/call-data-class-copy-via-reflection
+  val klass = prop.instanceParameter?.type?.classifier as? KClass<*>
+  val copy = klass?.memberFunctions?.firstOrNull { it.name == "copy" }
+  if (klass == null || !klass.isData || copy == null) {
+    throw IllegalArgumentException("may only be used with data classes")
+  }
+  val fieldParam = copy.parameters.first { it.name == prop.name }
+  return copy.callBy(mapOf(copy.instanceParameter!! to value, fieldParam to newField)) as S
+}

arrow-libs/optics/arrow-optics-reflect/src/jvmTest/kotlin/arrow/optics/ReflectionTest.kt

@@ -0,0 +1,55 @@
+package arrow.optics
+
+import arrow.core.test.UnitSpec
+import io.kotest.matchers.shouldBe
+import io.kotest.property.Arb
+import io.kotest.property.arbitrary.int
+import io.kotest.property.arbitrary.string
+
+data class Person(val name: String, val friends: List<String>)
+
+sealed interface Cutlery
+object Fork: Cutlery
+object Spoon: Cutlery
+
+object ReflectionTest: UnitSpec() {
+  init {
+    "optional for function" {
+      checkAll(Arb.list(Arb.int())) { ints ->
+        val firsty = { it: List<Int> -> it.firstOrNull() }
+        firsty.ogetter.get(ints) shouldBe ints.firstOrNull()
+      }
+    }
+
+    "lenses for field, get" {
+      checkAll(Arb.string(), Arb.list(Arb.string())) { nm, fs ->
+        val p = Person(nm, fs.toMutableList())
+        Person::name.lens.get(p) shouldBe nm
+      }
+    }
+
+    "lenses for field, set" {
+      checkAll(Arb.string(), Arb.list(Arb.string())) { nm, fs ->
+        val p = Person(nm, fs.toMutableList())
+        val m = Person::name.lens.modify(p) { it.capitalize() }
+        m shouldBe Person(nm.capitalize(), fs)
+      }
+    }
+
+    "traversal for list, set" {
+      checkAll(Arb.string(), Arb.list(Arb.string())) { nm, fs ->
+        val p = Person(nm, fs)
+        val m = Person::friends.every.modify(p) { it.capitalize() }
+        m shouldBe Person(nm, fs.map { it.capitalize() })
+      }
+    }
+
+    "instances" {
+      val things = listOf(Fork, Spoon, Fork)
+      val forks = Every.list<Cutlery>() compose instance<Cutlery, Fork>()
+      val spoons = Every.list<Cutlery>() compose instance<Cutlery, Fork>()
+      forks.size(things) shouldBe 2
+      spoons.size(things) shouldBe 1
+    }
+  }
+}

arrow-libs/optics/arrow-optics/build.gradle.kts

@@ -26,12 +26,14 @@ kotlin {
     jvmMain {
       dependencies {
         implementation(libs.kotlin.stdlibJDK8)
+        api(libs.kotlin.reflect)
       }
     }
     jvmTest {
       dependencies {
         implementation(libs.kotlin.stdlibJDK8)
         implementation(libs.junitJupiterEngine)
+        implementation(libs.kotlin.reflect)
       }
     }
     jsMain {

arrow-libs/optics/arrow-optics/src/commonMain/kotlin/arrow/optics/Fold.kt

@@ -10,6 +10,7 @@ import arrow.core.Tuple6
 import arrow.core.Tuple7
 import arrow.core.Tuple8
 import arrow.core.Tuple9
+import arrow.core.foldMap
 import arrow.core.identity
 import arrow.typeclasses.Monoid
 import kotlin.jvm.JvmStatic
@@ -199,6 +200,13 @@ public interface Fold<S, A> {
     public fun <A, B> void(): Fold<A, B> =
       POptional.void()
 
+    @JvmStatic
+    public fun <A> iterable(): Fold<Iterable<A>, A> =
+      object : Fold<Iterable<A>, A> {
+        override fun <R> foldMap(M: Monoid<R>, source: Iterable<A>, map: (focus: A) -> R): R =
+          source.foldMap(M, map)
+      }
+
     /**
      * [Traversal] for [List] that focuses in each [A] of the source [List].
      */

arrow-libs/optics/arrow-optics/src/commonMain/kotlin/arrow/optics/Optional.kt

@@ -7,6 +7,7 @@ import arrow.core.Some
 import arrow.core.flatMap
 import arrow.core.identity
 import arrow.core.prependTo
+import arrow.core.toOption
 import arrow.typeclasses.Monoid
 import kotlin.jvm.JvmStatic
 
@@ -204,5 +205,11 @@ public interface POptional<S, T, A, B> : PSetter<S, T, A, B>, Fold<S, A>, PTrave
       getOption = { if (it.isEmpty()) None else Some(it.drop(1)) },
       set = { list, newTail -> if (list.isNotEmpty()) list[0] prependTo newTail else emptyList() }
     )
+
+    @JvmStatic
+    public fun <A> nullable(): Optional<A?, A> = Optional(
+      getOption = { it.toOption() },
+      set = { source, new -> source?.let { new } }
+    )
   }
 }

settings.gradle.kts

@@ -53,6 +53,9 @@ project(":arrow-fx-stm").projectDir = file("arrow-libs/fx/arrow-fx-stm")
 include("arrow-optics")
 project(":arrow-optics").projectDir = file("arrow-libs/optics/arrow-optics")
 
+include("arrow-optics-reflect")
+project(":arrow-optics-reflect").projectDir = file("arrow-libs/optics/arrow-optics-reflect")
+
 include("arrow-optics-ksp-plugin")
 project(":arrow-optics-ksp-plugin").projectDir = file("arrow-libs/optics/arrow-optics-ksp-plugin")