Suspend functions concept in Kotlin - Mini Project: Build & Apply

Understanding Suspend Functions in Kotlin

📖 Scenario: You are building a simple Kotlin program that simulates fetching user data from a server. Since network calls take time, you will use suspend functions to pause and resume the work without blocking the main thread.

🎯 Goal: Create a Kotlin program that defines a suspend function to simulate a delay in fetching data, then call it from a coroutine and print the result.

📋 What You'll Learn

Create a suspend function named fetchUserData that returns a String

Inside fetchUserData, simulate a delay of 1000 milliseconds using delay(1000)

Return the string "User data loaded" from fetchUserData

In the main function, launch a coroutine using runBlocking

Call fetchUserData inside the coroutine and store the result in a variable named result

Print the result variable

💡 Why This Matters

🌍 Real World

Suspend functions are used in real apps to perform tasks like network calls or database access without freezing the user interface.

💼 Career

Understanding suspend functions is essential for Kotlin developers working on Android apps or backend services that require asynchronous programming.

1

Create the suspend function fetchUserData

Write a suspend function named fetchUserData that returns a String. Inside it, use delay(1000) to simulate waiting for 1 second, then return the string "User data loaded".

Kotlin

import kotlinx.coroutines.delay

// Define suspend function fetchUserData here
# Your code here

Hint

Remember to mark the function with suspend and use delay(1000) inside it.

2

Set up the main function with runBlocking

Add a main function that uses runBlocking to start a coroutine. Import kotlinx.coroutines.runBlocking at the top.

Kotlin

import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

suspend fun fetchUserData(): String {
    delay(1000)
    return "User data loaded"
}

// Create main function with runBlocking here
# Your code here

Hint

Use fun main() = runBlocking { } to start your coroutine.

3

Call fetchUserData inside runBlocking

Inside the runBlocking block in main, call the suspend function fetchUserData() and store its result in a variable named result.

Kotlin

import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

suspend fun fetchUserData(): String {
    delay(1000)
    return "User data loaded"
}

fun main() = runBlocking {
    // Call fetchUserData and save to result
# Your code here
}

Hint

Call fetchUserData() directly inside runBlocking and assign it to result.

4

Print the result

Add a println statement inside runBlocking to print the variable result.

Kotlin

import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

suspend fun fetchUserData(): String {
    delay(1000)
    return "User data loaded"
}

fun main() = runBlocking {
    val result = fetchUserData()
    // Print the result
# Your code here
}

Hint

Use println(result) to show the output.

Practice

1. What is the main purpose of a suspend function in Kotlin?

easy

A. To mark the function as deprecated

B. To make the function run faster by using multiple threads

C. To allow the function to pause and resume without blocking the thread

D. To convert the function into a lambda expression

Solution

1. Step 1: Understand what suspend functions do

   Suspend functions let the program pause execution at some point and resume later without blocking the thread.

2. Step 2: Compare options with this behavior

   Only To allow the function to pause and resume without blocking the thread describes this pausing and resuming behavior correctly.

3. Final Answer:

   To allow the function to pause and resume without blocking the thread -> Option C

4. Quick Check:

   Suspend function purpose = pause and resume without blocking [OK]

Hint: Suspend means pause and resume without blocking [OK]

Common Mistakes:

• Thinking suspend means multithreading
• Confusing suspend with deprecated functions
• Assuming suspend converts functions to lambdas

2. Which of the following is the correct way to declare a suspend function in Kotlin?

easy

A. fun suspend fetchData() { }

B. fun fetchData() suspend { }

C. suspend fetchData fun() { }

D. suspend fun fetchData() { }

Solution

1. Step 1: Recall suspend function syntax

   The correct syntax places the suspend keyword before fun.

2. Step 2: Check each option

   Only suspend fun fetchData() { } matches the correct syntax: suspend fun fetchData() { }.

3. Final Answer:

   suspend fun fetchData() { } -> Option D

4. Quick Check:

   Suspend function syntax = suspend before fun [OK]

Hint: Remember: suspend keyword comes before fun [OK]

Common Mistakes:

• Placing suspend after fun
• Putting suspend after function name
• Mixing order of keywords

3. What will be the output of the following Kotlin code?

import kotlinx.coroutines.*
suspend fun greet() {
    delay(100)
    println("Hello from suspend")
}
fun main() = runBlocking {
    greet()
    println("Done")
}

medium

A. Hello from suspend\nDone

B. Done\nHello from suspend

C. Compilation error because greet() is suspend

D. Runtime error because delay() is not allowed here

Solution

1. Step 1: Understand runBlocking and suspend call

   runBlocking starts a coroutine and allows calling suspend functions like greet().

2. Step 2: Trace execution order

   greet() delays 100ms, then prints "Hello from suspend". After greet() finishes, main prints "Done".

3. Final Answer:

   Hello from suspend\nDone -> Option A

4. Quick Check:

   Output order = greet() then Done [OK]

Hint: runBlocking lets you call suspend functions directly [OK]

Common Mistakes:

• Assuming greet() runs asynchronously and prints after Done
• Thinking delay causes errors outside coroutine
• Confusing suspend function calls outside coroutines

4. Identify the error in this Kotlin code snippet:

fun fetchData() {
    delay(1000)
    println("Data fetched")
}

medium

A. delay() cannot be called from a non-suspend function

B. println() is not allowed inside functions

C. fetchData() must return a value

D. delay() requires an integer argument, 1000 is invalid

Solution

1. Step 1: Check usage of delay()

   delay() is a suspend function and can only be called from suspend functions or coroutines.

2. Step 2: Analyze fetchData() declaration

   fetchData() is a regular function without suspend keyword, so calling delay() inside causes an error.

3. Final Answer:

   delay() cannot be called from a non-suspend function -> Option A

4. Quick Check:

   delay() call requires suspend function context [OK]

Hint: delay() only works inside suspend functions [OK]

Common Mistakes:

• Thinking delay() works in normal functions
• Believing println() is restricted
• Confusing delay() argument type

5. You want to write a suspend function fetchUserData() that calls another suspend function fetchFromNetwork() and returns its result. Which of the following is the correct way to implement fetchUserData()?

hard

A. fun fetchUserData() = fetchFromNetwork()

B. suspend fun fetchUserData() = fetchFromNetwork()

C. fun suspend fetchUserData() = fetchFromNetwork()

D. suspend fun fetchUserData() { fetchFromNetwork() }

Solution

1. Step 1: Recognize suspend function chaining rules

   A suspend function calling another suspend function must itself be marked suspend.

2. Step 2: Check each option's syntax and behavior

   suspend fun fetchUserData() = fetchFromNetwork() correctly declares fetchUserData() as suspend and returns fetchFromNetwork() result. The option with suspend fun fetchUserData() { fetchFromNetwork() } misses returning the result. The remaining options have incorrect syntax.

3. Final Answer:

   suspend fun fetchUserData() = fetchFromNetwork() -> Option B

4. Quick Check:

   Calling suspend inside suspend requires suspend keyword [OK]

Hint: Suspend functions calling suspend must also be suspend [OK]

Common Mistakes:

• Omitting suspend keyword on calling function
• Using wrong suspend syntax order
• Not returning the result from called suspend function