Answer.

Background: Kotlin was originally designed as a concise yet strongly typed language. To enhance readability and reduce code duplication, a powerful type inference mechanism was implemented.

Problem: Sometimes, type declarations become unnecessary, complicating the code. However, excessive type reduction leads to difficulties in reading and spreading errors if the compiler cannot infer the type.

Solution: Type inference allows the compiler to automatically determine most types based on initialization or context. Yet, strong typing still governs the correctness of the code.

Code example:

val name = "Kotlin" // String, type inferred automatically
var count = 5         // Int, type inferred automatically
val items = listOf(1, 2, 3) // List<Int>

// Explicit type declaration is required when inference is not possible
val callback: (Int) -> Unit = { println(it) }

Key features:

The type of a variable or expression can be inferred from initialization or function call context
Type inference is not always possible: the compiler requires an explicit declaration if the expression is ambiguous
Type inference does not apply to the return types of public functions and properties: the compiler requires these to be specified explicitly for ABI stability

Trick questions.

Is it possible not to specify the return type for a public function?

No, if the function is public, the compiler will require an explicit return type declaration for interface stability and Java interop support.

Example:

// Error!
public fun compute(x: Int) = x * 2 // Must explicitly declare: public fun compute(x: Int): Int = x * 2

What type is val x = null?

The compiler cannot infer the type because null has no type without context. You must explicitly declare the type:

val x: String? = null

Can type inference work for complex generic types during chain processing of collections?

Yes, but if the type cannot be inferred unambiguously (for example, when map transforms types), you may sometimes need to explicitly specify the variable type:

val values = listOf("1", "2").map { it.toInt() } // List<Int>, type will be inferred

Common mistakes and anti-patterns

Lack of explicit types in public API functions
Code overload with implicit types, making it hard to read
Error when trying to infer the type during initialization with null

Real-life example

Negative case

In the project, all variables are declared without specifying types, making navigation and understanding the code difficult for other developers or new hires.

Pros:

Less code
Faster to write and refactor

Cons:

Hard to read and maintain
Easy to make mistakes when changing initialization

Positive case

Inside functions, variable types are inferred automatically, but all public APIs always explicitly specify the return type and parameter types.