Kotlin Standard Library and DSLs: Extensions, Collections, Fluent APIs & Comprehensive Examples

Table of Contents

1. What is the Kotlin Standard Library (stdlib)?

The Kotlin Standard Library (stdlib) is a collection of core APIs and utilities provided by Kotlin, extending the Java standard library with Kotlin-specific enhancements. It includes functions for collections, strings, ranges, and more, enabling concise, idiomatic Kotlin code.

Key Features:

Use Case: Everyday programming tasks like data manipulation, string processing, and concurrency.

Key Components:

2. Can you give an example of using the Kotlin Standard Library?

fun main() {
    // Collections: Create list and use higher-order functions
    val numbers = listOf(1, 2, 3, 4, 5)
    val evens = numbers.filter { it % 2 == 0 }
    val squares = evens.map { it * it }
    val sum = squares.fold(0) { acc, i -> acc + i }
    
    println("Numbers: $numbers")
    println("Evens: $evens")
    println("Squares: $squares")
    println("Sum: $sum")
    
    // Strings: Extension functions
    val text = "  Hello, Kotlin!  "
    val trimmed = text.trim()
    val upper = trimmed.uppercase()
    val words = text.split(",")
    
    println("Original: '$text'")
    println("Trimmed: '$trimmed'")
    println("Uppercase: '$upper'")
    println("Words: $words")
    
    // Ranges
    for (i in 1..3) {
        println("Range: $i")
    }
}

Output:

Numbers: [1, 2, 3, 4, 5]
Evens: [2, 4]
Squares: [4, 16]
Sum: 20
Original: '  Hello, Kotlin!  '
Trimmed: 'Hello, Kotlin!'
Uppercase: 'HELLO, KOTLIN!'
Words: [  Hello, Kotlin!  ]
Range: 1
Range: 2
Range: 3

3. What are DSLs in Kotlin?

Domain-Specific Languages (DSLs) are specialized languages tailored for a particular domain, built using Kotlin's flexible syntax. Kotlin excels at DSLs due to infix functions, operator overloading, and extension functions, enabling readable, fluent APIs.

Types:

Key Features:

Use Case: Building configuration files, query builders, or testing frameworks.

4. How do you create a DSL in Kotlin?

Use infix, extension functions, and operators to create fluent, readable syntax.

Syntax:

infix fun Any.to(other: Any): Pair<Any, Any> = Pair(this, other)

Use Case: DSL for building queries or configurations.

5. Can you give an example of a DSL in Kotlin?

class QueryBuilder {
    private var selectClause = ""
    private var fromClause = ""
    private var whereClause = ""
    
    fun select(columns: String): QueryBuilder {
        selectClause = "SELECT $columns"
        return this
    }
    
    infix fun from(table: String): QueryBuilder {
        fromClause = "FROM $table"
        return this
    }
    
    fun where(condition: String): QueryBuilder {
        whereClause = "WHERE $condition"
        return this
    }
    
    fun build(): String {
        return "$selectClause $fromClause $whereClause"
    }
}

// Usage
fun main() {
    val query = QueryBuilder()
        .select("name, salary")
        .from("employees")
        .where("salary > 50000")
        .build()
    
    println("Generated Query: $query")
    
    // Infix usage
    val pair = "Krishna" to 60000
    println("Pair: $pair")
}

Output:

Generated Query: SELECT name, salary FROM employees WHERE salary > 50000
Pair: (Krishna, 60000)

6. Can you provide a comprehensive example using Kotlin Standard Library and DSLs?

import kotlin.math.sqrt

class DataProcessor {
    private val data = mutableListOf<Pair<String, Double>>()
    
    fun add(item: Pair<String, Double>): DataProcessor = apply {
        data.add(item)
    }
    
    infix fun filterByValue(threshold: Double): DataProcessor = apply {
        data.retainAll { it.second > threshold }
    }
    
    fun map(transform: (Pair<String, Double>) -> Double): List<Double> {
        return data.map { transform(it) }
    }
    
    fun fold(initial: Double, operation: (Double, Double) -> Double): Double {
        return data.fold(initial) { acc, pair -> operation(acc, pair.second) }
    }
    
    fun build(): String {
        val avg = data.map { it.second }.average()
        val stats = "Data: $data, Average: $avg"
        return stats
    }
}

// Usage
fun main() {
    val processor = DataProcessor()
        .add("Krishna" to 60000.0)
        .add("Ram" to 55000.0)
        .add("Kristal" to 70000.0)
        .filterByValue(58000.0)
    
    val squares = processor.map { sqrt(it.second) }
    val sum = processor.fold(0.0) { acc, value -> acc + value }
    
    println("Squares: $squares")
    println("Sum: $sum")
    println(processor.build())
}

Output:

Squares: [244.9489742783178, 264.5751311064591]
Sum: 130000.0
Data: [(Krishna, 60000.0), (Kristal, 70000.0)], Average: 65000.0

7. What are common mistakes with Kotlin Standard Library and DSLs?

Standard Library:

DSLs:

General:

8. What are best practices for Kotlin Standard Library and DSLs?

Standard Library:

DSLs:

General: