Kotlin Extensions — Extension Functions and Properties Guide

// Extension on String
fun String.isEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

// Extension on Int
fun Int.isEven(): Boolean = this % 2 == 0

// Extension on List
fun <T> List<T>.secondOrNull(): T? {
    return if (this.size >= 2) this[1] else null
}

fun main() {
    println("test@example.com".isEmail())  // Output: true
    println("hello".isEmail())             // Output: false
    
    println(4.isEven())  // Output: true
    println(5.isEven())  // Output: false
    
    println(listOf(1, 2, 3).secondOrNull())  // Output: 2
    println(listOf(1).secondOrNull())        // Output: null
    println(emptyList<Int>().secondOrNull()) // Output: null
    
    // Chaining extensions
    val result = "Hello, Kotlin!"
        .filter { it.isLetterOrDigit() || it == ' ' }
        .split(" ")
        .map { it.uppercase() }
        .joinToString("-")
    println(result)  // Output: HELLO-KOTLIN
}

// Extension property on String
val String.wordCount: Int
    get() = this.split("\\s+".toRegex()).size

val String.isNullOrBlank: Boolean
    get() = this.isBlank()

// Extension property on IntRange
val IntRange.halfway: Int
    get() = (this.first + this.last) / 2

// Extension property on collections
val <T> List<T>.middleItem: T?
    get() = if (isEmpty()) null else this[size / 2]

fun main() {
    val text = "Kotlin extension functions are powerful"
    println(text.wordCount)  // Output: 5
    
    println((1..10).halfway)  // Output: 5
    println((0..100).halfway) // Output: 50
    
    println(listOf("a", "b", "c", "d", "e").middleItem)  // Output: c
    println(emptyList<Int>().middleItem)  // Output: null
}

// Extension on nullable String
fun String?.isNullOrEmail(): Boolean {
    if (this == null) return false
    return contains("@") && contains(".")
}

// Extension on nullable List
fun <T> List<T>?.nullSafeSize(): Int {
    return this?.size ?: 0
}

fun String?.toSafeLength(): Int {
    return this?.length ?: 0
}

fun main() {
    val valid: String? = "user@example.com"
    val invalid: String? = "not-an-email"
    val nullStr: String? = null
    
    println(valid.isNullOrEmail())    // Output: true
    println(invalid.isNullOrEmail())  // Output: false
    println(nullStr.isNullOrEmail())  // Output: false (no NPE)
    
    println(listOf(1, 2, 3).nullSafeSize())  // Output: 3
    val nullList: List<Int>? = null
    println(nullList.nullSafeSize())          // Output: 0
    
    println(nullStr.toSafeLength())  // Output: 0
}

class MyClass {
    companion object {
        const val VERSION = "1.0.0"
    }
}

// Extension on companion object
fun MyClass.Companion.createDefault(): MyClass {
    println("Creating default instance (version $VERSION)")
    return MyClass()
}

fun MyClass.Companion.fromConfig(config: Map<String, String>): MyClass {
    println("Creating from config with ${config.size} entries")
    return MyClass()
}

// Extension on any companion
fun <T> T.Companion.safeCall(block: () -> T): T? {
    return try {
        block()
    } catch (e: Exception) {
        println("Error: ${e.message}")
        null
    }
}

fun main() {
    val instance = MyClass.createDefault()
    // Output: Creating default instance (version 1.0.0)
    
    val configured = MyClass.fromConfig(mapOf("key" to "value"))
    // Output: Creating from config with 1 entries
}

open class Shape
class Circle : Shape()

fun Shape.describe() = "I am a Shape"
fun Circle.describe() = "I am a Circle"

fun main() {
    val shape: Shape = Circle()
    println(shape.describe())  // Output: I am a Shape (static dispatch)
    
    val circle: Circle = Circle()
    println(circle.describe())  // Output: I am a Circle
    
    // Import extensions from other files
    // import com.example.extensions.isEmail
    // "test@test.com".isEmail()  // Available after import
}

// In file com/example/strings.kt
package com.example.strings
fun String.reverse(): String = this.reversed()

// In another file
import com.example.strings.reverse
// Now "hello".reverse() is available

class Greeter {
    fun greet() = println("Hello from member")
}

fun Greeter.greet() = println("Hello from extension")

fun main() {
    val greeter = Greeter()
    greeter.greet()  // Output: Hello from member
}

// Generic extension on List
fun <T> List<T>.second(): T {
    if (size < 2) throw NoSuchElementException("List has less than 2 elements")
    return this[1]
}

// Generic extension with type constraint
fun <T : Comparable<T>> List<T>.maxOrFallback(fallback: T): T {
    return this.maxOrNull() ?: fallback
}

// Extension on Map with specific types
fun Map<String, Any?>.toConfigString(): String {
    return this.entries.joinToString("\n") { (key, value) ->
        "$key = $value"
    }
}

fun main() {
    println(listOf("a", "b", "c").second())  // Output: b
    
    val numbers = listOf(3, 7, 1, 9, 4)
    println(numbers.maxOrFallback(0))  // Output: 9
    
    val emptyList = emptyList<Int>()
    println(emptyList.maxOrFallback(-1))  // Output: -1
    
    val config = mapOf("host" to "localhost", "port" to 8080)
    println(config.toConfigString())
    // Output:
    // host = localhost
    // port = 8080
}

fun String.slugify(): String {
    return this.lowercase()
        .replace(Regex("[^a-z0-9\\s-]"), "")
        .replace(Regex("[\\s-]+"), "-")
        .trim('-')
}

fun String.truncate(maxLength: Int, ellipsis: String = "..."): String {
    return if (this.length <= maxLength) this
           else this.take(maxLength - ellipsis.length) + ellipsis
}

val String.wordCount: Int
    get() = this.split(Regex("\\s+")).size

val String.readingTimeMinutes: Int
    get() = (this.wordCount / 200).coerceAtLeast(1)

fun String.extractHashtags(): List<String> {
    return Regex("#\\w+").findAll(this).map { it.value.lowercase() }.toList()
}

fun main() {
    val title = "Kotlin Extension Functions: A Complete Guide!"
    println(title.slugify())       // Output: kotlin-extension-functions-a-complete-guide
    
    val longText = "This is a very long text that needs to be truncated for display in a list view"
    println(longText.truncate(30))  // Output: This is a very long text ...
    
    val article = "Kotlin is a modern language. It runs on JVM. It is fun."
    println(article.wordCount)           // Output: 12
    println("${article.readingTimeMinutes} min read")  // Output: 1 min read
    
    val post = "Loving #Kotlin and #Extensions! #coding #100DaysOfCode"
    println(post.extractHashtags())  // Output: [#kotlin, #extensions, #coding, #100daysofcode]
}