// ❌ Verbose
val result = mutableListOf<String>()
for (item in items) {
    if (item.isActive) {
        result.add(item.name.uppercase())
    }
}
 
// ✅ Idiomatic
val result = items.filter { it.isActive }.map { it.name.uppercase() }

// ❌ Manual grouping
val map = mutableMapOf<String, MutableList<Item>>()
for (item in items) {
    map.getOrPut(item.category) { mutableListOf() }.add(item)
}
 
// ✅
val map = items.groupBy { it.category }

// ❌ Manual fold
var total = 0
for (order in orders) total += order.amount
 
// ✅
val total = orders.sumOf { it.amount }

// ❌ Unnecessary null check when Elvis suffices
val name: String
if (user?.name != null) {
    name = user.name
} else {
    name = "Guest"
}
 
// ✅
val name = user?.name ?: "Guest"

// ❌ Double null check
if (response != null && response.body != null) {
    process(response.body!!)
}
 
// ✅
response?.body?.let { process(it) }

// ❌ !! without guard
val value = nullable!!.doSomething()
 
// ✅ Make the non-null contract explicit at the boundary
val value = requireNotNull(nullable) { "nullable must be set before calling X" }.doSomething()
// Or return early:
val n = nullable ?: return

// ❌ Single-expression function with unnecessary block body
fun double(x: Int): Int {
    return x * 2
}
 
// ✅
fun double(x: Int) = x * 2

// ❌ Lambda capturing unused parameter
items.forEach { item -> doSomething() }
 
// ✅
items.forEach { doSomething() }

// ❌ Redundant with/apply nesting
val builder = Builder()
builder.setName("x")
builder.setAge(1)
val result = builder.build()
 
// ✅
val result = Builder().apply {
    setName("x")
    setAge(1)
}.build()

// ❌ Mutable class for immutable data
class Point {
    var x: Int = 0
    var y: Int = 0
}
 
// ✅
data class Point(val x: Int, val y: Int)

// ❌ Companion object just to hold a constant
class Foo {
    companion object {
        val TAG = "Foo"
    }
}
 
// ✅ — top-level if only used in this file
private const val TAG = "Foo"
class Foo

// ❌ Enum with when that has to be updated in two places
enum class Status { ACTIVE, INACTIVE }
fun label(s: Status) = when(s) { Status.ACTIVE -> "Active"; Status.INACTIVE -> "Inactive" }
 
// ✅ — put display logic on the enum itself
enum class Status(val label: String) { ACTIVE("Active"), INACTIVE("Inactive") }

// ❌ Unnecessary async/await pair when result is used immediately
val result = async { fetchData() }.await()
 
// ✅
val result = fetchData() // just suspend fun, no async needed

// ❌ Collecting in a loop
while (true) {
    val value = channel.receive()
    process(value)
}
 
// ✅
channel.consumeEach { process(it) }
// or for Flow:
flow.collect { process(it) }

// ❌ StateFlow + manual emit boilerplate
private val _state = MutableStateFlow(initial)
val state: StateFlow<State> = _state
// ... in many places: _state.value = newValue
 
// ✅ — use update{} for atomic mutation
_state.update { it.copy(field = newValue) }

// ❌ Unnecessary remember for derived state that's cheap to compute
val displayName = remember { user.firstName + " " + user.lastName }
 
// ✅ — only remember if computation is expensive or involves object creation
val displayName = "${user.firstName} ${user.lastName}"

// ❌ Passing entire state object when composable only needs one field
@Composable
fun UserBadge(user: User) { Text(user.name) }
 
// ✅ — pass only what's needed (stability + minimal recomposition)
@Composable
fun UserBadge(name: String) { Text(name) }

// ❌ Inline click handler lambda (creates new instance each recomposition)
Button(onClick = { viewModel.onSave() }) { ... }
 
// ✅
val onSave = remember(viewModel) { { viewModel.onSave() } }
Button(onClick = onSave) { ... }
// Or pass it down as a parameter already

// ❌ Nested Column/Row just to group children
Column {
    Column {
        Text("a")
        Text("b")
    }
}
 
// ✅
Column {
    Text("a")
    Text("b")
}