Answer.

Background

Kotlin was originally designed as a safe and concise alternative to Java. One of its strengths is the advanced type inference mechanism that allows for less verbose code without losing type safety. Type inference was inspired by functional languages (such as Scala and Haskell) as well as modern trends in designing statically typed languages.

Problem

In Java and other static languages, types must be explicitly declared, leading to code redundancy. However, the lack of explicit types can make code harder to understand and lead to subtle bugs if type inference does not work correctly.

Solution

In Kotlin, the compiler can often automatically determine the type of a variable or expression based on the context. This works for local variables, function return values, and within expressions with lambdas. However, there are situations where the compiler requires explicit type declaration—such as when declaring a function without a return type inside a class ('fun doSomething()') or when expressions are ambiguous.

Code example:

val a = 42           // Int
val s = "hello"      // String
fun sum(x: Int, y: Int) = x + y // return type Int is inferred automatically

val list = listOf(1, 2, 3) // List<Int>

// Explicit type declaration is necessary if the type cannot be inferred
val emptyList: List<String> = emptyList() // otherwise it will be List<Nothing>

Key features:

Types are inferred for local variables, properties, and function return values
Explicit type declaration is required when context is absent or ambiguous
Lambda expression types can be inferred from the signatures of functions that take lambdas

Trick questions.

Why can't the type always be omitted after a colon, for example, for class properties?

For properties that are not initialized at the declaration site (for example, through a getter or in an init block), the compiler cannot automatically infer the type because it does not see the initializer.

class User {
    val fullName: String // Type must be specified, otherwise an error
        get() = "name"
}

What type will a variable have if using emptyList() without an explicit type?

The type List<Nothing> will be inferred, making the result practically useless.

val list = emptyList() // List<Nothing>

When does type inference not work with function parameters?

In the function signature, type parameters must always be explicitly declared, otherwise the compiler will throw an error.

// Error:
// fun foo(x) = x * 2
// Correct:
fun foo(x: Int) = x * 2

Common mistakes and anti-patterns

Lack of explicit type for empty collections (emptyList, emptyMap)
Insufficient understanding of how type inference works with inheritance and generic types
Complete reliance on type inference, reducing code readability

Real-life example

Negative case

A developer uses emptyList() to return a value from an API function without specifying the type explicitly. As a result, the type List<Nothing> is received, causing problems when working with this API.

Pros:

Less code, conciseness Cons:
Type safety is lost, potential unexpected compile-time errors

Positive case

A developer always explicitly declares types when working with empty collections and where doing so improves readability, while in other cases relies on the compiler's type inference.