Function declaration syntax in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

How do you declare a simple function in Kotlin that takes no parameters and returns no value?

Use the fun keyword followed by the function name and empty parentheses. For example:

fun greet() {
    println("Hello!")
}

beginner

What is the syntax to declare a Kotlin function that returns an integer?

Specify the return type after the parameter list with a colon. For example:

fun add(a: Int, b: Int): Int {
    return a + b
}

beginner

How do you declare a Kotlin function with parameters?

Inside the parentheses after the function name, list parameters with their names and types separated by commas. For example:

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

intermediate

What is a single-expression function in Kotlin and how is it declared?

A function that returns a single expression can be declared using the = sign without curly braces. For example:

fun square(x: Int): Int = x * x

intermediate

Can Kotlin functions have default parameter values? How do you declare them?

Yes, you can assign default values to parameters in the declaration. For example:

fun greet(name: String = "Guest") {
    println("Hello, $name!")
}

Which keyword is used to declare a function in Kotlin?

A fun

B function

C def

D func

In Kotlin, the keyword fun is used to declare functions.

How do you specify the return type of a Kotlin function?

A Inside the function body

B After the function name, before parentheses

C After the parameter list, separated by a colon

D You cannot specify return types in Kotlin

The return type is specified after the parameter list with a colon, like fun f(): Int.

What is the correct way to declare a function with a single expression in Kotlin?

A Use = sign followed by the expression without curly braces

B Use parentheses around the expression

C Use the keyword 'single' before fun

D Use curly braces and return statement

Single-expression functions use = followed by the expression, no curly braces needed.

How do you provide a default value for a function parameter in Kotlin?

A Kotlin does not support default parameter values

B Using : after the parameter name

C Inside the function body only

D Using = after the parameter type in the declaration

Default values are assigned with = after the parameter type, e.g., name: String = "Guest".

Which of these is a valid Kotlin function declaration?

A def greet() { println("Hi") }

B fun greet() { println("Hi") }

C function greet() { println("Hi") }

D func greet() { println("Hi") }

Only fun is the correct keyword for Kotlin function declarations.

Explain how to declare a Kotlin function with parameters and a return type.

Think about the order: fun, name, parameters, return type, then body.

Describe what a single-expression function is in Kotlin and how to write one.

It's a short way to write functions that return one thing.

Practice

1. Which of the following is the correct way to declare a simple function named greet in Kotlin that takes no parameters and returns no value?

easy

A. function greet() { println("Hello") }

B. fun greet() { println("Hello") }

C. def greet() { println("Hello") }

D. fun greet { println("Hello") }

Solution

1. Step 1: Identify the correct keyword for function declaration

   Kotlin uses the keyword fun to declare functions. Options using function or def are incorrect.

2. Step 2: Check the function syntax for parameters and braces

   The function must have parentheses even if there are no parameters, so fun greet { println("Hello") } is incorrect because it misses parentheses.

3. Final Answer:

   fun greet() { println("Hello") } -> Option B

4. Quick Check:

   fun + name + () + body = B [OK]

Hint: Remember: Kotlin functions start with 'fun' and need parentheses [OK]

Common Mistakes:

• Using 'function' or 'def' instead of 'fun'
• Omitting parentheses for parameter list
• Missing curly braces for function body

2. Which of the following is the correct syntax to declare a function add that takes two Int parameters and returns their sum as an Int?

easy

A. fun add(a: Int, b: Int): Int { a + b }

B. fun add(a Int, b Int): Int { return a + b }

C. fun add(a: Int, b: Int) -> Int { return a + b }

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

Solution

1. Step 1: Check parameter declaration syntax

   Parameters must be declared as name: Type, so fun add(a Int, b Int): Int { return a + b } is incorrect because it misses colons.

2. Step 2: Verify return type and function body syntax

   fun add(a: Int, b: Int): Int = a + b uses the correct syntax with an expression body and return type. fun add(a: Int, b: Int) -> Int { return a + b } uses '->' which is invalid in Kotlin. fun add(a: Int, b: Int): Int { a + b } misses the return keyword in a block body, so it won't return the sum.

3. Final Answer:

   fun add(a: Int, b: Int): Int = a + b -> Option D

4. Quick Check:

   fun + parameters with colons + : ReturnType + = expression = A [OK]

Hint: Use colons for types and '=' for single-expression functions [OK]

Common Mistakes:

• Omitting colons between parameter names and types
• Using '->' instead of ':' for return type
• Missing 'return' in block body functions

3. What is the output of the following Kotlin code?

fun multiply(x: Int, y: Int): Int {
    return x * y
}

fun main() {
    println(multiply(3, 4))
}

medium

A. 12

B. 34

C. 7

D. Error

Solution

1. Step 1: Understand the multiply function

   The function takes two integers and returns their product using return x * y.

2. Step 2: Calculate the function call multiply(3, 4)

   3 multiplied by 4 equals 12, so the function returns 12.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Multiply parameters and check return value [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Assuming syntax error due to missing expression body

4. Identify the error in the following Kotlin function declaration:

fun divide(a: Int, b: Int): Int {
    return a / b

medium

A. Missing closing brace '}'

B. Incorrect return type

C. Parameters should not have types

D. Function name is invalid

Solution

1. Step 1: Check function syntax completeness

   The function body starts with '{' but there is no closing '}', so the code is incomplete.

2. Step 2: Verify other syntax parts

   The return type is correct, parameters have types, and the function name is valid, so no other errors.

3. Final Answer:

   Missing closing brace '}' -> Option A

4. Quick Check:

   All blocks need matching braces [OK]

Hint: Count opening and closing braces carefully [OK]

Common Mistakes:

• Forgetting to close function body with '}'
• Misplacing colons in parameters
• Using invalid function names

5. You want to declare a Kotlin function formatName that takes two parameters: firstName and lastName (both Strings), and returns a single String in the format "Last, First". Which of the following is the correct declaration and implementation?

hard

A. fun formatName(firstName: String, lastName: String): Int = "$lastName, $firstName"

B. fun formatName(firstName String, lastName String) = lastName + ", " + firstName

C. fun formatName(firstName: String, lastName: String): String { return "$lastName, $firstName" }

D. fun formatName(firstName: String, lastName: String): String { "$lastName, $firstName" }

Solution

1. Step 1: Check parameter and return type syntax

   Parameters must use name: Type and return type must match. A uses : Int but returns String (type mismatch). B misses colons (firstName String invalid).

2. Step 2: Verify function body syntax

   C has block body { "$lastName, $firstName" } without return, returns Unit not String. D correctly uses block body with return and string interpolation.

3. Final Answer:

   fun formatName(firstName: String, lastName: String): String { return "$lastName, $firstName" } -> Option C

4. Quick Check:

   Correct types + block body with return + interpolation = D [OK]

Hint: Use return keyword in block body functions for clarity [OK]

Common Mistakes:

• Omitting return keyword in block body
• Missing return type declaration
• Incorrect string concatenation or interpolation