When creating a program or software, functions is usually used to make a code become resuable and easy to read. In Kotlin, there are two main types of function including void function and a function that returns a value.

## Void Function

Void function is a function that does not return any values. In Kotlin, a void function is also known as a function that returns `Unit`

type.

This is the basic syntax of creating void function.

```
fun function_name(arg_name: data_type, ...) {
// code ..
}
```

In this example, the `sum()`

function is created to perform sum operation of two integers.

```
fun main() {
// call the sum function with given parameters
sum(12,24)
}
// create a sum function
// with two integers as the arguments
fun sum(numOne: Int, numTwo: Int) {
println("$numOne + $numTwo = ${numOne + numTwo}")
}
```

Output

```
12 + 24 = 36
```

Based on the code above, the `sum()`

function using two integers (`numOne`

and `numTwo`

) as the arguments. The `sum()`

function is called inside main function with given parameters.

The default argument value can be added inside function, this is the example of a function with default argument value.

```
fun main() {
// call the greet function without parameter
greet()
}
// create a greet function
// with default argument
// the default argument value is "guest"
fun greet(name: String = "guest") {
println("Hello, $name !")
}
```

Output

```
Hello, guest !
```

Based on the code above, the default argument value is used if the parameter inside the function is not specified.

## Function with Return Value

In Kotlin, the function that created can also returns certain value. This is the basic syntax of creating a function with return value.

```
// multi line
fun function_name(arg_name: data_type, ...): return_type {
// code ..
}
// single line
fun function_name(arg_name: data_type, ...) = // code..
```

In this example, the `multiply()`

and `average()`

function is created.

```
fun main() {
// call the multiply function with given parameters
val result = multiply(12,24)
println("The result of multiply operation: $result")
// call the average function with given parameters
val averageResult = average(78,90,80,67)
println("The average result: $averageResult")
}
// create a multiply function
// using single line approach
// with two integers as the arguments
fun multiply(numOne: Int, numTwo: Int) = numOne * numTwo
// create a average function
// with variadic argument of integer as the argument
fun average(vararg nums: Int): Int {
var result = 0
for (num in nums) {
result += num
}
return result / nums.size
}
```

Output

```
The result of multiply operation: 288
The average result: 78
```

Based on the code above, the `multiply()`

function contains single line of code so the single line approach is used. This is the `multiply()`

function with multi line approach.

```
fun multiply(numOne: Int, numTwo: Int): Int {
return numOne * numTwo
}
```

On the code above, the `average()`

function is also created with variadic argument of integers using `vararg`

followed with argument's name and argument's data type.

The variadic argument (

`vararg`

) also avaiable for void function.

## Overloading Functions

Overloading functions is a function with the same name but with the different arguments. This is the example of overloading mechanism for `area()`

function.

```
fun main() {
// call the functions
println("area of circle: ${area(7.0)}")
println("area of rectangle: ${area(8.0, 9.0)}")
}
// calculate area of circle
fun area(radius: Double) = Math.PI * radius * radius
// calculate area of rectangle
fun area(length: Double, width: Double) = length * width
```

Output

```
area of circle: 153.93804002589985
area of rectangle: 72.0
```

Based on the code above, the function has a same name called `area()`

but with different arguments.

## Infix Function

Infix function is a function that can be called without parentheses `()`

. This is the basic syntax to create an infix function.

```
infix fun receiver_type.func_name(arg): return_type {
// code..
}
```

There are many rules to follow when creating an infix function:

- Variadic argument is not allowed.
- The function must have one argument.
- The function type is a member or extension function.

Member function is a function that created inside class. Extension function is a function that is extended from a certain function inside library.

This is the usage example of infix function.

```
// create a class called Person
class Person(
val name: String
) {
// create an infix function
infix fun say(message: String) {
println("$name says $message")
}
}
fun main() {
// create an object from Person class
val person: Person = Person("ray krieger")
// call an infix function with parentheses
person.say("hi there!")
// call an infix function without parentheses
person say "this is fantastic"
}
```

Output

