# AndroidBites #Metas: fun in functions?

Let's explore what is the meaning of functions as first-class citizen in Kotlin

Hi! Welcome to my ongoing series of AndroidBites where we discuss bite-size information on some core concepts of programming, Today we are exploring some fun in the functions of Kotlin,

Kotlin has functions as a first-class citizen if you're wondering what that means then it's simply a function is primitive type in kotlin, which means it can be stored into variables and data structures, passed as arguments to and returned from other functions, i.e support for Higher-Order Functions.

# Structure of a function

A function consists of some components :

**fun**as keyword to declare the start of the function.**Function name**which is used for its invocation.- Some
**arguments/parameters**as a dependency for its operations. - A
**Return type**to return a result of the computation. - A
**function body**

that computes the result.**{ . . . }** - A
**Signature of the function:**if you observe closely, you can see another construct of the function i.e`(A,B)->C`

, where`A and B`

is the type of parameter, and`C`

is the return type, this defines the signature of the function and Kotlin uses it to provide high order functionality.

# Fun into variables.

- All function types have a parenthesized parameter types list and a return type.
`(A,B)->C`

, where`A and B`

is the type of parameter, and`C`

is the return type

example

`val sum = fun(param1:Int,param2:Int):Int {return param1+param2 }`

val shortHandSum: (Int,Int)->Int = {p1,p2 -> p1+p2 }

2. The parameter types list may be empty, as in `()->A`

. The Unit return type cannot be omitted.

example

val hello = fun():Unit {println("Hello functions") }

val shortHello: ()->Unit = println("Hello functions")

3. Function types can have an additional **receiver type**, which is specified before a dot in the notation: the type `A.(B)->C`

example

val printInt = fun Int.():Unit { println(this) }

val shortPrintInt : Int.()->Unit = { println(this) }

4. Suspending functions start with a suspend modifier in the notation, such as `suspend ()->Unit OR suspend A.(B)->C`

`suspend ()->Unit`

is not supported for variable holding, but shortHand way is supported.

example

val plus = suspend { fun Int.(other:Int):Unit { println(this+other) } }

val suspendSum : suspend (Int,Int)->Int = {p1,p2-> println(this+that) }

# Fun into Functions.

function returning a function signature can be used for a function returning a function.

var functionA: ((Int) -> Int) = {

println("func a")

2

}var functionB: (Int) -> ((Int) -> Int) = {

println("func b")

functionA

}// function call

valresultA =functionB(1) // returnfunctionAvalresult = resultA(5) // return 2val shortCall =functionB(1)(5) // return 2

passing a function signature into a function parameter is used for passing a function into a function

valsum={p1:Int,p2:Int->p1+p2}

valsub={p1:Int,p2:Int->p1-p2}funcalculate(p1: Int, p2: Int, operation: (Int, Int) -> Int):Int {

returnoperation.invoke(p1,p2)

}//function call

calculate(5,6,sum)

calculate(5,6,sub)

//or

calculate(2,4){p1 , p2->sum22.invoke(p1,p2)}

the type of `(Int->((Int)->Unit))`

=`(Int)->(Int)->Unit)`

!= `((Int)->(Int))->Unit`

# Function type

The way your storing function can define what kind of type it would end up in.

- function declared directly into the variable using function body
`{ . . . }`

are called**Lambda functions**. example*val sum = {p1,p2 -> p1+p2 }* - function declaration, whose just name is omitted out end up
**Anonymous function**. an example*val sum = fun(p1:Int,p2:Int):Int = p1 + p2* - function that uses additional receivers is called
**Extension function**. example*val printInt = fun Int.():Unit { println(this) }*

most of the time lambda functions ~ anonymous function,

Key difference in Kotlin is that

- when you want a return to a block of code to from the enclosing function lambda use lambda
- when you want to return from the block but not from the enclosing function use anonymous function

**Bonus**

## Closures

Closures are functions that can access and modify properties defined outside the scope of the function. example:

**var **total = 0

listOf(1,2,3,4,5,6,7,8,9,10).forEach{

total = total+it

}

# The End.

Congratulations you made it till the end!. if you found anything interesting feel free to share in response. Happy Coding!