Merge pull request #324 from forrestbice/bice/this-state-and-props

rjrjr · web-flow · commit 79337dac0bb9 · 2021-02-11T18:53:05.000-08:00
Cleanup `this.state`
diff --git a/samples/containers/hello-back-button/src/main/java/com/squareup/sample/hellobackbutton/HelloBackButtonWorkflow.kt b/samples/containers/hello-back-button/src/main/java/com/squareup/sample/hellobackbutton/HelloBackButtonWorkflow.kt
@@ -38,14 +38,14 @@ object HelloBackButtonWorkflow : StatefulWorkflow<
     return HelloBackButtonRendering(
         message = "$renderState",
         onClick = context.eventHandler {
-          this.state = when (this.state) {
+          state = when (state) {
             Able -> Baker
             Baker -> Charlie
             Charlie -> Able
           }
         },
         onBackPressed = if (renderState == Able) null else context.eventHandler {
-          this.state = when (this.state) {
+          state = when (state) {
             Able -> throw IllegalStateException()
             Baker -> Able
             Charlie -> Baker
diff --git a/samples/dungeon/common/src/main/java/com/squareup/sample/dungeon/GameWorkflow.kt b/samples/dungeon/common/src/main/java/com/squareup/sample/dungeon/GameWorkflow.kt
@@ -114,7 +114,7 @@ class GameWorkflow(
     if (running) {
       context.runningWorker(ticker) { tick ->
         return@runningWorker updateGame(
-            renderProps.ticksPerSecond, tick, game, playerRendering, board, aiRenderings
+            renderProps.ticksPerSecond, tick, playerRendering, aiRenderings
         )
       }
     }
@@ -139,9 +139,7 @@ class GameWorkflow(
   private fun updateGame(
     ticksPerSecond: Int,
     tick: Long,
-    game: Game,
     playerRendering: Rendering,
-    board: Board,
     aiRenderings: List<Pair<Location, ActorRendering>>
   ) = action("updateGame") {
     // Calculate if this tick should result in movement based on the movement's speed.
@@ -152,25 +150,27 @@ class GameWorkflow(
 
     // Execute player movement.
     var output: Output? = null
-    var newPlayerLocation: Location = game.playerLocation
+    var newPlayerLocation: Location = state.game.playerLocation
     if (playerRendering.actorRendering.movement.isTimeToMove()) {
-      val moveResult = game.playerLocation.move(playerRendering.actorRendering.movement, board)
+      val moveResult = state.game.playerLocation.move(
+        playerRendering.actorRendering.movement, props.board
+      )
       newPlayerLocation = moveResult.newLocation
       if (moveResult.collisionDetected) output = Vibrate
     }
 
     // Execute AI movement.
     val newAiLocations = aiRenderings.map { (location, rendering) ->
       return@map if (rendering.movement.isTimeToMove()) {
-        location.move(rendering.movement, board)
+        location.move(rendering.movement, props.board)
             // Don't care about collisions.
             .newLocation
       } else {
         location
       }
     }
 
-    val newGame = game.copy(
+    val newGame = state.game.copy(
         playerLocation = newPlayerLocation,
         aiLocations = newAiLocations
     )
diff --git a/samples/dungeon/timemachine/src/test/java/com/squareup/sample/timemachine/TimeMachineWorkflowTest.kt b/samples/dungeon/timemachine/src/test/java/com/squareup/sample/timemachine/TimeMachineWorkflowTest.kt
@@ -24,8 +24,8 @@ class TimeMachineWorkflowTest {
 
     val delegateWorkflow = Workflow.stateful<String, Nothing, DelegateRendering>(
         initialState = "initial",
-        render = { state ->
-          DelegateRendering(state, setState = eventHandler { s -> this.state = s })
+        render = { renderState ->
+          DelegateRendering(renderState, setState = eventHandler { s -> state = s })
         }
     )
     val clock = TestTimeSource()
diff --git a/samples/hello-terminal/todo-terminal-app/src/main/java/com/squareup/sample/hellotodo/EditTextWorkflow.kt b/samples/hello-terminal/todo-terminal-app/src/main/java/com/squareup/sample/hellotodo/EditTextWorkflow.kt
@@ -51,7 +51,7 @@ class EditTextWorkflow : StatefulWorkflow<EditTextProps, EditTextState, String,
   ): String {
     context.runningWorker(
       renderProps.terminalProps.keyStrokes
-    ) { key -> onKeystroke(renderProps, key) }
+    ) { key -> onKeystroke(key) }
 
     return buildString {
       renderProps.text.forEachIndexed { index, c ->
@@ -64,7 +64,6 @@ class EditTextWorkflow : StatefulWorkflow<EditTextProps, EditTextState, String,
   override fun snapshotState(state: EditTextState): Snapshot? = null
 
   private fun onKeystroke(
-    props: EditTextProps,
     key: KeyStroke
   ) = action {
     when (key.keyType) {
diff --git a/samples/tictactoe/common/src/main/java/com/squareup/sample/authworkflow/AuthWorkflow.kt b/samples/tictactoe/common/src/main/java/com/squareup/sample/authworkflow/AuthWorkflow.kt
@@ -78,7 +78,7 @@ class RealAuthWorkflow(private val authService: AuthService) : AuthWorkflow,
           LoginScreen(
               renderState.errorMessage,
               onLogin = context.eventHandler { email, password ->
-                this.state = when {
+                state = when {
                   email.isValidEmail -> Authorizing(email, password)
                   else -> LoginPrompt(email.emailValidationErrorMessage)
                 }
@@ -106,11 +106,11 @@ class RealAuthWorkflow(private val authService: AuthService) : AuthWorkflow,
           SecondFactorScreen(
               renderState.errorMessage,
               onSubmit = context.eventHandler { secondFactor ->
-                (this.state as? SecondFactorPrompt)?.let { oldState ->
-                  this.state = AuthorizingSecondFactor(oldState.tempToken, secondFactor)
+                (state as? SecondFactorPrompt)?.let { oldState ->
+                  state = AuthorizingSecondFactor(oldState.tempToken, secondFactor)
                 }
               },
-              onCancel = context.eventHandler { this.state = LoginPrompt() }
+              onCancel = context.eventHandler { state = LoginPrompt() }
           )
       )
     }
diff --git a/samples/tictactoe/common/src/main/java/com/squareup/sample/gameworkflow/RunGameWorkflow.kt b/samples/tictactoe/common/src/main/java/com/squareup/sample/gameworkflow/RunGameWorkflow.kt
@@ -79,7 +79,7 @@ class RealRunGameWorkflow(
               renderState.defaultXName,
               renderState.defaultOName,
               onCancel = context.eventHandler { setOutput(CanceledStart) },
-              onStartGame = context.eventHandler { x, o -> this.state = Playing(PlayerInfo(x, o)) }
+              onStartGame = context.eventHandler { x, o -> state = Playing(PlayerInfo(x, o)) }
           )
       )
     }
@@ -103,13 +103,13 @@ class RealRunGameWorkflow(
           base = GamePlayScreen(renderState.playerInfo, renderState.completedGame.lastTurn),
           alert = maybeQuitScreen(
               confirmQuit = context.eventHandler {
-                (this.state as? MaybeQuitting)?.let { oldState ->
-                  this.state = MaybeQuittingForSure(oldState.playerInfo, oldState.completedGame)
+                (state as? MaybeQuitting)?.let { oldState ->
+                  state = MaybeQuittingForSure(oldState.playerInfo, oldState.completedGame)
                 }
               },
               continuePlaying = context.eventHandler {
-                (this.state as? MaybeQuitting)?.let { oldState ->
-                  this.state = Playing(oldState.playerInfo, oldState.completedGame.lastTurn)
+                (state as? MaybeQuitting)?.let { oldState ->
+                  state = Playing(oldState.playerInfo, oldState.completedGame.lastTurn)
                 }
               }
           )
@@ -125,13 +125,13 @@ class RealRunGameWorkflow(
               positive = "Yes!!",
               negative = "Sigh, no",
               confirmQuit = context.eventHandler {
-                (this.state as? MaybeQuittingForSure)?.let { oldState ->
-                  this.state = GameOver(oldState.playerInfo, oldState.completedGame)
+                (state as? MaybeQuittingForSure)?.let { oldState ->
+                  state = GameOver(oldState.playerInfo, oldState.completedGame)
                 }
               },
               continuePlaying = context.eventHandler {
-                (this.state as? MaybeQuittingForSure)?.let { oldState ->
-                  this.state = Playing(oldState.playerInfo, oldState.completedGame.lastTurn)
+                (state as? MaybeQuittingForSure)?.let { oldState ->
+                  state = Playing(oldState.playerInfo, oldState.completedGame.lastTurn)
                 }
               }
           )
@@ -171,14 +171,14 @@ class RealRunGameWorkflow(
   }
 
   private fun RenderContext.playAgain() = eventHandler {
-    (this.state as? GameOver)?.let { oldState ->
+    (state as? GameOver)?.let { oldState ->
       val (x, o) = oldState.playerInfo
       state = NewGame(x, o)
     }
   }
 
   private fun RenderContext.trySaveAgain() = eventHandler {
-    (this.state as? GameOver)?.let { oldState ->
+    (state as? GameOver)?.let { oldState ->
       check(oldState.syncState == SAVE_FAILED) {
         "Should only fire trySaveAgain in syncState $SAVE_FAILED, " +
             "was ${oldState.syncState}"
diff --git a/samples/tutorial/Tutorial1.md b/samples/tutorial/Tutorial1.md
@@ -186,7 +186,7 @@ The `action` function is a shorthand for implementing the `WorkflowAction` class
   private fun onUsernameChanged(username: String) =
     object : WorkflowAction<Unit, State, Nothing>() {
       override fun Updater.apply() {
-        this.state = this.state.copy(username = username)
+        state = state.copy(username = username)
       }
     }
 ```
diff --git a/workflow-runtime/src/test/java/com/squareup/workflow1/RenderWorkflowInTest.kt b/workflow-runtime/src/test/java/com/squareup/workflow1/RenderWorkflowInTest.kt
@@ -128,10 +128,10 @@ class RenderWorkflowInTest {
         snapshot = { state ->
           Snapshot.write { it.writeUtf8WithLength(state) }
         },
-        render = { _, state ->
+        render = { _, renderState ->
           Pair(
-              state,
-              { newState -> actionSink.send(action { this.state = newState }) }
+              renderState,
+              { newState -> actionSink.send(action { state = newState }) }
           )
         }
     )
@@ -171,9 +171,9 @@ class RenderWorkflowInTest {
             ByteString.of(1)
           }
         },
-        render = { _, state ->
-          sink = actionSink.contraMap { action { this.state = it } }
-          state
+        render = { _, renderState ->
+          sink = actionSink.contraMap { action { state = it } }
+          renderState
         }
     )
     val props = MutableStateFlow(Unit)
@@ -464,14 +464,14 @@ class RenderWorkflowInTest {
     // A workflow whose state and rendering is the last output that it emitted.
     val workflow = Workflow.stateful<Unit, String, String, String>(
         initialState = { "{no output}" },
-        render = { _, state ->
+        render = { _, renderState ->
           runningWorker(Worker.from { outputTrigger.await() }) { output ->
             action {
               setOutput(output)
-              this.state = output
+              state = output
             }
           }
-          return@stateful state
+          return@stateful renderState
         }
     )
     val events = mutableListOf<String>()
diff --git a/workflow-runtime/src/test/java/com/squareup/workflow1/internal/WorkflowNodeTest.kt b/workflow-runtime/src/test/java/com/squareup/workflow1/internal/WorkflowNodeTest.kt
@@ -1083,9 +1083,9 @@ class WorkflowNodeTest {
   @Test fun `actionSink action changes state`() {
     val workflow = Workflow.stateful<Unit, String, Nothing, Pair<String, Sink<String>>>(
         initialState = { "initial" },
-        render = { _, state ->
-          state to actionSink.contraMap {
-            action { this.state = "${this.state}->$it" }
+        render = { _, renderState ->
+          renderState to actionSink.contraMap {
+            action { state = "$state->$it" }
           }
         }
     )
@@ -1163,11 +1163,11 @@ class WorkflowNodeTest {
   @Test fun `child action changes state`() {
     val workflow = Workflow.stateful<Unit, String, Nothing, String>(
         initialState = { "initial" },
-        render = { _, state ->
+        render = { _, renderState ->
           runningSideEffect("test") {
-            actionSink.send(action { this.state = "${this.state}->hello" })
+            actionSink.send(action { state = "$state->hello" })
           }
-          return@stateful state
+          return@stateful renderState
         }
     )
     val node = WorkflowNode(
diff --git a/workflow-runtime/src/test/java/com/squareup/workflow1/internal/WorkflowRunnerTest.kt b/workflow-runtime/src/test/java/com/squareup/workflow1/internal/WorkflowRunnerTest.kt
@@ -92,14 +92,14 @@ class WorkflowRunnerTest {
   @Test fun `nextOutput() handles workflow update`() {
     val workflow = Workflow.stateful<Unit, String, String, String>(
         initialState = { "initial" },
-        render = { _, state ->
+        render = { _, renderState ->
           runningWorker(Worker.from { "work" }) {
             action {
-              this.state = "state: $it"
+              state = "state: $it"
               setOutput("output: $it")
             }
           }
-          return@stateful state
+          return@stateful renderState
         }
     )
     val runner = WorkflowRunner(workflow, MutableStateFlow(Unit))
@@ -119,14 +119,14 @@ class WorkflowRunnerTest {
   @Test fun `nextOutput() handles concurrent props change and workflow update`() {
     val workflow = Workflow.stateful<String, String, String, String>(
         initialState = { "initial state($it)" },
-        render = { props, state ->
+        render = { renderProps, renderState ->
           runningWorker(Worker.from { "work" }) {
             action {
-              this.state = "state: $it"
+              state = "state: $it"
               setOutput("output: $it")
             }
           }
-          return@stateful "$props|$state"
+          return@stateful "$renderProps|$renderState"
         }
     )
     val props = MutableStateFlow("initial props")

Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,8 @@ class TimeMachineWorkflowTest {`
`24`	`24`
`25`	`25`	`val delegateWorkflow = Workflow.stateful<String, Nothing, DelegateRendering>(`
`26`	`26`	`initialState = "initial",`
`27`		`- render = { state ->`
`28`		`- DelegateRendering(state, setState = eventHandler { s -> this.state = s })`
	`27`	`+ render = { renderState ->`
	`28`	`+ DelegateRendering(renderState, setState = eventHandler { s -> state = s })`
`29`	`29`	`}`
`30`	`30`	`)`
`31`	`31`	`val clock = TestTimeSource()`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ class RealAuthWorkflow(private val authService: AuthService) : AuthWorkflow,`
`78`	`78`	`LoginScreen(`
`79`	`79`	`renderState.errorMessage,`
`80`	`80`	`onLogin = context.eventHandler { email, password ->`
`81`		`- this.state = when {`
	`81`	`+ state = when {`
`82`	`82`	`email.isValidEmail -> Authorizing(email, password)`
`83`	`83`	`else -> LoginPrompt(email.emailValidationErrorMessage)`
`84`	`84`	`}`
`@@ -106,11 +106,11 @@ class RealAuthWorkflow(private val authService: AuthService) : AuthWorkflow,`
`106`	`106`	`SecondFactorScreen(`
`107`	`107`	`renderState.errorMessage,`
`108`	`108`	`onSubmit = context.eventHandler { secondFactor ->`
`109`		`- (this.state as? SecondFactorPrompt)?.let { oldState ->`
`110`		`- this.state = AuthorizingSecondFactor(oldState.tempToken, secondFactor)`
	`109`	`+ (state as? SecondFactorPrompt)?.let { oldState ->`
	`110`	`+ state = AuthorizingSecondFactor(oldState.tempToken, secondFactor)`
`111`	`111`	`}`
`112`	`112`	`},`
`113`		`- onCancel = context.eventHandler { this.state = LoginPrompt() }`
	`113`	`+ onCancel = context.eventHandler { state = LoginPrompt() }`
`114`	`114`	`)`
`115`	`115`	`)`
`116`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ class RealRunGameWorkflow(`
`79`	`79`	`renderState.defaultXName,`
`80`	`80`	`renderState.defaultOName,`
`81`	`81`	`onCancel = context.eventHandler { setOutput(CanceledStart) },`
`82`		`- onStartGame = context.eventHandler { x, o -> this.state = Playing(PlayerInfo(x, o)) }`
	`82`	`+ onStartGame = context.eventHandler { x, o -> state = Playing(PlayerInfo(x, o)) }`
`83`	`83`	`)`
`84`	`84`	`)`
`85`	`85`	`}`
`@@ -103,13 +103,13 @@ class RealRunGameWorkflow(`
`103`	`103`	`base = GamePlayScreen(renderState.playerInfo, renderState.completedGame.lastTurn),`
`104`	`104`	`alert = maybeQuitScreen(`
`105`	`105`	`confirmQuit = context.eventHandler {`
`106`		`- (this.state as? MaybeQuitting)?.let { oldState ->`
`107`		`- this.state = MaybeQuittingForSure(oldState.playerInfo, oldState.completedGame)`
	`106`	`+ (state as? MaybeQuitting)?.let { oldState ->`
	`107`	`+ state = MaybeQuittingForSure(oldState.playerInfo, oldState.completedGame)`
`108`	`108`	`}`
`109`	`109`	`},`
`110`	`110`	`continuePlaying = context.eventHandler {`
`111`		`- (this.state as? MaybeQuitting)?.let { oldState ->`
`112`		`- this.state = Playing(oldState.playerInfo, oldState.completedGame.lastTurn)`
	`111`	`+ (state as? MaybeQuitting)?.let { oldState ->`
	`112`	`+ state = Playing(oldState.playerInfo, oldState.completedGame.lastTurn)`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`	`)`
`@@ -125,13 +125,13 @@ class RealRunGameWorkflow(`
`125`	`125`	`positive = "Yes!!",`
`126`	`126`	`negative = "Sigh, no",`
`127`	`127`	`confirmQuit = context.eventHandler {`
`128`		`- (this.state as? MaybeQuittingForSure)?.let { oldState ->`
`129`		`- this.state = GameOver(oldState.playerInfo, oldState.completedGame)`
	`128`	`+ (state as? MaybeQuittingForSure)?.let { oldState ->`
	`129`	`+ state = GameOver(oldState.playerInfo, oldState.completedGame)`
`130`	`130`	`}`
`131`	`131`	`},`
`132`	`132`	`continuePlaying = context.eventHandler {`
`133`		`- (this.state as? MaybeQuittingForSure)?.let { oldState ->`
`134`		`- this.state = Playing(oldState.playerInfo, oldState.completedGame.lastTurn)`
	`133`	`+ (state as? MaybeQuittingForSure)?.let { oldState ->`
	`134`	`+ state = Playing(oldState.playerInfo, oldState.completedGame.lastTurn)`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`	`)`
`@@ -171,14 +171,14 @@ class RealRunGameWorkflow(`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`private fun RenderContext.playAgain() = eventHandler {`
`174`		`- (this.state as? GameOver)?.let { oldState ->`
	`174`	`+ (state as? GameOver)?.let { oldState ->`
`175`	`175`	`val (x, o) = oldState.playerInfo`
`176`	`176`	`state = NewGame(x, o)`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`private fun RenderContext.trySaveAgain() = eventHandler {`
`181`		`- (this.state as? GameOver)?.let { oldState ->`
	`181`	`+ (state as? GameOver)?.let { oldState ->`
`182`	`182`	`check(oldState.syncState == SAVE_FAILED) {`
`183`	`183`	`"Should only fire trySaveAgain in syncState $SAVE_FAILED, " +`
`184`	`184`	`"was ${oldState.syncState}"`
Original file line number	Diff line number	Diff line change
@@ -186,7 +186,7 @@ The `action` function is a shorthand for implementing the `WorkflowAction` class
`186`	`186`	`private fun onUsernameChanged(username: String) =`
`187`	`187`	`object : WorkflowAction<Unit, State, Nothing>() {`
`188`	`188`	`override fun Updater.apply() {`
`189`		`- this.state = this.state.copy(username = username)`
	`189`	`+ state = state.copy(username = username)`
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`	```
Original file line number	Diff line number	Diff line change
`@@ -128,10 +128,10 @@ class RenderWorkflowInTest {`
`128`	`128`	`snapshot = { state ->`
`129`	`129`	`Snapshot.write { it.writeUtf8WithLength(state) }`
`130`	`130`	`},`
`131`		`- render = { _, state ->`
	`131`	`+ render = { _, renderState ->`
`132`	`132`	`Pair(`
`133`		`- state,`
`134`		`- { newState -> actionSink.send(action { this.state = newState }) }`
	`133`	`+ renderState,`
	`134`	`+ { newState -> actionSink.send(action { state = newState }) }`
`135`	`135`	`)`
`136`	`136`	`}`
`137`	`137`	`)`
`@@ -171,9 +171,9 @@ class RenderWorkflowInTest {`
`171`	`171`	`ByteString.of(1)`
`172`	`172`	`}`
`173`	`173`	`},`
`174`		`- render = { _, state ->`
`175`		`- sink = actionSink.contraMap { action { this.state = it } }`
`176`		`- state`
	`174`	`+ render = { _, renderState ->`
	`175`	`+ sink = actionSink.contraMap { action { state = it } }`
	`176`	`+ renderState`
`177`	`177`	`}`
`178`	`178`	`)`
`179`	`179`	`val props = MutableStateFlow(Unit)`
`@@ -464,14 +464,14 @@ class RenderWorkflowInTest {`
`464`	`464`	`// A workflow whose state and rendering is the last output that it emitted.`
`465`	`465`	`val workflow = Workflow.stateful<Unit, String, String, String>(`
`466`	`466`	`initialState = { "{no output}" },`
`467`		`- render = { _, state ->`
	`467`	`+ render = { _, renderState ->`
`468`	`468`	`runningWorker(Worker.from { outputTrigger.await() }) { output ->`
`469`	`469`	`action {`
`470`	`470`	`setOutput(output)`
`471`		`- this.state = output`
	`471`	`+ state = output`
`472`	`472`	`}`
`473`	`473`	`}`
`474`		`- return@stateful state`
	`474`	`+ return@stateful renderState`
`475`	`475`	`}`
`476`	`476`	`)`
`477`	`477`	`val events = mutableListOf<String>()`
Original file line number	Diff line number	Diff line change
`@@ -1083,9 +1083,9 @@ class WorkflowNodeTest {`
`1083`	`1083`	@Test fun `actionSink action changes state`() {
`1084`	`1084`	`val workflow = Workflow.stateful<Unit, String, Nothing, Pair<String, Sink<String>>>(`
`1085`	`1085`	`initialState = { "initial" },`
`1086`		`- render = { _, state ->`
`1087`		`- state to actionSink.contraMap {`
`1088`		`- action { this.state = "${this.state}->$it" }`
	`1086`	`+ render = { _, renderState ->`
	`1087`	`+ renderState to actionSink.contraMap {`
	`1088`	`+ action { state = "$state->$it" }`
`1089`	`1089`	`}`
`1090`	`1090`	`}`
`1091`	`1091`	`)`
`@@ -1163,11 +1163,11 @@ class WorkflowNodeTest {`
`1163`	`1163`	@Test fun `child action changes state`() {
`1164`	`1164`	`val workflow = Workflow.stateful<Unit, String, Nothing, String>(`
`1165`	`1165`	`initialState = { "initial" },`
`1166`		`- render = { _, state ->`
	`1166`	`+ render = { _, renderState ->`
`1167`	`1167`	`runningSideEffect("test") {`
`1168`		`- actionSink.send(action { this.state = "${this.state}->hello" })`
	`1168`	`+ actionSink.send(action { state = "$state->hello" })`
`1169`	`1169`	`}`
`1170`		`- return@stateful state`
	`1170`	`+ return@stateful renderState`
`1171`	`1171`	`}`
`1172`	`1172`	`)`
`1173`	`1173`	`val node = WorkflowNode(`
Original file line number	Diff line number	Diff line change
`@@ -92,14 +92,14 @@ class WorkflowRunnerTest {`
`92`	`92`	@Test fun `nextOutput() handles workflow update`() {
`93`	`93`	`val workflow = Workflow.stateful<Unit, String, String, String>(`
`94`	`94`	`initialState = { "initial" },`
`95`		`- render = { _, state ->`
	`95`	`+ render = { _, renderState ->`
`96`	`96`	`runningWorker(Worker.from { "work" }) {`
`97`	`97`	`action {`
`98`		`- this.state = "state: $it"`
	`98`	`+ state = "state: $it"`
`99`	`99`	`setOutput("output: $it")`
`100`	`100`	`}`
`101`	`101`	`}`
`102`		`- return@stateful state`
	`102`	`+ return@stateful renderState`
`103`	`103`	`}`
`104`	`104`	`)`
`105`	`105`	`val runner = WorkflowRunner(workflow, MutableStateFlow(Unit))`
`@@ -119,14 +119,14 @@ class WorkflowRunnerTest {`
`119`	`119`	@Test fun `nextOutput() handles concurrent props change and workflow update`() {
`120`	`120`	`val workflow = Workflow.stateful<String, String, String, String>(`
`121`	`121`	`initialState = { "initial state($it)" },`
`122`		`- render = { props, state ->`
	`122`	`+ render = { renderProps, renderState ->`
`123`	`123`	`runningWorker(Worker.from { "work" }) {`
`124`	`124`	`action {`
`125`		`- this.state = "state: $it"`
	`125`	`+ state = "state: $it"`
`126`	`126`	`setOutput("output: $it")`
`127`	`127`	`}`
`128`	`128`	`}`
`129`		`- return@stateful "$props\|$state"`
	`129`	`+ return@stateful "$renderProps\|$renderState"`
`130`	`130`	`}`
`131`	`131`	`)`
`132`	`132`	`val props = MutableStateFlow("initial props")`