// Non-nullable String - can never be null  
val definitelyNotNull: String = "Hello"  
// Nullable String - can contain null  
val mightBeNull: String? = null  
// This would not compile  
val willCauseError: String = null // Error: Null can not be a value of a non-null type String

// Safe call operator (?.) - safely access properties on nullable references  
val length = mightBeNull?.length // Type is Int?  
// Elvis operator (?:) - provide a default value when reference is null  
val lengthOrDefault = mightBeNull?.length ?: 0 // Type is Int  
// Not-null assertion (!!) - for when you're absolutely sure it's not null  
// (use with caution - this can throw NullPointerException)  
val forcedLength = mightBeNull!!.length

// Java code  
public class JavaClass {  
    public String mayBeNull() {  
        return Math.random() > 0.5 ? "Hello" : null;  
    }  
}

// Kotlin code  
val javaResult = JavaClass().mayBeNull() // Platform type  
// Kotlin doesn't force null checks here, but you should be careful!

// Type inference for local variables  
val name = "Kotlin" // Compiler infers String  
val list = listOf(1, 2, 3) // Compiler infers List<Int>  
  
// Type inference for function return types  
fun greet() = "Hello" // Return type inferred as String  
// Type inference for lambda parameters  
val doubles = list.map { it \* 2 } // "it" is inferred as Int

fun process(value: Any) {  
    if (value is String) {  
        // value is automatically cast to String inside this block  
        println(value.length) // No need for explicit casting  
    }  
      
    // Outside the if-block, value is back to type Any  
    // println(value.length) // This would not compile  
}

fun processNullable(value: String?) {  
    if (value != null) {  
        // value is automatically cast to non-nullable String  
        println(value.length) // Safe to access .length here  
    }  
}

class Example {  
    var mutableProperty: Any = "Hello"  
      
    fun process() {  
        if (mutableProperty is String) {  
            // Smart cast isn't allowed - property could change between check and use  
            // println(mutableProperty.length) // Doesn't compile  
              
            // Need explicit cast  
            println((mutableProperty as String).length)  
        }  
    }  
}

data class User(val id: Int, val name: String, val email: String)  
  
// Automatic equals() and hashCode()  
val user1 = User(1, "Alice", "[email protected]")  
val user2 = User(1, "Alice", "[email protected]")  
println(user1 == user2) // true - structural equality  
// Automatic toString()  
println(user1) // User(id=1, name=Alice, [email protected])  
// Copy function for immutable data handling  
val user3 = user1.copy(email = "[email protected]")  
// Destructuring declarations  
val (id, name, \_) = user1 // Only extract id and name

sealed class Result {  
    data class Success(val data: String) : Result()  
    data class Error(val message: String, val code: Int) : Result()  
    object Loading : Result()  
}  
  
fun handleResult(result: Result) {  
    // The when statement must cover all possible subclasses  
    when (result) {  
        is Result.Success -> println("Success: ${result.data}")  
        is Result.Error -> println("Error ${result.code}: ${result.message}")  
        Result.Loading -> println("Loading...")  
        // No else branch needed - compiler knows all cases are covered  
    }  
}

@JvmInline  
value class UserId(val value: Int)  
@JvmInline  
value class AccountId(val value: Int)  
// Now these are different types at compile time  
fun processUser(userId: UserId) { /\* ... \*/ }  
fun processAccount(accountId: AccountId) { /\* ... \*/ }  
val userId = UserId(1)  
val accountId = AccountId(1)  
processUser(userId) // Works  
// processUser(accountId) // Compile error - type mismatch  
// processUser(1) // Compile error - type mismatch

// A generic wrapper with a phantom type parameter  
class Tagged<TAG, T>(val value: T) {  
    // No actual use of TAG in the implementation  
}  
  
