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

Concept Flow - Function declaration syntax

Start

↓

Write 'func' keyword

↓

Name the function

↓

Add parentheses ()

↓

Add parameters (optional)

↓

Add return type (optional) -> Type

↓

Write function body inside { }

↓

Function ready to call

↓

End

This flow shows the steps to write a function in Swift: start with 'func', name it, add parameters and return type if needed, then write the code inside braces.

Execution Sample

Swift

func 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	Declare function with name and parameter	func greet(name: String) -> String {	Function greet declared
2	Write return statement	return "Hello, \(name)!"	Returns greeting string
3	Close function body	}	Function body ends
4	Call function with argument 'Alice'	greet(name: "Alice")	Returns 'Hello, Alice!'

💡 Function declaration ends after closing brace; calling function returns greeting string.

Variable Tracker

Variable	Start	After Call
name	undefined	"Alice"
return value	undefined	"Hello, Alice!"

Key Moments - 3 Insights

Why do we write parentheses () after the function name even if there are no parameters?

Parentheses indicate a function call or definition. Even if no parameters exist, parentheses are required to show it is a function, as seen in step 1 of the execution_table.

What does the arrow '-> String' mean in the function declaration?

The arrow '-> String' means the function will return a value of type String. This is shown in step 1 where the return type is declared and in step 2 where the return statement provides the string.

Can a function have no return type or parameters?

Yes, a function can have no parameters and no return type. In that case, parentheses are empty and no arrow is used. This is part of the syntax flow in the concept_flow.

Visual Quiz - 3 Questions

Look at the execution_table, what is the function name declared at step 1?

A greet

B name

C return

D String

💡 Hint

Check the 'Code Part' column in step 1 of the execution_table.

At which step does the function return the greeting string?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Action' and 'Result' columns in the execution_table for the return statement.

If we remove '-> String' from the function declaration, what changes in the execution?

A Function parameters change

B Function no longer returns a value

C Function name changes

D Function body must be empty

💡 Hint

Refer to the key_moments about the meaning of '-> String' in the function declaration.

Concept Snapshot

Swift function declaration syntax:
func functionName(parameters) -> ReturnType {
    // code
}
- 'func' starts declaration
- Parentheses hold parameters or are empty
- '-> ReturnType' is optional
- Body is inside braces
- Call with functionName(args)

Full Transcript

This visual execution shows how to declare a function in Swift. First, write the keyword 'func', then the function name, followed by parentheses for parameters. Optionally, add a return type after an arrow. Inside braces, write the code to run when the function is called. The example defines a function greet that takes a name and returns a greeting string. The execution table traces declaration steps and a call with 'Alice' returning 'Hello, Alice!'. Variables like 'name' and the return value change during the call. Key moments clarify why parentheses are needed, what the return type means, and that functions can have no parameters or return type. The quiz tests understanding of function name, return step, and effect of removing return type. The snapshot summarizes the syntax and usage for quick reference.