Kotlin Functions and Project Setup

fun square(x: Double) = x * x // x is a parameter

fun main() {
    println(square(10.0)) // 10.0 is an argument
}

Read-Only Parameters and Shadowing

In Kotlin, function parameters are read-only. This means you cannot reassign a value to a parameter inside the function body.

fun a(i: Int) {
    i = i + 10 // ERROR: Cannot reassign a parameter
}

If you absolutely must modify the value, you can use variable shadowing by creating a new mutable variable with the same name.

[!WARNING] While shadowing works, it is not recommended to use the same name for a local variable as a parameter because it can make the code confusing to read.

Types of Functions in Kotlin

Kotlin is highly flexible, allowing you to define functions at different levels of scope.

1. Top-level functions: Defined in a file but outside of any class.
2. Member functions: Defined inside a class or object (often called methods).
3. Local functions: Defined inside another function, making them accessible only within that specific scope.

Single-Expression Functions

For simple functions that only perform one calculation, Kotlin offers a concise syntax called single-expression functions. You can omit the curly braces and the return keyword by using the = operator.

// Standard way
fun square(x: Double): Double {
    return x * x
}

// Single-expression way
fun square(x: Double): Double = x * x

// Even more concise (type inference)
fun square(x: Double) = x * x

Advanced Function Features

Unit Return Type

In many languages, a function that doesn't return a value is considered "void." In Kotlin, every function returns something. If you don't specify a return type, the default is Unit.

fun someFunction() {} // Returns Unit implicitly
fun explicitFunction(): Unit { return Unit } // Explicitly returns Unit

Varargs, Named Arguments, and Defaults

Kotlin provides several tools to make function calls more readable and flexible:

• Vararg: The vararg modifier allows a parameter to accept any number of arguments. Inside the function, these are treated as an Array.
• Default Arguments: You can assign default values to parameters, allowing you to call a function without providing every single argument.
• Named Arguments: When calling a function, you can specify the name of the parameter to ensure the right value goes to the right place, especially when using default values.

Function Overloading

You can have multiple functions with the same name, provided they have a different argument list. This means they must differ in either the number of parameters or the types of the parameters.

Infix Notation

If a function has exactly one parameter, you can use the infix modifier. This allows you to call the function without using dots or parentheses, making the code read more like a natural sentence.

// Regular notation
interactor.clicks(aView)

// Infix notation
interactor clicks aView

[!TIP] When your function declaration becomes too long, use proper formatting by placing each parameter on its own line to maintain readability.