// Tags to differentiate between different types  
object Validated  
object Unvalidated  
// Type aliases for better readability  
typealias ValidatedEmail = Tagged<Validated, String>  
typealias UnvalidatedEmail = Tagged<Unvalidated, String>  
// Function that only accepts validated emails  
fun sendEmail(email: ValidatedEmail) {  
    // Safe to use - we know it's validated  
    println("Sending email to ${email.value}")  
}  
// Validation function that converts from unvalidated to validated  
fun validateEmail(email: UnvalidatedEmail): ValidatedEmail? {  
    return if (email.value.contains("@")) {  
        Tagged(email.value)  
    } else {  
        null  
    }  
}  
// Usage  
val userInput = Tagged<Unvalidated, String>("[email protected]")  
// sendEmail(userInput) // Compile error - type mismatch  
val validatedEmail = validateEmail(userInput)  
validatedEmail?.let { sendEmail(it) } // Works fine

// T must be a subtype of Comparable<T>  
fun <T> findMax(list: List<T>) where T : Comparable<T> {  
    // Implementation can safely use .compareTo()  
}  
  
// Multiple constraints  
interface Repository  
interface Cacheable  
// T must implement both Repository and Cacheable  
fun <T> enableCaching(repo: T) where T : Repository, T : Cacheable {  
    // Implementation  
}

// State machine with phantom types  
sealed class State  
object Empty : State()  
object Filled : State()  
  
class Container<S : State> private constructor(val items: List<String>) {  
    companion object {  
        fun empty(): Container<Empty> = Container(emptyList())  
    }  
      
    // This operation is only available when container is empty  
    fun fill(items: List<String>): Container<Filled> = Container(items)  
}  
// This extension function is only available on Filled containers  
fun <S : Filled> Container<S>.process(): List<String> {  
    return items.map { it.uppercase() }  
}  
// Usage  
val empty = Container.empty()  
val filled = empty.fill(listOf("apple", "banana"))  
val processed = filled.process()  
// Won't compile - can't call process() on empty container  
// empty.process()  
// Won't compile - can't call fill() on filled container  
// filled.fill(listOf("cherry"))

// F-bounded polymorphism  
interface Comparable<in T> {  
    fun compareTo(other: T): Int  
}  
  
// Self-recursive type constraints  
interface Builder<T : Builder<T>> {  
    fun withName(name: String): T  
    fun withAge(age: Int): T  
    fun build(): Any  
}  
class PersonBuilder : Builder<PersonBuilder> {  
    private var name: String = ""  
    private var age: Int = 0  
      
    override fun withName(name: String): PersonBuilder {  
        this.name = name  
        return this  
    }  
      
    override fun withAge(age: Int): PersonBuilder {  
        this.age = age  
        return this  
    }  
      
    override fun build(): Any {  
        return "Person(name=$name, age=$age)"  
    }  
}  
// Usage  
val person = PersonBuilder()  
    .withName("Alice")  
    .withAge(30)  
    .build()

// Add functionality to String class  
fun String.toTitleCase(): String {  
    return this.split(" ")  
        .joinToString(" ") { it.capitalize() }  
}  
  
// Usage  
val title = "kotlin type system".toTitleCase() // "Kotlin Type System"  
  
// Extension property  
val String.lastChar: Char  
    get() = this\[length - 1\]  
  
// Receiver type safety - only available on specific types  
fun List<Int>.sum(): Int = this.reduce { acc, i -> acc + i }  
// "hello".sum() // Won't compile - String doesn't have sum() extension

interface Writer {  
    fun write(message: String)  
}  
  
class ConsoleWriter : Writer {  
    override fun write(message: String) {  
        println(message)  
    }  
}  
// Delegation with "by" keyword  
class LoggingWriter(private val writer: Writer) : Writer by writer {  
    fun writeWithTimestamp(message: String) {  
        write("\[${System.currentTimeMillis()}\] $message")  
    }  
}  
// Property delegation  
class Person {  
    // Lazy initialization - only computed on first access  
    val heavyComputation: String by lazy {  
        println("Computing...")  
        "Result of heavy computation"  
    }  
      
    // Observable property  
    var name: String by Delegates.observable("") { \_, old, new ->  
        println("Name changed from $old to $new")  
    }  
}

