Named Parameters in Kotlin

A parameter is a value that you can pass to a method. Then the method can use the parameter as though it were a local variable initialized with the value of the variable passed to it by the calling method. Function parameters are defined using Pascal notation – name: type. Parameters are separated using commas, and each parameter must be explicitly typed:

fun powerOf(number: Int, exponent: Int): Int { /*...*/ }

Example

Named parameters in Kotlin allow us to be explicit about naming arguments when passed to a function. This has the benefit that for functions with many parameters, explicit naming makes the intent of each argument clear. This makes the call site more readable. In the following example, we check to see whether the first string contains a substring of the second:

val string = "a kindness of ravens"
string.regionMatches(14, "Red Ravens", 4, 6, true)

To use named parameters, we put the parameter name before the argument value. Here is the function call again, this time with named parameters:

string.regionMatches(thisOffset = 14, other = "Red Ravens",
otherOffset = 4, length = 6, ignoreCase = true)

This second example is more readable at the cost of being more verbose, but it is now clear what each of the parameters is meant for. The final Boolean, which you might have guessed was case sensitivity, is now obvious. If you don’t have named parameters, you must check the documentation or source code. Another benefit is that for functions with multiple parameters of the same type, it makes errors less likely as the values can be associated with the name. In the next example, you will see how the function accepts multiple Boolean parameters. And without named parameters, it is easy to swap arguments erroneously:

fun deleteFiles(filePattern: String, recursive: Boolean, ignoreCase:
Boolean, deleteDirectories: Boolean): Unit

Compare the two different styles of calling this function:

deleteFiles("*.jpg", true, true, false)
deleteFiles("*.jpg", recursive = true, ignoreCase = true,deleteDirectories = false)

Did you notice that the first parameter is not named, even when the others are? When calling a function, not all parameters need to be named. The rule is simple: once a parameter has been named, all the following parameters must be named too. Named parameters also allow the parameter order to be changed to suit the caller. For example, the following two examples are equivalent:

val string = "a kindness of ravens"
string.endsWith(suffix = "ravens", ignoreCase = true)
string.endsWith(ignoreCase = true, suffix = "ravens")

Why this is useful will be demonstrated in the next section on default parameters. Changing the order of parameters allows us to selectively choose which default parameters to override. 

Conclusion

Named parameters can only be used on Kotlin-defined functions and not on Java-defined functions. This is because the Java code when compiled into bytecode does not always preserve the parameter names.