Kotlin Use function – Syntax & Example

Kotlin Use function

Kotlin use function is an inline extension function used to run a block of code on a closeable resource and then close that resource after the block finishes. It is commonly used with files, readers, streams, sockets, and other objects that must be closed after use.

The main advantage of Kotlin use is safer resource handling. The resource is closed after the operation is completed, and it is also closed when an exception occurs inside the block. This helps avoid resource leaks in file handling and I/O code.

Use function could be thought of as try with resource in Java.

For general function declaration rules in Kotlin, you may also refer to the official Kotlin functions documentation. This tutorial focuses specifically on the use function for closing resources.

When to use Kotlin use function for Closeable resources

Use the Kotlin use function when an object has to be closed after work is complete. Typical examples include BufferedReader, InputStream, OutputStream, FileReader, and other Java I/O resources used from Kotlin.

• Use use when the resource should be opened, processed, and closed in one local block.
• Do not call close() manually after use; the function handles closing.
• Keep the code inside the use block focused on the work that needs the resource.
• Use the value returned by the block when you want to read or compute something from the resource.

Syntax of Kotlin Use function

The syntax of use function is

inline fun <T : Closeable?, R> T.use(block: (T) -> R): R (source)

where

• block is the function to process the Closeable resource.
• fun returns the result of block function.

In simple words, T is the resource type and R is the return type of the block. The lambda receives the resource as its argument, runs the required operation, and returns a result if needed.

resource.use { resourceReference ->
    // work with resourceReference
}

If the lambda has only one parameter, Kotlin lets you refer to it as it. You can also give it a meaningful name such as reader when that makes the code easier to read.

Example 1 – Kotlin Use function

In this example, we will call use function on BufferedReader().

Kotlin Program – example.kt

import java.io.File

fun main(args: Array<String>) {
    val file = File("file.txt")
    file.bufferedReader().use{
        println(it.readText())
    }
}

The program opens file.txt, creates a buffered reader, reads the complete file content, prints it, and closes the reader automatically after the use block ends.

Output

Good Day !
Welcome to Kotlin Tutorials by www.tutorialkart.com.

Process finished with exit code 0

Kotlin use function with a named lambda parameter

The previous example uses it inside the block. For short blocks, it is fine. For larger blocks, a named parameter such as reader can make the code clearer.

import java.io.File

fun main() {
    val file = File("file.txt")

    file.bufferedReader().use { reader ->
        val firstLine = reader.readLine()
        println(firstLine)
    }
}

Here, reader is the BufferedReader received by the lambda. After readLine() completes, Kotlin closes the reader automatically.

Returning a value from Kotlin use function

The use function returns the result of the lambda block. This means you can assign the value produced inside the block to a variable.

import java.io.File

fun main() {
    val file = File("file.txt")

    val textLength = file.bufferedReader().use { reader ->
        reader.readText().length
    }

    println(textLength)
}

In this example, the last expression inside the use block is reader.readText().length. That value becomes the return value of use and is stored in textLength.

How to run a Kotlin function that uses use

A Kotlin program starts from the main() function. To run a function that uses use, define the function and call it from main().

import java.io.File

fun readFileText(path: String): String {
    return File(path).bufferedReader().use { reader ->
        reader.readText()
    }
}

fun main() {
    val content = readFileText("file.txt")
    println(content)
}

The function readFileText() returns the file content as a string. The main() function calls it and prints the returned value.

Kotlin use function compared with try-finally close

Without use, resource closing is usually written with try and finally. Kotlin use keeps the same idea but reduces boilerplate.

import java.io.File

fun main() {
    val reader = File("file.txt").bufferedReader()

    try {
        println(reader.readText())
    } finally {
        reader.close()
    }
}

The same operation can be written more compactly with use.

import java.io.File

fun main() {
    File("file.txt").bufferedReader().use { reader ->
        println(reader.readText())
    }
}

Both versions close the reader, but the use version makes the resource lifecycle easier to see.

Common mistakes with Kotlin use function

• Using the resource outside the block: After the use block ends, the resource is closed. Do not read from it later.
• Adding manual close calls inside the block: In most cases, calling close() manually inside use is unnecessary and can make the code harder to follow.
• Using use for non-closeable values: The function is meant for resources that implement a close operation, such as readers and streams.
• Hiding too much logic inside one block: If the block becomes long, move parsing or processing logic into separate Kotlin functions.

Kotlin use function FAQ

Editorial QA checklist for Kotlin use function examples

• Check that every new code example uses a resource that can be closed, such as a reader or stream.
• Confirm that the code does not use the reader after the use block has ended.
• Verify that output blocks show only program output and use the output class.
• Use language-kotlin for Kotlin code blocks and add syntax only for syntax-only snippets.
• Keep explanations specific to Kotlin use, resource closing, and return values.

Conclusion

In this Kotlin Tutorial – Kotlin Use Function, we have learnt to use given block function on a resource.

The use function is most useful when working with closeable resources. It keeps file and stream handling concise, closes the resource automatically, and can also return a value from the block.