// Declaration-site variance  
// "out" is like Java's <? extends T>  
interface Source<out T> {  
    fun get(): T // Can only return T, not consume it  
}  
  
// "in" is like Java's <? super T>  
interface Sink<in T> {  
    fun add(item: T) // Can only consume T, not return it  
}  
// Reified generics with inline functions  
inline fun <reified T> isType(value: Any): Boolean {  
    return value is T // Works because T is reified  
}  
// Usage  
println(isType<String>("Hello")) // true  
println(isType<Int>("Hello")) // false

// Without type alias  
fun processMap(map: Map<String, List<Pair<Int, String>>>): Map<Int, List<String>> {  
    // Implementation  
}  
  
// With type alias  
typealias UserData = Pair<Int, String>  
typealias UserList = List<UserData>  
typealias UserMap = Map<String, UserList>  
typealias ResultMap = Map<Int, List<String>>  
fun processMap(map: UserMap): ResultMap {  
    // Implementation is much more readable  
}

// Function that never returns normally  
fun fail(message: String): Nothing {  
    throw IllegalStateException(message)  
}  
  
// Useful for exhaustiveness checks  
fun process(value: String?): String {  
    return value ?: fail("Value cannot be null")  
    // No need for else branch - compiler knows all paths are covered  
}  
// Using Nothing in generics  
fun <T> emptyList(): List<T> = listOf()  
val list: List<Nothing> = emptyList() // Most specific empty list type

// Sum type (OR relationship)  
sealed class Either<out A, out B> {  
    data class Left<A>(val value: A) : Either<A, Nothing>()  
    data class Right<B>(val value: B) : Either<Nothing, B>()  
}  
  
// Product type (AND relationship)  
data class Person(val name: String, val age: Int, val email: String)  
// Pattern matching on algebraic data types  
fun <A, B, C> Either<A, B>.fold(  
    ifLeft: (A) -> C,  
    ifRight: (B) -> C  
): C = when (this) {  
    is Either.Left -> ifLeft(value)  
    is Either.Right -> ifRight(value)  
}

sealed class Result<out T, out E> {  
    data class Success<T>(val value: T) : Result<T, Nothing>()  
    data class Failure<E>(val error: E) : Result<Nothing, E>()  
}  
  
fun divide(a: Int, b: Int): Result<Int, String> {  
    return if (b == 0) {  
        Result.Failure("Division by zero")  
    } else {  
        Result.Success(a / b)  
    }  
}  
// Usage  
val result = divide(10, 2)  
when (result) {  
    is Result.Success -> println("Result: ${result.value}")  
    is Result.Failure -> println("Error: ${result.error}")  
}  
// Function to transform results  
fun <T, E, R> Result<T, E>.map(transform: (T) -> R): Result<R, E> {  
    return when (this) {  
        is Result.Success -> Result.Success(transform(value))  
        is Result.Failure -> this  
    }  
}  

class HtmlBuilder {  
    private val result = StringBuilder()  
      
    fun div(init: DivBuilder.() -> Unit) {  
        result.append("<div>")  
        val div = DivBuilder()  
        div.init()  
        result.append(div.build())  
        result.append("</div>")  
    }  
      
    fun build(): String = result.toString()  
}  
  
class DivBuilder {  
    private val content = StringBuilder()  
      
    fun p(text: String) {  
        content.append("<p>$text</p>")  
    }  
      
    fun span(text: String) {  
        content.append("<span>$text</span>")  
    }  
      
    // Nesting is type-safe  
    fun div(init: DivBuilder.() -> Unit) {  
        content.append("<div>")  
        val div = DivBuilder()  
        div.init()  
        content.append(div.build())  
        content.append("</div>")  
    }  
      
    fun build(): String = content.toString()  
}  
// Usage  
val html = HtmlBuilder().apply {  
    div {  
        p("Hello")  
        span("Kotlin")  
        div {  
            p("Nested content")  
        }  
    }  
}.build()