```
ray krieger says hi there!
ray krieger says this is fantastic
```

Based on the code above, the infix function is a member function inside `Person`

class. The infix function can be called with or without using parentheses.

## Lambda

Lambda is an anonymous function that can be used in Kotlin. This is the basic syntax to create a lambda in Kotlin.

```
{ parameter,... -> // code }
```

This is the usage example of lambda.

```
fun main() {
// create a lambda function
val multiply = { a: Int, b: Int -> a * b }
// call a lambda function
val result: Int = multiply.invoke(2,3)
// print out the result
println("The result is: $result")
}
```

Output

```
The result is: 6
```

Based on the code above, the lambda function is created inside `multiply`

variable. The lambda function is called using `invoke()`

method from variable that store lambda function.

The usage of lambda function can be seen in method usage for Collections like `map()`

method.

```
fun main() {
// create a collection
val list = listOf<Int>(1,2,3,4,5)
// using lambda inside map method
// to multiply every number inside collection with 3
val updatedList = list.map { num -> num * 3 }
// print out the result from map
println("Result from map")
updatedList.forEach { num -> println(num) }
}
```

Output

```
Result from map
3
6
9
12
15
```

Based on the code above, the lambda function that used inside `map`

method is `{ num -> num * 3 }`

to multiply every number inside collection with 3.

## Higher-order Function

Basically, higher-order function is a mechanism that a function is available to become argument or parameter in another function or a function could return another function or callback.

This is the usage example of higher-order function.

```
fun main() {
// create a lambda function
// that will be inserted as parameter in calculator function
val operator = { a: Int, b: Int -> a + b }
// call a calculator function with parameter
val result = calculator(4,5, operator)
// print out the result
println("The result is: $result")
}
// create a calculator function with these arguments:
// 1. x and y with Int data type
// 2. operator is a function with two integer arguments that returns integer "(Int, Int) -> Int"
fun calculator(x: Int, y: Int, operator: (Int, Int) -> Int): Int {
// returns the result of lambda function execution
// that stored inside operator argument
return operator.invoke(x,y)
}
```

Output

```
The result is: 9
```

Based on the code above, the `calculator`

function is created with many arguments including `x`

and `y`

with `Int`

data type and `operator`

is a function type that has two `Int`

arguments with return type is `Int`

. The `calculator`

function is called inside main method with specified parameters.

## Recursive Function

Recursive function is a function that called itself. Recursive function can be used to solve many problems like fibonacci number calculation.

This is the example of using recursive function to solve fibonacci calculation.

```
fun main() {
// call the fib function
println(fibonacci(5))
}
fun fibonacci(n: Int): Int {
if(n <= 2)
return 1
else
return fibonacci(n - 1) + fibonacci(n - 2)
}
```

Output

```
5
```

Based on the code above, there are two main components inside recursive function:

Base case: is a case or condition that define when the recursive function is stopped. The base case inside that function is if the value of

`n`

is less than or equals 2.Recursive case: is a case or condition that define when the certain code is executed until the base case. The recursive case inside that function is to sum two previous numbers (

`fibonacci(n - 1) + fib(n - 2)`

).

This is the illustration of how the recursive function works.

## Notes

- In Kotlin, the parameter's name inside function can be defined. This is the example.

```
fun main() {
// call a function with parameter's name
val result = plus(x = 3, y = 9)
// print out the result
println(result)
}
// create a function
fun plus(x: Int, y: Int): Int {
return x + y
}
```

Output

```
12
```

## Sources

Learn more about function in this link.

Learn more about infix function in this link.

Learn more about lambda in Kotlin in this link.

Learn more about higher-order function in this link.

I hope this article is helpful for learning the Kotlin programming language. If you have any thoughts or comments you can write in the discussion section below.

## Top comments (4)

Good one. Infix function is new to me. :)

Thanks

Very nice content. I think you could have your own website for this.

What did you use to make your illustrations, like in the fibonnacci's ?

Thanks, I use draw.io to make the illustration in this post. You can use draw.io in this link: app.diagrams.net/.