@LazyScopeMarker
@JvmDefaultWithCompatibility
interface LazyListScope {
   fun item(
      key: Any? = null,
      contentType: Any? = null, // ← contentType 추가
      content: @Composable LazyItemScope.() -> Unit
   ) {
      error("The method is not implemented")
   }
  
   ...
}

inline fun <T> LazyListScope.items(
   items: List<T>,
   noinline key: ((item: T) -> Any)? = null,
   noinline contentType: (item: T) -> Any? = { null }, // ← contentType 추가
   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])
   }
...

internal class LazyListIntervalContent(
   content: LazyListScope.() -> Unit,
) : LazyLayoutIntervalContent<LazyListInterval>(), LazyListScope {
   override val intervals: MutableIntervalList<LazyListInterval> = MutableIntervalList()
   ...

   init {
      apply(content)
   }

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

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

   override fun stickyHeader(
      key: Any?,
      contentType: Any?, // ← contentType 추가
      content: @Composable LazyItemScope.(Int) -> Unit
   ) {
      ...
   }
}

internal class LazyListInterval(
    override val key: ((index: Int) -> Any)?,
    override val type: ((index: Int) -> Any?), // ← contentType을 가져올 수 있는 Lambda 추가
    val item: @Composable LazyItemScope.(index: Int) -> Unit
) : LazyLayoutIntervalContent.Interval

private class LazyListItemProviderImpl
constructor(
   ...
   private val intervalContent: LazyListIntervalContent,
   override val keyIndexMap: LazyLayoutKeyIndexMap,
) : LazyListItemProvider {
   ...
   @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)
  
   // ↓ contentType을 가져올 수 있는 기능 추가
   override fun getContentType(index: Int): Any? = intervalContent.getContentType(index) 
   ...
}

internal class LazyLayoutItemContentFactory(
   ...,
   val itemProvider: () -> LazyLayoutItemProvider,
) {
   /** itemProvider에서 생성된 캐시된 람다를 포함 */
   private val lambdasCache = mutableScatterMapOf<Any, CachedItemContent>()

   /** 
    * 지정된 키가 있는 아이템의 contentType을 반환합니다. 아이템의 composition 재사용 효율을 개선하는 데 사용됩니다
    */
   fun getContentType(key: Any?): Any? { // ← contentType을 가져올 수 있는 기능 추가
      if (key == null) return null

      val cachedContent = lambdasCache[key]
      return if (cachedContent != null) {
         cachedContent.contentType
      } else {
         val itemProvider = itemProvider()
         val index = itemProvider.getIndex(key)
         if (index != -1) {
            itemProvider.getContentType(index)
         } else {
            null
         }
      }
   }

   /** 캐시된 item content 람다를 반환하거나 새 람다를 생성하여 캐시에 넣습니다. */
   fun getContent(index: Int, key: Any, contentType: Any?): @Composable () -> Unit {
      val cached = lambdasCache[key]
      return if (cached != null && cached.index == index && cached.contentType == contentType) {
         cached.content
      } else {
         val newContent = CachedItemContent(index, key, contentType)
         lambdasCache[key] = newContent
         newContent.content
      }
   }

   ...
}
...

private class LazyLayoutItemReusePolicy(private val factory: LazyLayoutItemContentFactory) :
   SubcomposeSlotReusePolicy {
   private val countPerType = mutableObjectIntMapOf<Any?>()

   override fun getSlotsToRetain(slotIds: SubcomposeSlotReusePolicy.SlotIdsSet) {
      countPerType.clear()
      slotIds.forEach { slotId ->
         val type = factory.getContentType(slotId)
         val currentCount = countPerType.getOrDefault(type, 0)
                       
         // MaxItemsToRetainForReuse은 현재 7로 정의   
         // RecyclerView와 동일한 최대 수치 지정              
         // (RecycledViewPool.DEFAULT_MAX_SCRAP) + 2 (Recycler.DEFAULT_CACHE_SIZE)
         if (currentCount == MaxItemsToRetainForReuse) {
            slotIds.remove(slotId)
         } else {
            countPerType[type] = currentCount + 1
         }
      }
   }

   override fun areCompatible(slotId: Any?, reusableSlotId: Any?): Boolean =
      factory.getContentType(slotId) == factory.getContentType(reusableSlotId)
}