interface Modifier {
    interface Element: Modifier{ /* .. */ }
    ..
    abstract class Node { 
        var isAttached: Boolean = false
            private set

        open fun onAttach() {}
        open fun onDetach() {}

        val coroutineScope: CoroutineScope
            get() = ..
    }
}

abstract class ModifierNodeELement<N: Modifier.Node>(): Modifier.Element {
    abstract fun create(): N
    abstract fun update(node: N)

    abstract override fun equals(other: Any?): Boolean
    ..
}

// ../androidx/compose/ui/node/LayoutNode.kt
internal class LayoutNode {
    ..
    internal val nodes = NodeChain(this)
}

// ../androidx/compose/ui/node/NodeChain.kt
internal class NodeChain(val layoutNode: LayoutNode) {

    // 現在提供されてる Modifier に属する ModifierNodeElements のコレクション
    private var current: MutableVector<Modifier.Element>? = null
    ..
}

// ../androidx/compose/ui/node/LayoutNode.kt
internal class LayoutNode {
    ..
    /**
     * The [Modifier] currently applied to this node.
     */
    override var modifier: Modifier = Modifier
        set(value) {
            nodes.updateFrom(value)
            ..
        }
}

fun updateFrom(modifier: Modifier) {
    var before = current // 現在のコレクション
    var beforeSize = before?.size ?: 0
    var after = modifier.fillVector(..) // 新しいコレクションに拡大
    ..
    if (after.size == beforeSize) { /* .. */ }
    else if(beforeSize == 0) { /* .. */ }
    else if(after.size == 0) { /* .. */ }
    else { /* .. */ }
}

// ../androidx/compose/ui/node/NodeChain.kt
if (after.size == before.size) {
    var i = 0
    while (i < before.size) {
        val prev = before[i] // 現在のコレクションの ModifierNodeElement
        val next = after[i] // 新しいコレクションの ModifierNodeElement

        when (actionForModifiers(prev, next)) { /* .. */ }
    }
}
..

// ２つのコレクションを ModifierNodeElement ごとに順次比較します
internal fun actionForModifiers(prev: ModifierNodeElement, next: ModifierNodeElement): Int {
    return if (prev == next)
        // 両アイテムのタイプとプロパティが同じ。つまり、update が必要なくそのまま
        // 使用されます
        ActionReuse
    else if (areObjectsOfSameType(prev, next))
        // 両アイテムのタイプが同じだけど、プロパティが異なってる。
        // つまり、update が必要です
        ActionUpdate
    else
        // アイテムのタイプが異なってるので update より差し替えが必要です
        ActionReplace
} 

if (after.size == before.size) {
    while (i < before.size) {
        when (actionForModifiers(prev, next)) {
            is ActionReuse -> { 
                // no need to do anything, this is "the same" modifier
            }
            ..
        }
    }
}

if (after.size == before.size) {
    while (i < before.size) {
        when (actionForModifiers(prev, next)) {
            is ActionReplace -> {
                //　break the loop at the index where difference was encountered for the first time
                break 
            }
            ..
        }
    }

    // リスト末尾が来る前に差分が検出されました
    if (i < before.size) {
        structuralUpdate(offset = i, before, after)
    }
}

/**
 * This method utilizes a modified Myers Diff Algorithm which will diff the two modifier chains
 * and execute a minimal number of insertions/deletions. ..
 */
private fun structuralUpdate(
    offset: Int, // the index of both collections from where diff is to be calculated
    ..
) {
    val differ = getDiffer(..) // modified version of DiffUtils
    executeDiff(differ, offset, ..)
    /* invalidate */
}

// ../androidx/compose/ui/node/NodeChain.kt
fun updateFrom(modifier: Modifier) {
    ..
    else if (beforeSize == 0) {
        var node = /* linked list の頭部 */
        while (i < after.size) {
            node = createAndInsertNodeAsChild(
                element = next, 
                parent = node
            )
            i++
        }
    }
}

fun createAndInsertNodeAsChild(
    element: ModifierNodeElement,
    parent: Modifier.Node
): Modifier.Node {
    val node = element.create() // ModifierNodeElement.create() が呼び出される
    ..
    // linked list で親の後に子を追加する
    val theChild = parent.child
    if (theChild != null) {
        theChild.parent = node
        node.child = theChild
    }
    parent.child = node
    node.parent = parent
    return node
}

// ../androidx/compose/ui/node/NodeChain.kt
fun updateFrom() {
    ..
    else if (after.size == 0) {
        var node = /* linked list の頭部 */
        while (node != null && i < before.size) {
            node = detachAndRemoveNode(node)
            ..
        }
    }
}

fun detachAndRemoveNode(node: Modifier.Node) {
    ..
    node.markAsDetached()
    ..
    val child = node.child
    val parent = node.parent
    if (child != null) {
        child.parent = parent
        node.child = null
    }
    if (parent != null) {
        parent.child = child
        node.parent = null
    }
    return parent!!
}

fun updateFrom() {
    if (after.size == before.size) { /* .. */ }
    else if (before.size == 0) { /* .. */ }
    else if (after.size == 0) { /* .. */ }
    else {
        // diff is run from the index 0 itself
        structuralUpdate(offset = 0, ..)
    }
}