wip: KType instead of KClass

Author: rjrjr

gradle.properties

@@ -8,7 +8,7 @@ android.useAndroidX=true
 systemProp.org.gradle.internal.publish.checksums.insecure=true
 
 GROUP=com.squareup.workflow1
-VERSION_NAME=1.13.0-beta2-SNAPSHOT
+VERSION_NAME=1.13.0-ehmagic01-SNAPSHOT
 
 POM_DESCRIPTION=Square Workflow
 

samples/dungeon/timemachine/src/test/java/com/squareup/sample/timemachine/TimeMachineWorkflowTest.kt

@@ -8,6 +8,7 @@ import com.squareup.workflow1.Workflow
 import com.squareup.workflow1.stateful
 import com.squareup.workflow1.testing.launchForTestingFromStartWith
 import org.junit.Test
+import kotlin.reflect.typeOf
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 import kotlin.time.ExperimentalTime
@@ -27,7 +28,7 @@ class TimeMachineWorkflowTest {
       render = { renderState ->
         DelegateRendering(
           renderState,
-          setState = eventHandler("setState", String::class) { s -> state = s }
+          setState = eventHandler("setState", typeOf<String>()) { s -> state = s }
         )
       }
     )

samples/tictactoe/common/src/main/java/com/squareup/sample/authworkflow/AuthWorkflow.kt

