feat(dsl): generalize exchanging (#850)

Author: DanySK

dsl/src/commonMain/kotlin/it/unibo/collektive/aggregate/api/Aggregate.kt

@@ -11,7 +11,8 @@ package it.unibo.collektive.aggregate.api
 import it.unibo.collektive.field.Field
 import kotlinx.serialization.serializer
 
-typealias YieldingScope<Initial, Return> = YieldingContext<Initial, Return>.(Initial) -> YieldingResult<Initial, Return>
+typealias YieldingScope<Shared, Returned> =
+    YieldingContext<Shared, Returned>.(Shared) -> YieldingResult<Shared, Returned>
 
 /**
  * Represents methods intended to be used internally only.
@@ -49,8 +50,8 @@ interface Aggregate<ID : Any> {
     fun <Shared, Returned> InternalAPI.`_ serialization aware exchanging`(
         initial: Shared,
         dataSharingMethod: DataSharingMethod<Shared>,
-        body: YieldingScope<Field<ID, Shared>, Field<ID, Returned>>,
-    ): Field<ID, Returned>
+        body: YieldingScope<Field<ID, Shared>, Returned>,
+    ): Returned
 
     /**
      * Iteratively updates the value computing the [transform] expression at each device using the last

dsl/src/commonMain/kotlin/it/unibo/collektive/aggregate/api/CoreOperators.kt

@@ -34,8 +34,8 @@ import it.unibo.collektive.field.Field
  */
 inline fun <ID : Any, reified Shared, Returned> Aggregate<ID>.exchanging(
     initial: Shared,
-    noinline body: YieldingScope<Field<ID, Shared>, Field<ID, Returned>>,
-): Field<ID, Returned> =
+    noinline body: YieldingScope<Field<ID, Shared>, Returned>,
+): Returned =
     @OptIn(DelicateCollektiveApi::class)
     InternalAPI.`_ serialization aware exchanging`(initial, dataSharingMethod(), body)
 

dsl/src/commonMain/kotlin/it/unibo/collektive/aggregate/api/Operators.kt

@@ -31,7 +31,7 @@ import it.unibo.collektive.field.Field
 inline fun <ID : Any, reified Shared> Aggregate<ID>.exchange(
     initial: Shared,
     noinline body: (Field<ID, Shared>) -> Field<ID, Shared>,
-): Field<ID, Shared> = exchanging(initial) { field -> body(field).run { yielding { this } } }
+): Field<ID, Shared> = exchanging(initial) { field -> body(field).yielding { this } }
 
 /**
  * [share] implements efficient stateful data sharing.
@@ -48,7 +48,7 @@ inline fun <ID : Any, reified Shared> Aggregate<ID>.exchange(
 inline fun <ID : Any, reified Shared> Aggregate<ID>.share(
     initial: Shared,
     noinline body: (Field<ID, Shared>) -> Shared,
-): Shared = sharing(initial) { field -> body(field).run { yielding { this } } }
+): Shared = sharing(initial) { field -> body(field).yielding { this } }
 
 /**
  * [sharing] implements efficient stateful data sharing.
@@ -67,8 +67,6 @@ inline fun <ID : Any, reified Shared, Returned> Aggregate<ID>.sharing(
 ): Returned = exchanging(initial) { field: Field<ID, Shared> ->
     with(YieldingContext<Shared, Returned>()) {
         val result: YieldingResult<Shared, Returned> = body(field)
-        field.map { result.toSend }.yielding {
-            field.map { result.toReturn }
-        }
+        field.mapToConstantField(result.toSend).yielding { result.toReturn }
     }
-}.localValue
+}

dsl/src/commonMain/kotlin/it/unibo/collektive/aggregate/api/YieldSupport.kt

@@ -17,7 +17,8 @@ class YieldingContext<Shared, Returned> {
     /**
      * Computes [toReturn] after the data exchange operation is complete.
      */
-    fun Shared.yielding(toReturn: () -> Returned): YieldingResult<Shared, Returned> = YieldingResult(this, toReturn())
+    fun Shared.yielding(toReturn: Shared.() -> Returned): YieldingResult<Shared, Returned> =
+        YieldingResult(this, this.toReturn())
 }
 
 /**

dsl/src/commonMain/kotlin/it/unibo/collektive/aggregate/api/impl/AggregateContext.kt

@@ -56,22 +56,22 @@ internal class AggregateContext<ID : Any>(
     private fun <T> newField(localValue: T, others: Map<ID, T>): Field<ID, T> = Field(localId, localValue, others)
 
     @DelicateCollektiveApi
-    override fun <Initial, Ret> InternalAPI.`_ serialization aware exchanging`(
-        initial: Initial,
-        dataSharingMethod: DataSharingMethod<Initial>,
-        body: YieldingScope<Field<ID, Initial>, Field<ID, Ret>>,
-    ): Field<ID, Ret> {
+    override fun <Shared, Returned> InternalAPI.`_ serialization aware exchanging`(
+        initial: Shared,
+        dataSharingMethod: DataSharingMethod<Shared>,
+        body: YieldingScope<Field<ID, Shared>, Returned>,
+    ): Returned {
         val path: Path = stack.currentPath()
-        val messages = inboundMessage.dataAt<Initial>(path, dataSharingMethod)
+        val messages = inboundMessage.dataAt<Shared>(path, dataSharingMethod)
         val previous = stateAt(path, initial)
-        val subject = newField(previous, messages)
-        val context = YieldingContext<Field<ID, Initial>, Field<ID, Ret>>()
-        return body(context, subject)
+        val subject: Field<ID, Shared> = newField(previous, messages)
+        val context = YieldingContext<Field<ID, Shared>, Returned>()
+        return context.body(subject)
             .also {
                 val message = SharedData(
                     it.toSend.localValue,
                     when (it.toSend) {
-                        is ConstantField<ID, Initial> -> emptyMap()
+                        is ConstantField<ID, Shared> -> emptyMap()
                         else -> it.toSend.excludeSelf()
                     },
                 )