Generics,
Lambdas &
Functions

// ✗ Without reified: T is erased, must pass KClass manually
fun <T> findService(clazz: KClass<T>): T { ... }
findService(UserService::class)  // caller must pass KClass

// ✓ With reified: T is available as a real class
inline fun <reified T> findService(): T {
    return serviceLocator.get(T::class.java) as T
}
findService<UserService>()  // clean, no KClass argument

// Type checking at runtime
inline fun <reified T> Any.isType() = this is T
// Compiles to: this is UserService (substituted at call site)

// filterIsInstance — stdlib uses reified internally
inline fun <reified R> Iterable<*>.filterIsInstance(): List<R> =
    filter { it is R }.map { it as R }

// JSON/serialization: get type without passing Class
inline fun <reified T> parseJson(json: String): T =
    gson.fromJson(json, T::class.java)

// Android ViewModel without ViewModelProvider boilerplate
inline fun <reified VM : ViewModel> Fragment.viewModels(): VM =
    ViewModelProvider(this)[VM::class.java]

// What the compiler generates at call site:
// parseJson<User>(json)
// → gson.fromJson(json, User::class.java)  ← T substituted

// The pattern: builder function + receiver lambda
class HtmlBuilder {
    private val children = mutableListOf<String>()
    fun p(text: String) = children.add("<p>$text</p>")
    fun h1(text: String) = children.add("<h1>$text</h1>")
    fun build() = children.joinToString("\n")
}

// Builder function: receiver lambda invoked on a new HtmlBuilder
fun html(block: HtmlBuilder.() -> Unit): String {
    val builder = HtmlBuilder()
    builder.block()      // 'this' inside block = builder instance
    return builder.build()
}

// Usage: reads like HTML, is fully type-safe Kotlin
val page = html {
    h1("Welcome")   // calls HtmlBuilder.h1()
    p("Hello world") // calls HtmlBuilder.p()
}

// @DslMarker: prevent accessing outer scope from inner scope
@DslMarker
@Target(AnnotationTarget.CLASS)
annotation class HtmlDsl

@HtmlDsl class Div { fun p(text: String) { ... } }
@HtmlDsl class Table { fun div(init: Div.() -> Unit) { ... } }

// Without @DslMarker, outer div's methods leak into inner scope.
// With @DslMarker, this is a compile error:
table {
    div {
        tr { ... }  // ✗ Error: can't access table's tr() from div scope
    }
}

// apply: T.(block) → T  — receiver = this, returns receiver
// Use: object configuration (builder pattern)
val dialog = AlertDialog.Builder(ctx).apply {
    setTitle("Warning")  // this = Builder
    setMessage("Are you sure?")
}.create()

// with: (T, T.() → R) → R  — receiver = this, returns result
// Use: multiple operations on same object, result is different
val size = with(myList) {
    add("item")   // this = myList
    size          // return value
}

// let: T.((T) → R) → R  — argument = it, returns result
// Use: null-safe chain, transform and return something else
name?.let { println("Name: $it") }  // only runs if non-null

// run: T.(T.() → R) → R  — receiver = this, returns result
// Use: object config + compute result in same block
val result = builder.run {
    configure()    // this = builder
    build()        // return build result
}

// also: T.((T) → Unit) → T  — argument = it, returns receiver
// Use: side effects in a chain (logging, validation)
val user = createUser()
    .also { log.info("Created: ${it.id}") }  // side effect
    .also { analytics.track(it) }

// Define your builder classes
@DslMarker
@Target(AnnotationTarget.CLASS)
annotation class RequestDsl

@RequestDsl
class RequestBuilder {
    var url: String = ""
    var method: String = "GET"
    private val headers = mutableMapOf<String, String>()
    private var body: String? = null

    fun header(key: String, value: String) {
        headers[key] = value
    }
    fun body(init: BodyBuilder.() -> Unit) {
        body = BodyBuilder().apply(init).build()
    }
    fun build() = Request(url, method, headers, body)
}

// The entry point builder function
fun request(init: RequestBuilder.() -> Unit): Request =
    RequestBuilder().apply(init).build()

// Usage: reads like configuration, is fully type-checked
val req = request {
    url = "https://api.example.com/users"
    method = "POST"
    header("Authorization", "Bearer $token")
    body {
        json { "name" to "Alice" }
    }
}