@Composable
internal fun LazyList(
   modifier: Modifier,
   state: LazyListState, /** 스크롤 위치를 제어하는 상태 */
   contentPadding: PaddingValues, /** 전체 콘텐츠에 추가될 내부 패딩 */
   reverseLayout: Boolean, /** 스크롤 방향과 레이아웃을 반대로 바꾸기 */
   isVertical: Boolean, /** List 레이아웃의 방향 */
   flingBehavior: FlingBehavior, /** 플링에 사용할 동작 */
   userScrollEnabled: Boolean, /** 사용자 제스처를 통한 스크롤 허용 여부 */
   overscrollEffect: OverscrollEffect?, /** 이벤트를 렌더링하고 전달할 오버스크롤 효과 */
   beyondBoundsItemCount: Int = 0, /** 표시되는 항목 앞뒤에 레이아웃할 항목 수 */
   horizontalAlignment: Alignment.Horizontal? = null, /** 항목의 수평 정렬. isVertical가 true일 때 동작 */
   verticalArrangement: Arrangement.Vertical? = null, /** 항목의 수직 배열. isVertical가 true일 때 동작 */
   verticalAlignment: Alignment.Vertical? = null, /** 항목의 세로로 정렬. isVertical가 false일 때 동작 */
   horizontalArrangement: Arrangement.Horizontal? = null, /** 항목의 수평 배열 */
   content: LazyListScope.() -> Unit /** List의 내용 */
) {
  ...
}

LazyColumn(...) { 
   // this = LazyListScope
   item(
      key = /** ... */,
      contentType = /** ... */
   ) { 
      // this = LazyItemScope
      ...
   }
}

interface LazyListScope {
   fun item(
      key: Any? = null,
      contentType: Any? = null,
      content: @Composable LazyItemScope.() -> Unit
   ) {
      ...
   }
}

@Composable
internal fun LazyList(
   state: LazyListState, /** 스크롤 위치를 제어하는 상태 */
   content: LazyListScope.() -> Unit /** List의 내용 */
) {
  val itemProviderLambda = rememberLazyListItemProviderLambda(state, content)
  ...
}

package androidx.compose.foundation.lazy

@Composable
internal fun rememberLazyListItemProviderLambda(
   state: LazyListState,
   content: LazyListScope.() -> Unit
): () -> LazyListItemProvider {
   val latestContent = rememberUpdatedState(content)
   return remember(state) {
      val scope = LazyItemScopeImpl()
      val intervalContentState =
         derivedStateOf(referentialEqualityPolicy()) {
            LazyListIntervalContent(latestContent.value)
         }
      val itemProviderState =
         derivedStateOf(referentialEqualityPolicy()) {
            val intervalContent = intervalContentState.value
            val map = NearestRangeKeyIndexMap(state.nearestRange, intervalContent)
            LazyListItemProviderImpl(
               state = state,
               intervalContent = intervalContent,
               itemScope = scope,
               keyIndexMap = map
            )
         }
      itemProviderState::value
   }
}

package androidx.compose.foundation.lazy

// item DSL을 통해 정의된 lazy layout의 interval 기반 콘텐츠를 뒷받침하는 공통 부분
internal class LazyListIntervalContent(
   content: LazyListScope.() -> Unit,
) : LazyLayoutIntervalContent<LazyListInterval>(), LazyListScope {
   override val intervals: MutableIntervalList<LazyListInterval> = MutableIntervalList()

   private var _headerIndexes: MutableIntList? = null
   val headerIndexes: IntList
      get() = _headerIndexes ?: emptyIntList()

   ...

   // items 수만큼 추가
   override fun items(
      count: Int,
      key: ((index: Int) -> Any)?,
      contentType: (index: Int) -> Any?,
      itemContent: @Composable LazyItemScope.(index: Int) -> Unit
   ) {
      intervals.addInterval(
         count,
         LazyListInterval(key = key, type = contentType, item = itemContent)
      )
   }

   // 단일 item 추가
   override fun item(
      key: Any?, 
      contentType: Any?, 
      content: @Composable LazyItemScope.() -> Unit
   ) {
      intervals.addInterval(
         1,
         LazyListInterval(
            key = if (key != null) { _: Int -> key } else null,
            type = { contentType },
            item = { content() }
         )
      )
   }

   // stickyHeader item을 추가하여 스크롤할 때도 고정된 상태로 유지
   // Header는 다음 Header가 그 자리를 차지할 때까지 고정된 상태로 유지
   override fun stickyHeader(
      key: Any?,
      contentType: Any?,
      content: @Composable LazyItemScope.(Int) -> Unit
   ) {
      val headersIndexes = _headerIndexes ?: mutableIntListOf().also { _headerIndexes = it }
      headersIndexes.add(intervals.size)
      val headerIndex = intervals.size

      item(key, contentType) { content(headerIndex) }
   }
}

