Generic function declaration in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a generic function in Kotlin?

A generic function is a function that can work with any data type. It uses a placeholder type, usually written as <T>, so you can use the same function for different types without rewriting it.

beginner

How do you declare a generic function in Kotlin?

You declare a generic function by adding a type parameter in angle brackets before the function name, like this: fun <T> functionName(param: T) { ... }

beginner

Why use generic functions instead of regular functions?

Generic functions let you write one function that works with many types, so you avoid repeating code and make your code more flexible and reusable.

beginner

Example: What does this Kotlin function do?

fun <T> printItem(item: T) { println(item) }

This function prints any item you give it. The <T> means it can accept any type, like a number, text, or even a list.

intermediate

Can a generic function have more than one type parameter? How?

Yes, you can declare multiple type parameters separated by commas, like fun example(a: T, b: U) { ... } to work with two different types.

How do you start declaring a generic function in Kotlin?

A By using the keyword generic

B By adding () after the function name

C By adding <T> before the function name

D By writing fun generic()

Generic functions start with a type parameter in angle brackets, like , before the function name.

What does the <T> in a generic function represent?

A A placeholder for any type

B A specific type like Int

C A function name

D A variable

is a placeholder that can represent any type when the function is used.

Can a generic function accept different types each time it is called?

A No, it only accepts one type

B Only if the types are strings

C Only if the types are numbers

D Yes, it can accept any type

Generic functions are designed to accept any type, making them flexible.

Which of these is a correct generic function declaration?

A fun <T> show(item: T) { println(item) }

B fun show<T>(item: T) { println(item) }

C fun show(item: T) { println(item) }

D fun <T> show(item) { println(item) }

The correct syntax places before the function name and specifies the parameter type as T.

How do you declare a generic function with two type parameters?

A fun <T U> example(a: T, b: U) { }

B fun <T, U> example(a: T, b: U) { }

C fun <T; U> example(a: T, b: U) { }

D fun example<T, U>(a: T, b: U) { }

Multiple type parameters are separated by commas inside the angle brackets before the function name.

Explain how to declare and use a generic function in Kotlin with an example.

Think about how <T> works and how you can pass different types to the function.

Why are generic functions useful? Describe a real-life situation where they help.

Imagine writing one tool that works for many jobs instead of many tools for each job.