https://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/Recent content in Identity, keys, remember, and lifecycle on Staticvar LearnHugo -- gohugo.ioen-ushttps://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/01-positional-identity-and-explicit-key-groups/Mon, 01 Jan 0001 00:00:00 +0000https://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/01-positional-identity-and-explicit-key-groups/Status: The matching model is Durable . Generated integer keys and composer method names are Version-specific observations at the pinned revisions above. This is not a promise that every compiler release emits identical groups. Outcome Given a conditional or loop, you should be able to predict when a remembered value stays attached to the same logical work and when it is matched to a different position. A group has a place and, sometimes, data identity The compiler turns composable structure into groups consumed by Composer.https://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/02-sibling-reorder-joinkey-and-moving-state/Mon, 01 Jan 0001 00:00:00 +0000https://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/02-sibling-reorder-joinkey-and-moving-state/Status: State following a keyed sibling is Durable behavior. joinKey, JoinedKey, and the exact reconciliation paths are Version-specific at the pinned revisions. The link-buffer path remains Experimental where noted by the implementation. Outcome After inserting, deleting, reversing, or shuffling siblings, you should be able to predict which remembered object follows each data item and explain the role of joinKey when a key has several parts. The reorder problem is a matching problem Suppose each row creates a remembered token:https://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/03-remember-is-a-slot-cache/Mon, 01 Jan 0001 00:00:00 +0000https://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/03-remember-is-a-slot-cache/Status: remember as composition-local caching is Durable . Composer.cache, slot traversal, and the selected gap/link storage path are Version-specific . The link-buffer route is Experimental at this snapshot. Outcome You should be able to explain why a remember calculation runs once, when a keyed calculation runs again, and why the cache belongs to composition memory rather than to the Kotlin function. The cache protocol is small The public overloads in Composables.https://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/04-remembered-forgotten-and-abandoned/Mon, 01 Jan 0001 00:00:00 +0000https://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/04-remembered-forgotten-and-abandoned/Status: The distinction between Durable remembered, forgotten, and abandoned outcomes comes from the RememberObserver contract. Callback threading and dispatcher internals are Version-specific at the pinned revision. Outcome Given a remembered object and a composition event, you should be able to predict whether onRemembered, onForgotten, or onAbandoned is the relevant callback—and which callback is not justified. Three outcomes, three questions A RememberObserver is not notified when its constructor runs. It is notified when the composition has a lifecycle result for the remembered slot.https://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/05-apply-success-failure-and-event-dispatch/Mon, 01 Jan 0001 00:00:00 +0000https://learn.staticvar.dev/courses/jetpack-compose-internals/04-identity-keys-remember-lifecycle/05-apply-success-failure-and-event-dispatch/Status: The separation between composition, application, and abandonment is Durable . RememberManager, RememberEventDispatcher, and their exact queues are Version-specific at the pinned AndroidX revision. Paused-composition hooks are Experimental context, not ordinary remember semantics. Outcome You should be able to trace a remembered object through change calculation, apply, observer dispatch, side-effect dispatch, and the failure path that produces onAbandoned. RememberManager is the apply-phase inbox The internal RememberManager receives events while changes execute.