IssueTracker

Existing observable object systems are not provided enough information to allow them to duplicate what mutableStateOf() and RecomposeScope enable. This means that they need to create mutableStateOf() proxies if they wish to integrate which can be prohibitively expensive if used at the same scale as mutableStateOf().

To enable this Compose should have an API that looks something like,

/**
 * Provides a the a [RecomposeScope] that allows restarting invalidating
 * the function and requesting it to recompose.
 */
interface RecomposeScopeProvider {
    /**
     * Allocate a recompose scope (or return the current one if one is already allocated). 
     * A [RecomposeScope] can be used to invalidate the restartable composable function
     * requesting it to recompose. Allocating a recompose scope will cause the restart
     * lambda of the function to be allocated enabling the restartable composable function
     * to be restarted.
     */
    fun allocateRecomposeScope(): RecomposeScope
}

/**
 * An observer that is called at the beginning and end of each composable restartable
 * function.
 */
interface RestartableComposableFunctionObserver {
    /**
     * When a restartable function is called for any reason prior to the body of the 
     * function executing.
     *
     * @param compoundHashCode The compoundHashCode at the point the function is exeucted.
     */
    onEnter(compoundHashCode: Int)

    /**
     * Called just prior to the restartable composable function returning, prior to
     * the allocation of the restart lambda. The restart lamba can be requested to
     * be created by calling [RecomposeScopeProvider.allocateRecomposeScope] of
     * the [recomposeScopeProvider] parameter.
     *
     * If the function invocation is terminated by an exception [onExit] is not called.
     *
     * @param compoundHashCode The compoundHashCode at the point the function is exeucted.
     * @return a handle that will be disposed if the function is no longer part of 
     *   composition or if the composition is disposed.
     */
    onExit(compoundHashCode: Int, recomposeScopeProvider: RecomposeScopeProvider): ComposableObserverHandle?

    /**
     * Called when the composition the observer is observing is disposed and it will no be
     * used.
     */
    onDispose()
}

/**
 * Observe the invocation of restartable composable function in a compostion composition. The
 * [RestartableComposableFunctionObserver] will be called on for all restartable composable functions
 * in the [Compoposition] and all sub-compositions, transitively, for which this compsoition is a
 * context. 
 * 
 * [observeRestartableFunctions] can be called multiple times and each observer is independent of
 * the other observers but each observer adds overhead to every restartable composable function so care
 * should be taken when calling this API.
 * 
 * @param observer the observer that will be informed when an restartable composable function starts
 *   and when it ends as well as when it is no longer needed.
 * @return a handle that allows the observer to be disposed and detached from the composition.
 */
fun Composition.observeRestartableFunctions(observer: RestartableComposableFunctionObserver): CompositionObserverHandle?