internal fun ColorScheme.fromToken(value: ColorSchemeKeyTokens): Color {
   return when (value) {
      ColorSchemeKeyTokens.Background -> background
      ColorSchemeKeyTokens.Error -> error
      ColorSchemeKeyTokens.ErrorContainer -> errorContainer
      ColorSchemeKeyTokens.InverseOnSurface -> inverseOnSurface
      ColorSchemeKeyTokens.InversePrimary -> inversePrimary
      ColorSchemeKeyTokens.InverseSurface -> inverseSurface
      ColorSchemeKeyTokens.OnBackground -> onBackground
      ColorSchemeKeyTokens.OnError -> onError
      ColorSchemeKeyTokens.OnErrorContainer -> onErrorContainer
      ColorSchemeKeyTokens.OnPrimary -> onPrimary
      ColorSchemeKeyTokens.OnPrimaryContainer -> onPrimaryContainer
      ColorSchemeKeyTokens.OnSecondary -> onSecondary
      ColorSchemeKeyTokens.OnSecondaryContainer -> onSecondaryContainer
      ColorSchemeKeyTokens.OnSurface -> onSurface
      ColorSchemeKeyTokens.OnSurfaceVariant -> onSurfaceVariant
      ColorSchemeKeyTokens.SurfaceTint -> surfaceTint
      ColorSchemeKeyTokens.OnTertiary -> onTertiary
      ColorSchemeKeyTokens.OnTertiaryContainer -> onTertiaryContainer
      ColorSchemeKeyTokens.Outline -> outline
      ColorSchemeKeyTokens.OutlineVariant -> outlineVariant
      ColorSchemeKeyTokens.Primary -> primary
      ColorSchemeKeyTokens.PrimaryContainer -> primaryContainer
      ColorSchemeKeyTokens.Scrim -> scrim
      ColorSchemeKeyTokens.Secondary -> secondary
      ColorSchemeKeyTokens.SecondaryContainer -> secondaryContainer
      ColorSchemeKeyTokens.Surface -> surface
      ColorSchemeKeyTokens.SurfaceVariant -> surfaceVariant
      ColorSchemeKeyTokens.Tertiary -> tertiary
      ColorSchemeKeyTokens.TertiaryContainer -> tertiaryContainer
   }
}

FloatingActionButton(
   ...
   modifier = modifier.sizeIn(
      minWidth = FabPrimarySmallTokens.ContainerWidth,
      minHeight = FabPrimarySmallTokens.ContainerHeight,
   ),
)

val scope = rememberCoroutineScope()
val snackbarHostState = remember { SnackbarHostState() }
Scaffold(
   snackbarHost = {
      SnackbarHost(hostState = snackbarHostState)
   },
   floatingActionButton = {
      ExtendedFloatingActionButton(
         text = { Text("Show snackbar") },
         icon = { Icon(Icons.Filled.Image, contentDescription = "") },
         onClick = {
            // Case1. 단일 텍스트 노출
            scope.launch {
               snackbarHostState.showSnackbar("Snackbar")
            }
           
            // Case2. Action이 있는 형태
            val result = snackbarHostState
               .showSnackbar(
                  message = "Snackbar",
                  actionLabel = "Action",
                  // Defaults to SnackbarDuration.Short
                  duration = SnackbarDuration.Indefinite
               )
            when (result) {
               SnackbarResult.ActionPerformed -> {
                  /* Handle snackbar action performed */
               }
               SnackbarResult.Dismissed -> {
                  /* Handle snackbar dismissed */
               }
            }
         }
      )
   }
) { contentPadding ->
   // Screen content
}

LazyColumn {
   // Add a single item
   item {
      Text(text = "First item")
   }

   // Add 5 items
   items(5) { index ->
      Text(text = "Item: $index")
   }

   // Add another single item
   item {
      Text(text = "Last item")
   }
}

LazyColumn {
   items(messages) { message ->
      MessageRow(message)
   }
}

LazyColumn(
   contentPadding = PaddingValues(horizontal = 16.dp, vertical = 8.dp),
) {
   // ...
}

LazyColumn(
   verticalArrangement = Arrangement.spacedBy(4.dp),
) {
   // ...
}

LazyColumn {
   items(
      items = messages,
      key = { message ->
         // Return a stable + unique key for the item
         message.id
      }
   ) { message ->
      MessageRow(message)
   }
}

LazyColumn {
   items(books, key = { it.id }) {
      Row(Modifier.animateItemPlacement()) {
         // ...
      }
   }
}

@OptIn(ExperimentalFoundationApi::class)
@Composable
fun ListWithHeader(items: List<Item>) {
   LazyColumn {
      stickyHeader {
         Header()
      }
      ...
   }
}

@OptIn(ExperimentalAnimationApi::class)
@Composable
fun MessageList(messages: List<Message>) {
   Box {
      val listState = rememberLazyListState()

      LazyColumn(state = listState) {
         // ...
      }

      // firstVisibleItemIndex이 첫 번째 항목을 지나면 버튼을 표시
      // 불필요한 composition을 최소화하기 위해 remember+derivedStateOf를 사용
      val showButton by remember {
         derivedStateOf {
            listState.firstVisibleItemIndex > 0
         }
      }

      AnimatedVisibility(visible = showButton) {
         ScrollToTopButton()
      }
   }
}

val listState = rememberLazyListState()

LazyColumn(state = listState) {
   // ...
}

LaunchedEffect(listState) {
   snapshotFlow { listState.firstVisibleItemIndex }
      .map { index -> index > 0 }
      .distinctUntilChanged()
      .filter { it }
      .collect {
         MyAnalyticsService.sendScrolledPastFirstItemEvent()
      }
}

@Composable
fun MessageList(messages: List<Message>) {
   val listState = rememberLazyListState()
   // Remember a CoroutineScope to be able to launch
   val coroutineScope = rememberCoroutineScope()

   LazyColumn(state = listState) {
      // ...
   }

   ScrollToTopButton(
      onClick = {
         coroutineScope.launch {
            // 첫 번째 항목으로 스크롤 애니메이션 적용
            listState.animateScrollToItem(index = 0)
         }
      }
   )
}

@Composable
fun MessageList(pager: Pager<Int, Message>) {
   val lazyPagingItems = pager.flow.collectAsLazyPagingItems()

   LazyColumn {
      items(
         lazyPagingItems.itemCount,
         key = lazyPagingItems.itemKey { it.id }
      ) { index ->
         val message = lazyPagingItems[index]
         if (message != null) {
            MessageRow(message)
         } else {
            MessagePlaceholder()
         }
      }
   }
}

LazyColumn {
   items(elements, contentType = { it.type }) {
      // ...
   }
}