@@ -77,11 +77,7 @@ class RealAuthWorkflow(private val authService: AuthService) : AuthWorkflow,
       BackStackScreen(
         LoginScreen(
           renderState.errorMessage,
-          onLogin = context.eventHandler(
-            "onLogin",
-            String::class,
-            String::class,
-          ) { email, password ->
+          onLogin = context.eventHandler("onLogin") { email, password ->
             state = when {
               email.isValidEmail -> Authorizing(email, password)
               else -> LoginPrompt(email.emailValidationErrorMessage)
@@ -109,10 +105,7 @@ class RealAuthWorkflow(private val authService: AuthService) : AuthWorkflow,
         LoginScreen(),
         SecondFactorScreen(
           renderState.errorMessage,
-          onSubmit = context.eventHandler(
-            "onSubmitSecondFactor",
-            String::class
-          ) { secondFactor ->
+          onSubmit = context.eventHandler("onSubmitSecondFactor") { secondFactor ->
             (state as? SecondFactorPrompt)?.let { oldState ->
               state = AuthorizingSecondFactor(oldState.tempToken, secondFactor)
             }

workflow-core/api/workflow-core.api

@@ -12,7 +12,6 @@ import com.squareup.workflow1.WorkflowAction.Companion.noAction
 import kotlinx.coroutines.CoroutineScope
 import kotlin.jvm.JvmMultifileClass
 import kotlin.jvm.JvmName
-import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
 
@@ -126,9 +125,10 @@ public interface BaseRenderContext<out PropsT, StateT, in OutputT> {
     sideEffect: suspend CoroutineScope.() -> Unit
   )
 
-  public fun <ResultT : Any> remember(
+  /** TODO kdoc */
+  public fun <ResultT> remember(
     key: String,
-    resultType: KClass<ResultT>,
+    resultType: KType,
     vararg inputs: Any?,
     calculation: () -> ResultT
   ): ResultT
@@ -143,42 +143,42 @@ public interface BaseRenderContext<out PropsT, StateT, in OutputT> {
       >.Updater.() -> Unit
   ): () -> Unit
 
-  public fun <EventT : Any> eventHandler(
+  public fun <EventT> eventHandler(
     name: String,
-    eventType: KClass<EventT>,
+    eventType: KType,
     update: WorkflowAction<@UnsafeVariance PropsT, StateT, @UnsafeVariance OutputT>.Updater.(
       EventT
     ) -> Unit
   ): (EventT) -> Unit
 
-  public fun <E1 : Any, E2 : Any> eventHandler(
+  public fun <E1, E2> eventHandler(
     name: String,
-    e1Type: KClass<E1>,
-    e2Type: KClass<E2>,
+    e1Type: KType,
+    e2Type: KType,
     update: WorkflowAction<@UnsafeVariance PropsT, StateT, @UnsafeVariance OutputT>.Updater.(
       E1,
       E2
     ) -> Unit
   ): (E1, E2) -> Unit
 
-  public fun <E1 : Any, E2 : Any, E3 : Any> eventHandler(
+  public fun <E1, E2, E3> eventHandler(
     name: String,
-    e1Type: KClass<E1>,
-    e2Type: KClass<E2>,
-    e3Type: KClass<E3>,
+    e1Type: KType,
+    e2Type: KType,
+    e3Type: KType,
     update: WorkflowAction<@UnsafeVariance PropsT, StateT, @UnsafeVariance OutputT>.Updater.(
       E1,
       E2,
       E3
     ) -> Unit
   ): (E1, E2, E3) -> Unit
 
-  public fun <E1 : Any, E2 : Any, E3 : Any, E4 : Any> eventHandler(
+  public fun <E1, E2, E3, E4> eventHandler(
     name: String,
-    e1Type: KClass<E1>,
-    e2Type: KClass<E2>,
-    e3Type: KClass<E3>,
-    e4Type: KClass<E4>,
+    e1Type: KType,
+    e2Type: KType,
+    e3Type: KType,
+    e4Type: KType,
     update: WorkflowAction<@UnsafeVariance PropsT, StateT, @UnsafeVariance OutputT>.Updater.(
       E1,
       E2,
@@ -187,13 +187,13 @@ public interface BaseRenderContext<out PropsT, StateT, in OutputT> {
     ) -> Unit
   ): (E1, E2, E3, E4) -> Unit
 
-  public fun <E1 : Any, E2 : Any, E3 : Any, E4 : Any, E5 : Any> eventHandler(
+  public fun <E1, E2, E3, E4, E5> eventHandler(
     name: String,
-    e1Type: KClass<E1>,
-    e2Type: KClass<E2>,
-    e3Type: KClass<E3>,
-    e4Type: KClass<E4>,
-    e5Type: KClass<E5>,
+    e1Type: KType,
+    e2Type: KType,
+    e3Type: KType,
+    e4Type: KType,
+    e5Type: KType,
     update: WorkflowAction<@UnsafeVariance PropsT, StateT, @UnsafeVariance OutputT>.Updater.(
       E1,
       E2,
@@ -203,14 +203,14 @@ public interface BaseRenderContext<out PropsT, StateT, in OutputT> {
     ) -> Unit
   ): (E1, E2, E3, E4, E5) -> Unit
 
-  public fun <E1 : Any, E2 : Any, E3 : Any, E4 : Any, E5 : Any, E6 : Any> eventHandler(
+  public fun <E1, E2, E3, E4, E5, E6> eventHandler(
     name: String,
-    e1Type: KClass<E1>,
-    e2Type: KClass<E2>,
-    e3Type: KClass<E3>,
-    e4Type: KClass<E4>,
-    e5Type: KClass<E5>,
-    e6Type: KClass<E6>,
+    e1Type: KType,
+    e2Type: KType,
+    e3Type: KType,
+    e4Type: KType,
+    e5Type: KType,
+    e6Type: KType,
     update: WorkflowAction<@UnsafeVariance PropsT, StateT, @UnsafeVariance OutputT>.Updater.(
       E1,
       E2,
@@ -221,15 +221,15 @@ public interface BaseRenderContext<out PropsT, StateT, in OutputT> {
     ) -> Unit
   ): (E1, E2, E3, E4, E5, E6) -> Unit
 
-  public fun <E1 : Any, E2 : Any, E3 : Any, E4 : Any, E5 : Any, E6 : Any, E7 : Any> eventHandler(
+  public fun <E1, E2, E3, E4, E5, E6, E7> eventHandler(
     name: String,
-    e1Type: KClass<E1>,
-    e2Type: KClass<E2>,
-    e3Type: KClass<E3>,
-    e4Type: KClass<E4>,
-    e5Type: KClass<E5>,
-    e6Type: KClass<E6>,
-    e7Type: KClass<E7>,
+    e1Type: KType,
+    e2Type: KType,
+    e3Type: KType,
+    e4Type: KType,
+    e5Type: KType,
+    e6Type: KType,
+    e7Type: KType,
     update: WorkflowAction<@UnsafeVariance PropsT, StateT, @UnsafeVariance OutputT>.Updater.(
       E1,
       E2,
@@ -241,16 +241,16 @@ public interface BaseRenderContext<out PropsT, StateT, in OutputT> {
     ) -> Unit
   ): (E1, E2, E3, E4, E5, E6, E7) -> Unit
 
-  public fun <E1 : Any, E2 : Any, E3 : Any, E4 : Any, E5 : Any, E6 : Any, E7 : Any, E8 : Any> eventHandler(
+  public fun <E1, E2, E3, E4, E5, E6, E7, E8> eventHandler(
     name: String,
-    e1Type: KClass<E1>,
-    e2Type: KClass<E2>,
-    e3Type: KClass<E3>,
-    e4Type: KClass<E4>,
-    e5Type: KClass<E5>,
-    e6Type: KClass<E6>,
-    e7Type: KClass<E7>,
-    e8Type: KClass<E8>,
+    e1Type: KType,
+    e2Type: KType,
+    e3Type: KType,
+    e4Type: KType,
+    e5Type: KType,
+    e6Type: KType,
+    e7Type: KType,
+    e8Type: KType,
     update: WorkflowAction<@UnsafeVariance PropsT, StateT, @UnsafeVariance OutputT>.Updater.(
       E1,
       E2,
@@ -263,17 +263,17 @@ public interface BaseRenderContext<out PropsT, StateT, in OutputT> {
     ) -> Unit
   ): (E1, E2, E3, E4, E5, E6, E7, E8) -> Unit
 
-  public fun <E1 : Any, E2 : Any, E3 : Any, E4 : Any, E5 : Any, E6 : Any, E7 : Any, E8 : Any, E9 : Any> eventHandler(
+  public fun <E1, E2, E3, E4, E5, E6, E7, E8, E9> eventHandler(
     name: String,
-    e1Type: KClass<E1>,
-    e2Type: KClass<E2>,
-    e3Type: KClass<E3>,
-    e4Type: KClass<E4>,
-    e5Type: KClass<E5>,
-    e6Type: KClass<E6>,
-    e7Type: KClass<E7>,
-    e8Type: KClass<E8>,
-    e9Type: KClass<E9>,
+    e1Type: KType,
+    e2Type: KType,
+    e3Type: KType,
+    e4Type: KType,
+    e5Type: KType,
+    e6Type: KType,
+    e7Type: KType,
+    e8Type: KType,
+    e9Type: KType,
     update: WorkflowAction<@UnsafeVariance PropsT, StateT, @UnsafeVariance OutputT>.Updater.(
       E1,
       E2,
@@ -287,18 +287,18 @@ public interface BaseRenderContext<out PropsT, StateT, in OutputT> {
     ) -> Unit
   ): (E1, E2, E3, E4, E5, E6, E7, E8, E9) -> Unit
 
-  public fun <E1 : Any, E2 : Any, E3 : Any, E4 : Any, E5 : Any, E6 : Any, E7 : Any, E8 : Any, E9 : Any, E10 : Any> eventHandler(
+  public fun <E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> eventHandler(
     name: String,
-    e1Type: KClass<E1>,
-    e2Type: KClass<E2>,
-    e3Type: KClass<E3>,
-    e4Type: KClass<E4>,
-    e5Type: KClass<E5>,
-    e6Type: KClass<E6>,
-    e7Type: KClass<E7>,
-    e8Type: KClass<E8>,
-    e9Type: KClass<E9>,
-    e10Type: KClass<E10>,
+    e1Type: KType,
+    e2Type: KType,
+    e3Type: KType,
+    e4Type: KType,
+    e5Type: KType,
+    e6Type: KType,
+    e7Type: KType,
+    e8Type: KType,
+    e9Type: KType,
+    e10Type: KType,
     update: WorkflowAction<@UnsafeVariance PropsT, StateT, @UnsafeVariance OutputT>.Updater.(
       E1,
       E2,
@@ -314,12 +314,12 @@ public interface BaseRenderContext<out PropsT, StateT, in OutputT> {
   ): (E1, E2, E3, E4, E5, E6, E7, E8, E9, E10) -> Unit
 }
 
-public inline fun <reified ResultT : Any> BaseRenderContext<*, *, *>.remember(
+public inline fun <reified ResultT> BaseRenderContext<*, *, *>.remember(
   key: String,
   vararg inputs: Any?,
   noinline calculation: () -> ResultT
 ): ResultT {
-  return remember(key, ResultT::class, inputs = inputs, calculation)
+  return remember(key, typeOf<ResultT>(), inputs = inputs, calculation)
 }
 
 /**