A modern programming language that makes developers happier.

kotlinlang

Can/should postSideEffect be called from outside an `intent { }` block (like from a Compose button?

Can you elaborate?
 `postSideEffect` and `reduce` can only be called inside `ìntent` . You can have a public fun from the ViewModel that does that

Yeah, I guess even side effects should pass through the viewModel/containerHost... I was thinking of calling `containterHost.container.intent { postSideEffect(...) }` straight from the button callback. But you're right, I don't know why I thought I saw it exist on the ContainerHost...

containerHost should be private to the ViewModel

and you should hoist everything in the compose side

&gt; should hoist everything
I made an interface of my ContainerHost's action functions that I pass down through the composables... or do you think it's better to have a bunch of lambdas in the function params?

```@Composable
fun OverviewScreen(
    ...
    viewModel: OverviewViewModel = hiltViewModel(),
) {
    ...

    with(viewModel.state.collectAsStateWithLifecycle().value) {
                MyComposalbe(
                    ...
                    onLoadMore = { viewModel.loadMore() },
                    onDelete = { viewModel.deleteWorkOrder(it) },
                )
            }
    }
    LaunchedEffect(Unit) {
        viewModel.sideEffect.collect {
            ...
        }
    }
}```


```fun deleteWorkOrder(id: Long) {
    containerHost.intent {
        ...
                    reduce { state.copy(...) }
                    postSideEffect( ... )
                 
                }
            }     
    }
}```


```protected val containerHost = containerHostVisibilityWrapper&lt;STATE, SIDE_EFFECT&gt;(initialState, savedStateHandle) { initContainerHost() }
val state: StateFlow&lt;STATE&gt; = containerHost.container.stateFlow
val sideEffect: Flow&lt;SIDE_EFFECT&gt; = containerHost.container.sideEffectFlow```


• containerHost, private to ViewModel
• state, sideEffect, public to composable

Yeah, you're right about hiding the the container, but it seems a bit overkill to have to hoist the actions using lambdas all the way down the hierarchy... even for testing, it's not too hard to pass a Noop fake implementation of that actions interface...

That way you avoid the onLoadMore, onDelete params, and just have:
```interface Actions {
  fun onLoadMore(...)
  fun onDelete (...)
}

class ContainerHostImpl : ContainerHost..., Actions {
  override fun onLoadMore(...) = intent {...}
...
}```

```/**
 * Just to keep it private without public access.
 */
fun &lt;STATE : Parcelable, SIDE_EFFECT : Any&gt; ViewModel.containerHostVisibilityWrapper(
    initialState: STATE,
    savedStateHandle: SavedStateHandle,
    onCreate: ((state: STATE) -&gt; Unit)? = null
) =
    object : ContainerHost&lt;STATE, SIDE_EFFECT&gt; {
        override val container =
            this@containerHostVisibilityWrapper.container&lt;STATE, SIDE_EFFECT&gt;(initialState, savedStateHandle = savedStateHandle, onCreate = onCreate)
    }```
