Function declaration syntax in Kotlin - Step-by-Step Execution

Concept Flow - Function declaration syntax

Start

↓

Write 'fun' keyword

↓

Name the function

↓

Add parentheses ()

↓

Optional: Add parameters inside ()

↓

Optional: Specify return type after ':'

↓

Write function body inside curly braces {}

↓

Function ready to be called

↓

End

This flow shows the steps to write a Kotlin function: start with 'fun', name it, add parameters and return type if needed, then write the body.

Execution Sample

Kotlin

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

Defines a function named greet that takes a name and returns a greeting string.

Execution Table

Step	Action	Code Part	Result
1	Write function keyword	fun	Marks start of function declaration
2	Name the function	greet	Function named greet
3	Add parameters	(name: String)	One parameter named name of type String
4	Specify return type	: String	Function returns a String
5	Write function body	return "Hello, $name!"	Returns greeting string with name
6	Function declared	fun greet(name: String): String { ... }	Function ready to be called

💡 Function declaration complete and ready for use.

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
name	undefined	String parameter	String parameter	String parameter
return value	undefined	undefined	"Hello, $name!"	"Hello, $name!"

Key Moments - 3 Insights

Why do we write 'fun' before the function name?

In Kotlin, 'fun' tells the compiler that we are declaring a function. See execution_table step 1.

What happens if we omit the return type?

If omitted, Kotlin assumes the function returns Unit (like void). Here, return type is specified at step 4.

Why are parentheses needed even if there are no parameters?

Parentheses mark the parameter list. Even empty, they are required to define a function. See step 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the function name at step 2?

A fun

B name

C greet

D String

💡 Hint

Check the 'Code Part' column at step 2 in execution_table.

At which step is the return type specified?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look for ': String' in the 'Code Part' column in execution_table.

If we remove the parentheses, what part of the flow breaks?

A Adding parameters

B Writing the function body

C Naming the function

D Specifying return type

💡 Hint

Parentheses are needed to hold parameters, see concept_flow step 'Add parentheses ()'.

Concept Snapshot

fun functionName(parameters): ReturnType {
    // function body
}

- 'fun' starts the declaration
- Name the function after 'fun'
- Parameters go inside ()
- Return type after ':' (optional)
- Body inside curly braces {}

Full Transcript

This lesson shows how to write a function in Kotlin. First, write the keyword 'fun' to start. Then give your function a name. Next, add parentheses to hold parameters. You can specify the return type after a colon. Finally, write the function body inside curly braces. The example defines a greet function that takes a name and returns a greeting string. The execution table breaks down each step of writing this function. Variables like 'name' and the return value are tracked through the steps. Common confusions include why 'fun' is needed, the role of parentheses, and the return type. The quiz checks understanding of these parts. Remember, this is the basic syntax to declare functions in Kotlin.