How do you ensure type safety in Kotlin?

Type safety in Kotlin is ensured at compile time through several key mechanisms:

1. Non-nullable type system: Kotlin distinguishes between reference types that can accept the value null (denoted with ? at the end of the type name) and those that cannot. The compiler requires explicit null checks or the use of safe calls (?.) and operators (?:, !!).

   // Reference that cannot be null
   val nonNullableString: String = "Hello"
   
   // Reference that can be null
   var nullableString: String? = "World"
   nullableString = null // Allowed
   
   // Compilation error: null handling required
   // val length = nullableString.length
   
   // Safe call
   val length: Int? = nullableString?.length
   
   // Elvis operator
   val safeLength: Int = nullableString?.length ?: 0
   

2. Smart casts: The compiler automatically casts the type of a variable within if, when, while, for, and other expressions after a type or null check.

   fun printLength(obj: Any) {
       if (obj is String) {
           // Inside this block, the compiler knows that obj is a String
           println("String length is ${obj.length}")
       }
   }
   
   fun processNullableString(str: String?) {
       if (str != null) {
           // Inside this block, the compiler knows that str is not null
           println("String is not null, length is ${str.length}")
       }
   }
   

3. Generics: Kotlin supports generics, which allow creating classes, interfaces, and functions that work with various types, ensuring type safety at compile time.

   class Box<T>(val item: T)
   
   fun printItem(box: Box<String>) {
       // The compiler knows that item is of type String
       println(box.item.uppercase())
   }
   

4. Covariance (out) and contravariance (in): These allow specifying how subtypes can be used in generic types, preventing type mismatch errors at compile time.

   interface Source<out T> {
       fun nextT(): T
       // fun consumeT(t: T) // Compilation error
   }
   
   interface Sink<in T> {
       // fun produceT(): T // Compilation error
       fun consumeT(t: T)
   }
   

5. Sealed classes: They represent a restricted class hierarchy where all subclasses are known at compile time. This allows the compiler to check the exhaustiveness of when expressions with subclasses of a sealed class, ensuring all cases are handled.

   sealed class Result {
       data class Success(val data: String) : Result()
       data class Error(val code: Int) : Result()
   }
   
   fun handleResult(result: Result) {
       when (result) {
           is Result.Success -> println("Data: ${result.data}")
           is Result.Error -> println("Error: ${result.code}")
           // No 'else' needed; the compiler guarantees handling all subclasses of Sealed
       }
   }
   

These mechanisms work together to detect many potential type-related errors early in development, before running the application.