Suspend functions concept in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple suspend function call

What is the output of this Kotlin code using a suspend function?

Kotlin

import kotlinx.coroutines.*

suspend fun greet(): String {
    delay(100)
    return "Hello, Kotlin!"
}

fun main() = runBlocking {
    val message = greet()
    println(message)
}

A Compilation error: suspend function called from non-suspend context

B Hello, Kotlin!

C Hello, Kotlin!\nHello, Kotlin!

D Runtime exception: Unresolved reference: delay

💡 Hint

Remember that suspend functions must be called from a coroutine or another suspend function.

The suspend function greet() is called inside runBlocking, which is a coroutine builder. The delay suspends the coroutine without blocking the thread, then returns the string. The println prints the returned string.

🧠 Conceptual

intermediate

Understanding suspend function behavior

Which statement best describes what happens when a suspend function is called in Kotlin?

A It suspends the coroutine without blocking the thread, allowing other coroutines to run.

B It runs the function in a new thread automatically.

C It blocks the current thread until the function completes.

D It converts the function into a callback-based asynchronous function.

💡 Hint

Think about how suspend functions help with concurrency without blocking threads.

Suspend functions suspend the coroutine they run in, freeing the thread to do other work. They do not block the thread or create new threads automatically.

🔧 Debug

advanced

Identify the error in suspend function usage

What error will this Kotlin code produce when compiled and run?

Kotlin

suspend fun fetchData(): String {
    return "Data"
}

fun main() {
    val result = fetchData()
    println(result)
}

A Compilation error: suspend function fetchData() called from non-suspend function main()

B Compilation error: missing coroutine context

C Output: Data

D Runtime error: suspend function cannot be called directly

💡 Hint

Check where suspend functions can be called from.

Suspend functions can only be called from other suspend functions or coroutine builders. Calling fetchData() directly in main() causes a compilation error.

📝 Syntax

advanced

Correct syntax for calling a suspend function

Which option correctly calls the suspend function fetchUser() and prints its result?

Kotlin

suspend fun fetchUser(): String {
    delay(50)
    return "User123"
}

A

fun main() {
    val user = fetchUser()
    println(user)
}

B

suspend fun main() = coroutineScope {
    val user = fetchUser()
    println(user)
}

C

fun main() {
    GlobalScope.launch {
        val user = fetchUser()
        println(user)
    }
}

D

fun main() = runBlocking {
    val user = fetchUser()
    println(user)
}

💡 Hint

Remember that runBlocking is a coroutine builder that blocks the main thread until completion.

Option D uses runBlocking to call the suspend function fetchUser() properly and prints the result synchronously. Option D calls suspend function directly causing compile error. Option D launches a coroutine but main returns immediately, so println may not run before program ends. Option D is valid syntax if main is suspend, but typically main is not suspend in Kotlin JVM apps; however, the original Option D was invalid syntax because coroutineScope cannot be called like that in main without suspend. Corrected Option D marks main as suspend.

🚀 Application

expert

Predict the output of nested suspend functions with delay

What will be printed when running this Kotlin program?

Kotlin

import kotlinx.coroutines.*

suspend fun first(): String {
    delay(100)
    return "First"
}

suspend fun second(): String {
    delay(50)
    return "Second"
}

fun main() = runBlocking {
    val result = "${first()} and ${second()}"
    println(result)
}

A Compilation error: suspend functions cannot be called inside string templates

B Second and First

C First and Second

D Runtime error: IllegalStateException

💡 Hint

Suspend functions inside string templates are evaluated sequentially in runBlocking.

Inside runBlocking, the suspend functions first() and second() are called sequentially inside the string template. first() delays 100ms, then second() delays 50ms. The final string is 'First and Second'.

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