This chapter will focus on exploring a number of Kotlin features that can help to write functions and interfaces that are robust, flexible, and clean. After reading the following recipes, you will understand the language-specific support and approach for boilerplate code reduction and runtime performance improvements. You will also understand the way functions of the standard library are implemented under the hood and how to work with them effectively.

When creating new functions, we often need to allow some of their parameters to be optional. This forces us to use method overloading to create multiple function declarations with the same name but different sets of arguments related to different use cases and scenarios. Usually, under the hood, each variant of the function is calling the base function with the default implementation. Let's consider a simple example of a function that calculates a displacement of an object moving with a constant acceleration rate:

fun calculateDisplacement(initialSpeed: Float, 
                          acceleration: Float, 
                          duration: Long): Double =
    initialSpeed * duration + 0.5 * acceleration * duration * duration

We might also need to provide a displacement calculation for the scenario where the initial speed...

Kotlin makes the interface a powerful language element by offering the possibility to declare default implementations for its functions and to define default values of its properties. Those features bring the interface to a whole new level, allowing you to use it for more advanced applications than simple contract declarations.

In this recipe, we are going to define a reusable interface responsible for validating email address values entered by a user into the input field in an abstract registration form. The interface will provide two functions. The first one is responsible for parsing the email address and deciding if the given value is a valid email address, and the second one responsible for extracting a user's login from the email text entered into the form.

While working on implementing new features or refactoring of existing code, we often end up extracting some part of the code to functions in order to reuse them in different places. If the extracted function is atomic enough, we often end up exporting it to external utility classes whose primary purpose is to extend functionalities of existing classes. Kotlin provides an interesting alternative to the utility classes. It offers a built-in feature allowing us to extend functionalities of other classes with extension functions and extension properties.

In this recipe, we are going to extend the functionality of the Array<T> class and add a swap(a:T, b: T) extension function to it, which is responsible for changing places of a two given elements of the array.

It is often practical to convert a single object of a complex type into a number of variables. This allows you to provide proper naming for the variables and simplifies the code. Kotlin provides an easy, built-in way to achieve this with a feature called destructuring:

data class User(val login: String, val email: String, val birthday: LocalDate)

fun getUser() = User("Agata", "ag@t.pl", LocalDate.of(1990, 1, 18))

val (name, mail, birthday) = getUser()

print("$name was born on $birthday")

As a result, this piece of code would print the following message to the console:

Agata was born on 1990-01-18

Although Kotlin doesn't provide a multiple return feature, thanks to data classes and destructuring declarations, it is quite convenient to write functions that return a number of values of different types. In this recipe, we are going to implement a function returning the result of dividing two numbers. The result is going to contain the quotient and remainder values.

1. Let's start with declaring a data class for the return type:

data class DivisionResult(val quotient: Int, val remainder: Int)

2. Let's implement the divide() function:

fun divide(dividend: Int, divisor: Int): DivisionResult {
    val quotient = dividend.div(divisor)
    val remainder = dividend.rem(divisor...

Usage of higher-order functions can lead to a decrease of runtime performance. Memory allocations of the functions passed as lambda arguments and their virtual calls in a function body lead to runtime overhead. However, in many cases, we can eliminate this type of overhead by inlining the lambda expression parameters.

In this recipe, we are going to implement the lock() function that will automate work with the Java java.util.concurrent.locks.Lock interface. The function will take two arguments—an instance of the Lock interface and the function that should be invoked after the lock is acquired. Finally, our lock() function should release the lock. We also want to allow making the function parameter inlined.

To bring our code closer to the natural language, Kotlin provides infix notations for the functions containing a single parameter. This way, we can invoke the function without using brackets. In this recipe, we are going to learn how to design an infix extension function for the String type, named concat(), which is responsible for the concatenation of two string values.

In order to enable an infix notation for the function, we simply need to add the infix keyword before the function header.

Declare the concat...

While implementing functions that support generic type arguments, we often deal with the need to provide additional information about object types at runtime. On the JVM platform, types have their representations in the Class<T> class instances. For example, we can face such a need while parsing JSON formatted data to the Kotlin class instances using the Gson library:

data class ApiResponse(val gifsWithPandas: List<ByteArray>)
data class Error(val message: String)

fun parseJsonResponse(json: String): ApiResponse {
    Gson().fromJson(json, ApiResponse::class.java)
}

Normally, we can't access the generic type argument at runtime because of a JVM types erasure. However, Kotlin allows you to overcome this limitation because it preserves the type argument at runtime. In this recipe, we are going to tune up Gson&apos...

The Kotlin language provides a set of operators which have their own symbol (for example, +, -, *, or /) and a priority defined. At the time of compilation, the Kotlin compiler transforms them into associated function calls or even more complex statements. We are also able to override an operator and declare its custom underlying implementation for a specified type. This implementation would be applied to the instances of the specified type the operator was used with.

In this recipe, we are going to define a class called Position, representing the current coordinates of the point in a three-dimensional space. Then, we are going to implement custom plus and minus operators for our class to provide a simple way of applying a geometric transformation to its instances. As a result, we want to be able to update the coordinates of the point represented by the...