Declaration Forms

A local function is a function declared inside another function. The main reason to use one is to reuse a small piece of logic that only matters to the surrounding function, while reading its local variables directly.

Named arguments let you pass a value by writing the parameter's name, like draw(width = 5). This makes calls easier to read and lets you supply only the arguments you want, in any order.

The :: operator turns a named function into a value you can store in a variable or pass to another function, instead of calling it. The result is a function object you can invoke later.

It is a function whose body is a single expression written after an equals sign instead of curly braces. For example: fun square(x: Int) = x * x. The result of the expression is what the function returns.

A function written directly in a file, not inside any class. You declare it with the fun keyword at the top of the file and call it just by its name after importing it.

Unit is Kotlin's type for functions that do useful work but return no meaningful value. It is like Java's void, but it is a real type with one value. You can leave it out of the signature.

vararg lets a function accept any number of arguments of one type. You call it like f(1, 2, 3) and inside the function you read them as an array you can loop over.

The default expression runs every time the function is called without that argument. It is not computed once and cached, so each defaulted call re-evaluates it freshly.

You can start a call with positional arguments and then switch to named ones, but once you use a name you generally must keep naming the rest. In modern Kotlin you may put positional arguments after named ones as long as they land in the right positions.

An unbound reference (String::length) leaves the object out, so you must pass it in as the first argument. A bound reference ("hello"::length) already fixes the object, so you just invoke it with no extra argument.

The compiler can usually figure out the return type from the expression, so you can leave it off. But for public API functions, recursive functions, or when you want a different type than what is inferred, you should write the type explicitly.

The compiler can't put free functions in bytecode, so it creates a hidden class named after the file (e.g. Utils.kt becomes UtilsKt) and makes the function a public static method on that class.

Nothing is the type for code that never returns normally — it always throws, loops forever, or stops the program. A function returning Nothing tells the compiler the line after it is unreachable.

Put a * before the array when you call the function: printAll(*myArray). The * unpacks the array so each element is passed as a separate argument instead of one array argument.

Java does not understand Kotlin default arguments, so it sees only the full-parameter version. Adding @JvmOverloads tells the compiler to generate extra Java-visible overloads, one per defaulted parameter, so Java callers can omit them.

Put the recursive part in a function declared inside the public one. It keeps the recursion private and lets it reuse the outer parameters, so the public function's signature stays clean and the helper can't be misused from outside.

In a local function, a plain return just exits that local function. In a lambda, a plain return is only allowed when the lambda is inlined, and then it exits the whole outer function. That difference trips people up.

Use a local function for multi-step named helper logic, especially if it must recurse or read clearly. Use a lambda when you need to pass behavior as a value into another function, like into map or forEach.

When a function has default values, you can leave out a middle parameter by naming the later ones you want to set. Without named arguments you'd have to repeat every value up to the last one you care about.

Writing ::ClassName gives you a reference to the constructor — a function value that creates instances. You can pass it anywhere a factory function is expected, and calling it builds a new object.

In Kotlin, if, when, and try all produce values, so you can use one of them as the single expression after the equals sign. This lets a one-line function branch or handle errors while still returning the result of that branch.

Java calls the function as a static method on the generated file class, like FileNameKt.functionName(args). The function name and the 'Kt' suffix matter, and Kotlin-only features may not map cleanly.

Because a throw or a Nothing function can stand in for any type, you can put it after Elvis (?:) to get a non-null value or bail out. The compiler knows that path can't continue, so code after it is dead.

Yes. In one call you can write individual values and spread arrays together, like f(0, *arr, 9). Kotlin combines them in the exact left-to-right order you wrote them into one array for the function.

An overriding function must not declare its own default values; it inherits them from the base. This avoids ambiguity about which default applies when you call through a base-type reference.

Kotlin lets a local function change an outer var. Behind the scenes the variable is boxed in a small holder object so both the outer code and the inner function see the same value. Changes made inside are visible outside.

Java bytecode usually doesn't keep parameter names, so Kotlin can't reliably match a name to a Java method's parameter. Therefore Kotlin forbids named arguments on calls to Java methods; you must pass them positionally.

Kotlin uses the surrounding context — the expected function type — to pick the matching overload. If nothing constrains the type and several overloads fit, it's ambiguous and the compiler reports an error until you add a type.

If the single expression returns nothing useful (Unit), the function silently returns Unit, which may not be what you intended. Also, beginners sometimes confuse the body equals sign with assigning a lambda, accidentally returning a function instead of calling it.