What are the best practices you use for organizing…

I use a combination of approaches, focusing on readability, maintainability, and scalability.

Feature/module-based project structure: Dividing into modules (for large projects) or packages by functionality.
Naming conventions: camelCase for variables and functions, PascalCase for classes and objects. Clear and understandable names reflecting their purpose.
Using extensions: To add functionality to existing classes without modifying their source code. Helps avoid inheritance and makes the code cleaner.
```
// Example of extension for String
fun String.isInteger(): Boolean {
    return this.toIntOrNull() != null
}
```

Top-level functions: For helper functions that are not tied to a specific class.

// Example of a top-level function
fun formatCurrency(amount: Double): String {
    return "%.2f rub.".format(amount)
}

Data classes: For simple data holders. Automatically generate equals(), hashCode(), toString(), and copy().
```
data class User(val name: String, val age: Int)
```

Sealed classes: To represent a limited hierarchy of classes. Provide exhaustive when expressions.

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
}

fun processResult(result: Result) {
    when (result) {
        is Result.Success -> println("Success: ${result.data}")
        is Result.Error -> println("Error: ${result.message}")
    }
}

Object declarations: For singletons and companion objects.

object DatabaseManager {
    fun connect() {
        // ...
    }
}

Lambda expressions and higher-order functions: For concise and expressive code.

val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }

Nullable types and safe calls (?., ?:): To explicitly indicate nullability and work safely with them.
```
val name: String? = getName()
val length = name?.length ?: 0 // Safe call and Elvis operator
```
Code formatting conventions: Follow the standard Kotlin style (spaces, indents, etc.), often using automatic formatting tools (e.g., ktlint).
Comments: Use comments to explain complex code sections or design decisions, but aim for self-documenting code.
Tests: Write unit and integration tests to verify functionality and facilitate refactoring.

What are the best practices you use for organizing code in Kotlin?