Have you used inline functions in your project?

Yes, I have used it. Mainly for implementing high-level functions that accept other functions as parameters (lambda expressions).

Advantages of using inline functions in my project:

• Reducing overhead: The compiler substitutes the body of the inline function directly at the call site, avoiding the creation of a function object and calling through it. This is especially useful when working with small lambdas that are often passed as parameters or used in loop constructs.
• Improved performance: By eliminating calls and object creation for functions, inline functions can execute code faster, especially in hot spots of the application.
• Using non-local returns: return inside an inline lambda can exit from the enclosing function, not just the lambda itself. This allows writing more concise code for certain scenarios, such as iterating over collections with early exit.

Examples of usage:

Some standard Kotlin functions, such as forEach or use, are inline functions, and their use inherently results in inlining.

// Example of using the standard inline function forEach
val list = listOf(1, 2, 3)
list.forEach {
    // The lambda body will be inlined
    println(it)
}

I have created custom inline functions for abstracting typical resource operations or for implementing DSLs.

// Example of a simple inline function for closing a resource
inline fun <T : AutoCloseable, R> T.useResource(block: (T) -> R): R {
    var exception: Throwable? = null
    try {
        return block(this)
    } catch (e: Throwable) {
        exception = e
        throw e
    } finally {
        closeQuietly(exception)
    }
}

private fun AutoCloseable.closeQuietly(cause: Throwable? = null) {
    try {
        close()
    } catch (closeException: RuntimeException) {
        // Log or handle exception during closing
    }
}

// Usage
FileInputStream("file.txt").useResource { inputStream ->
    // Reading from inputStream
}

It is important to note that inlining is not always the best solution. Excessive use of inline functions, especially with large bodies, can lead to increased bytecode size. I try to apply them where there is measurable benefit for performance or where they simplify the code without significantly increasing its size.