Functions In Kotlin

Function

Function is a set of code which may take some parameters, perform certain operations on them, and then may return a value.

Kotlin uses "fun" keyword to declare a function, and you can use traditional ways, like C, C++, and Java, to call them.

General Syntax

<Access specifire> fun
    <Function name>(parametors) : returntype
    {
      //body statements. return
        <value>;
    }

Example

Printing a message using function                                            

fun main(args: Array < String > )
{
    println("Message=" + welcomeMessage())
}
fun welcomeMessage(): String {
    var msg: String = "Hello Android"
    return msg
}
// output: Message=Hello Android

Passing Parameters

Function parameters are defined as name: type. Parameters are separated using comma. Each parameter must be explicitly typed.

fun main(args: Array < String > )
{
    println("area of square=" + area(5))
}
fun area(x: Int): Int {
    return x * x
}
//output:  area of square=25

Default Arguments

You can use the default value of parameter when the corresponding parameter is omitted.

fun read(off: Int = 0, length: Int = b.size) { //body statements}

• Default values are defined using the =after type along with the value.
• Overriding methods always use the same default parameter values as the base method.

Named Argument

You can name a list of parameters for making it readable and for convenience.

fun sample(pwd: String, wordseparator: Char = ’_’, uppercase: Boolean = true, lowercse: Boolean = true, number: Boolean = true, specialchar: Boolean = true)
{
  // body statements…………………
}

Now, you can call this function like this –

sample(pwd)

or  sample(pwd,true,true,true)

Unit Returning Type 

It is optional return type. Suppose, you do not want to return any value/data from Function. You can use Unit type.

Example

fun main(args: Array < String > ) {
    showMessage();
}
fun showMessage(): Unit {
    println("Hello Android")
}
//output: Hello Android

Lambda Function 

Syntax

val functionName = {
    param_var: Type - > operation
}
or
val functionname: (param_Type) - > return_Type = {
    operation on param here
}
now you can use it as traditional
function call i.e.–
function_name(param)

Example

Create a lambda function to calculate the area of a rectangle.

val area =
  {
    width: Double,
    height: Double - > width * height
} //lambda function to calculate area
fun main(args: Array < String > ) {
    println("Area of Rectangle=" + area(5.5, 5.5))
}
//output: Area of Rectangle=30.25

Inline Function

When you use the inline keyword with function, it copies the body statement of the inline function at its invoking code which reduces the control jumping from calling statement to a definition of the function.

Example

Write a program to illustrate inline function.

inline fun printMessage(message: () - > Unit) {
    println("Line before calling lambda function")
    message()
    println("Line after calling lambda function")
}
fun main(args: Array < String > ) {
    printMessage {
        println("Calling exact function")
    }
}
/*

Output:

Line before calling lambda function

Calling exact function

Line after calling lambda function

*/

Use ctrl+shift+A to get the search dialog and search here for Kotlin bytecode. You can see the bytecode so now, decompile this bytecode which will be visible in Java.            

public final class Example_inline_lambdaKt {
   public static final void printMessage(@NotNull Function0 message) {
      Intrinsics.checkParameterIsNotNull(message, "message");
      String var2 = "Line before calling lambda function";
      System.out.println(var2);
      message.invoke();
      var2 = "Line after calling lambda function";
      System.out.println(var2);
   }

   public static final void main(@NotNull String[] args) {
      Intrinsics.checkParameterIsNotNull(args, "args");
      String var1 = "Line before calling lambda function";
      System.out.println(var1);
      String var2 = "Calling exact function";
      System.out.println(var2);
      var1 = "Line after calling lambda function";
      System.out.println(var1);
   }
}

tailrec function [Recursive Function]

Recursive functions are those functions which call themselves several times within their body .You can use ’tailrec’ keyword before fun keyword in function definition. This keyword prevents the program from stack overflow.  Let us understand working of this keyword with an example-

Example

Write a program to find n^th number of  Fibonacci series.

import java.math.BigInteger
fun main(args: Array < String > ) {
    println("factorial =" + getfabinockyNum(10000, BigInteger("1"), BigInteger("1")))
}
tailrec fun getfabinockyNum(n: Int, a: BigInteger, b: BigInteger): BigInteger {
    if (n == 0) {
        return b
    } else {
        return getfabinockyNum(n - 1, a + b, a)
    }
} //output: factorial .=54438373113565281338734260993750380135389184554695967…………768..23814710669912644214775254478587674568963808002962265133111359929762726679441400101575800043510777465935805362502461707918059226414679005690752321895868142367849593880756423483754386342639635970733756260098962462668746112041739819404875062443709868654315626847186195620146126642232711815040367018825205314845875817193533529827837800351902529239517836689467661917953884712441028463935449484614450778762529520961887597272889220768537396475869543159172434537193611263743926337313005896167248051737986306368115003088396749587102619524631352447499505204198305187168321623283859794627245919771454628218399695789223798912199431775469705216131081096559950638297261253848242007897109054754028438149611930465061866170122983288964352733750792786069444761853525144421077928045979904561298129423809156055033032338919609162236698759922782923191896688017718575555520994653320128446502371153715141749290913104897203455577507196645425232862022019506091483585223882711016708433051169942115775151255510251655931888164048344129557038825477521111577395780115868397072602565614824956460538700280331311861485399805397031555727529693399586079850381581446276433858828529535803424850845426446471681531001533180479567436396815653326152509571127480411928196022148849148284389124178520174507305538928717857923509417743383331506898239354421988805429332440371194867215543576548565499134519271098919802665184564927827827212957649240235507595558205647569365394873317659000206373126570643509709482649710038733517477713403319028105575667931789470024118803094604034362953471997461392274791549730356412633074230824051999996101549784667340458326852960388301120765629245998136251652347093963049734046445106365304163630823669242257761468288461791843224793434406079917883360676846711185597501

• Without using ‘tailrec’ keyword, this program will return ‘StackOverflow ’ exception.

High Order Functions

When a function has a function as a parameter, it is called high order function .To understand better with user defined function, see the example of Inline Function.

fun main(args: Array < String > )
{
    var data = mutableListOf < Int > (1, 2, 3, 4, 5)
    data.forEach {
        println(it)
    }
}
//output :
1
2
3
4
5

Explanation

In this example, ‘forEach()’ has a method println() as a parameter. It takes a single element of the list one by one and put it in variable ‘it’ which will be printed using println() method. This is the abbreviated code of data.forEach{println(it)}.

For(x in data)
{
    println(x)
}