Functions and lambdas in Android Kotlin

Introduction

Functions help you organize code into reusable blocks. Lambdas let you write small, quick functions without naming them.

When you want to repeat a task multiple times without rewriting code.

When you need to pass a small piece of code as a parameter to another function.

When you want to keep your code clean and easy to read by breaking it into parts.

When handling user actions like button clicks with simple code blocks.

When working with collections to transform or filter data quickly.

Syntax

Android Kotlin

fun functionName(parameter: Type): ReturnType {
    // code
}

val lambdaName: (Type) -> ReturnType = { parameter ->
    // code
}

Functions start with fun keyword, followed by name and parameters.

Lambdas are anonymous functions assigned to variables or passed directly.

Examples

A simple function that takes a name and returns a greeting.

Android Kotlin

fun greet(name: String): String {
    return "Hello, $name!"
}

A lambda doing the same greeting without a function name.

Android Kotlin

val greetLambda: (String) -> String = { name -> "Hello, $name!" }

Short function that adds two numbers and returns the result.

Android Kotlin

fun add(a: Int, b: Int) = a + b

Lambda that adds two numbers, types are declared inline.

Android Kotlin

val addLambda = { a: Int, b: Int -> a + b }

Sample App

This program shows a function and a lambda that both calculate the square of a number. It prints the results to the console.

Android Kotlin

fun main() {
    fun square(x: Int): Int {
        return x * x
    }

    val squareLambda: (Int) -> Int = { x -> x * x }

    println("Function: square(4) = ${square(4)}")
    println("Lambda: squareLambda(4) = ${squareLambda(4)}")
}

Important Notes

Lambdas are great for short tasks but use functions for bigger, reusable code blocks.

You can pass lambdas directly to functions that expect them, like collection operations.

Use descriptive names for functions to make your code easier to understand.

Summary

Functions group code to reuse and organize it.

Lambdas are unnamed, quick functions useful for small tasks.

Both help keep your app code clean and easy to maintain.

Practice

1. What is a lambda function in Kotlin?
val sum = { a: Int, b: Int -> a + b }

easy

A. A function that must have a name and cannot be stored

B. An unnamed function that can be stored in a variable

C. A special class for storing data

D. A type of loop for repeating code

Solution

1. Step 1: Understand lambda syntax

   The code { a: Int, b: Int -> a + b } defines a function without a name.

2. Step 2: Identify lambda characteristics

   This function is stored in the variable sum, showing it is unnamed but reusable.

3. Final Answer:

   An unnamed function that can be stored in a variable -> Option B

4. Quick Check:

   Lambda = unnamed function stored in variable [OK]

Hint: Lambdas have no name and are assigned to variables [OK]

Common Mistakes:

• Thinking lambdas must have names
• Confusing lambdas with classes
• Assuming lambdas are loops

2. Which of the following is the correct syntax to declare a lambda that takes no parameters and returns a String "Hello"?

easy

A. val greet = fun() { return "Hello" }

B. val greet = () -> "Hello"

C. val greet = { -> "Hello"

D. val greet = { "Hello" }

Solution

1. Step 1: Review lambda syntax for no parameters

   Lambdas with no parameters use { expression } syntax.

2. Step 2: Check each option

   val greet = { "Hello" } correctly uses { "Hello" }. val greet = { -> "Hello" missing closing brace, B is function type syntax, D is a named function.

3. Final Answer:

   val greet = { "Hello" } -> Option D

4. Quick Check:

   No-parameter lambda = { value } [OK]

Hint: Use { expression } for lambdas with no parameters [OK]

Common Mistakes:

• Missing closing brace in lambda
• Confusing lambda with function type syntax
• Using fun keyword inside lambda

3. What is the output of this Kotlin code?

val multiply = { x: Int, y: Int -> x * y }
println(multiply(3, 4))

medium

A. 7

B. 34

C. 12

D. Error

Solution

1. Step 1: Understand the lambda function

   The lambda { x: Int, y: Int -> x * y } multiplies two integers.

2. Step 2: Calculate the result of multiply(3, 4)

   3 * 4 equals 12, so the printed output is 12.

3. Final Answer:

   12 -> Option C

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Multiply inputs inside lambda to get output [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Expecting syntax error

4. Identify the error in this Kotlin lambda declaration:

val greet = { name: String ->
  println("Hello, " + name)
}

medium

A. No error, this is valid syntax

B. Cannot use println inside lambda

C. Missing return type declaration

D. Lambda must return a value, println returns Unit

Solution

1. Step 1: Check lambda syntax

   The lambda takes a String parameter and calls println, which is allowed.

2. Step 2: Confirm return type flexibility

   Lambdas can return Unit (like void), so no return type declaration is needed.

3. Final Answer:

   No error, this is valid syntax -> Option A

4. Quick Check:

   Lambda with println is valid [OK]

Hint: Lambdas can return Unit; println is allowed [OK]

Common Mistakes:

• Expecting return type declaration
• Thinking println is disallowed
• Confusing Unit with error

5. You want to filter a list of numbers to keep only even numbers using a lambda. Which code correctly does this?

val numbers = listOf(1, 2, 3, 4, 5, 6)
val evens = numbers.filter( /* fill here */ )
println(evens)

hard

A. numbers.filter { it % 2 == 0 }

B. numbers.filter { x -> x / 2 == 0 }

C. numbers.filter { it % 2 = 0 }

D. numbers.filter { it & 2 == 0 }

Solution

1. Step 1: Understand filtering with lambda

   The filter lambda should return true for even numbers using modulo operator.

2. Step 2: Evaluate each option

   numbers.filter { it % 2 == 0 } correctly uses it % 2 == 0. numbers.filter { x -> x / 2 == 0 } uses division instead of modulo, C uses assignment (=) instead of comparison (==), A uses bitwise AND incorrectly.

3. Final Answer:

   numbers.filter { it % 2 == 0 } -> Option A

4. Quick Check:

   Filter even numbers with modulo == 0 [OK]

Hint: Use it % 2 == 0 to check even numbers in filter [OK]

Common Mistakes:

• Using = instead of == for comparison
• Using division instead of modulo
• Misusing bitwise operators