internal class LazyListInterval(
   override val key: ((index: Int) -> Any)?,
   override val type: ((index: Int) -> Any?),
   val item: @Composable LazyItemScope.(index: Int) -> Unit
) : LazyLayoutIntervalContent.Interval

@Composable
fun PluuItem(list: List<Int>) {
   LazyColumn(Modifier.fillMaxSize()) {
      items(
         items = list,
         ...
      ) {
         ...
      }
   }
}

inline fun <T> LazyListScope.items(
   items: List<T>,
   noinline key: ((item: T) -> Any)? = null,
   noinline contentType: (item: T) -> Any? = { null },
   crossinline itemContent: @Composable LazyItemScope.(item: T) -> Unit
) =
   items(
      count = items.size,
      key = if (key != null) { index: Int -> key(items[index]) } else null,
      contentType = { index: Int -> contentType(items[index]) }
   ) {
      itemContent(items[it])
   }

package androidx.compose.foundation.lazy.layout

abstract class LazyLayoutIntervalContent<Interval : LazyLayoutIntervalContent.Interval> {
   abstract val intervals: IntervalList<Interval>

   // intervals에 있는 item의 총 갯수
   val itemCount: Int
      get() = intervals.size

   // global index에 따라 item key 반환
   fun getKey(index: Int): Any =
      withInterval(index) { localIndex, content ->
         content.key?.invoke(localIndex) ?: getDefaultLazyLayoutKey(index)
      }

   // global index에 따라 ContentType 반환
   fun getContentType(index: Int): Any? =
      withInterval(index) { localIndex, content -> content.type.invoke(localIndex) }

   // interval에 localIntervalIndex를 제공하여 
   // globalIndex와 연관된 interval의 컨텐츠에 대한 block을 실행
   inline fun <T> withInterval(
      globalIndex: Int,
      block: (localIntervalIndex: Int, content: Interval) -> T
   ): T {
      val interval = intervals[globalIndex]
      val localIntervalIndex = globalIndex - interval.startIndex
      return block(localIntervalIndex, interval.value)
   }

   // lazy layout의 item DSL에 있는 개별 Interval의 공통 컨텐츠
   interface Interval {
      // 현재 interval에 대한 local index를 기준으로 item key를 반환
      val key: ((index: Int) -> Any)?
         get() = null

      // 현재 interval에 대한 local index를 기준으로 item type을 반환
      val type: ((index: Int) -> Any?)
         get() = { null }
   }
}

package androidx.compose.foundation.lazy

private class LazyListItemProviderImpl
constructor(
   private val state: LazyListState,
   private val intervalContent: LazyListIntervalContent,
   override val itemScope: LazyItemScopeImpl,
   override val keyIndexMap: LazyLayoutKeyIndexMap,
) : LazyListItemProvider {

   override val itemCount: Int
      get() = intervalContent.itemCount

   @Composable
   override fun Item(index: Int, key: Any) {
      LazyLayoutPinnableItem(key, index, state.pinnedItems) {
         intervalContent.withInterval(index) { localIndex, content ->
            content.item(itemScope, localIndex)
         }
      }
   }

   override fun getKey(index: Int): Any =
      keyIndexMap.getKey(index) ?: intervalContent.getKey(index)

   override fun getContentType(index: Int): Any? = intervalContent.getContentType(index)

   override val headerIndexes: IntList
      get() = intervalContent.headerIndexes

   override fun getIndex(key: Any): Int = keyIndexMap.getIndex(key)

   ... 
}

@OptIn(ExperimentalFoundationApi::class)
internal interface LazyListItemProvider : LazyLayoutItemProvider {
   val keyIndexMap: LazyLayoutKeyIndexMap
   /** sticky header items이 Index 리스트 */
   val headerIndexes: IntList
   /** item content lambda에서 사용하는 Scope */
   val itemScope: LazyItemScopeImpl
}

@Stable
@ExperimentalFoundationApi
interface LazyLayoutItemProvider {

   /** lazy layout의 총 item 갯수 */
   val itemCount: Int

   /** 주어진 index/key에 대한 item */
   @Composable fun Item(index: Int, key: Any)

   /**
    * index에 있는 item의 ContentType을 반환
    * item의 composition 재사용 효율성을 개선하는 데 사용
    */
   fun getContentType(index: Int): Any? = null

   /** index에 있는 항목의 key를 반환 */
   fun getKey(index: Int): Any = getDefaultLazyLayoutKey(index)

   /**
    * 주어진 key에 대한 index를 반환
    * 최적화를 위해 레이아웃의 모든 키에 대해 알 수 있음
    * 레이아웃에 키가 없거나 뷰포트가 없으면 -1을 반환
    */
   fun getIndex(key: Any): Int = -1
}