Nested functions in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a nested function inside the outer function.

Swift

func outer() {
    func [1]() {
        print("Hello from inner")
    }
    inner()
}

Drag options to blanks, or click blank then click option'

Aprint

Bouter

Cinner

Dcall

Attempts:

3 left

💡 Hint

Common Mistakes

Using the outer function name inside the nested function definition.

Trying to call a function that is not defined.

The nested function inside outer() is named inner. This name is used to define and call it.

2fill in blank

medium

Complete the code to return the result of the nested function.

Swift

func outer() -> Int {
    func [1]() -> Int {
        return 5
    }
    return inner()
}

Drag options to blanks, or click blank then click option'

Ainner

Bouter

Cresult

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Returning the outer function name instead of the nested function.

Using a name not defined as a function.

The nested function inner() returns an integer, and outer() returns the result of calling inner().

3fill in blank

hard

Fix the error in the nested function call by completing the blank.

Swift

func outer() {
    func inner() {
        print("Inside inner")
    }
    [1]()
}

Drag options to blanks, or click blank then click option'

Aouter

Binner

Cprint

Dcall

Attempts:

3 left

💡 Hint

Common Mistakes

Calling the outer function inside itself.

Using a function name that does not exist.

The nested function inner() must be called by its name inside outer().

4fill in blank

hard

Fill both blanks to create a nested function that adds two numbers and returns the sum.

Swift

func addNumbers(a: Int, b: Int) -> Int {
    func [1]() -> Int {
        return a [2] b
    }
    return sum()
}

Drag options to blanks, or click blank then click option'

Asum

B+

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong operator like - or *.

Naming the nested function differently than the call.

The nested function is named sum and returns the addition of a and b using the + operator.

5fill in blank

hard

Fill all three blanks to create a nested function that multiplies a number by itself and returns the result.

Swift

func calculateSquare(number: Int) -> Int {
    func [1]() -> Int {
        return number [2] number
    }
    return [3]()
}

Drag options to blanks, or click blank then click option'

Asquare

B*

C+

Dmultiply

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition instead of multiplication.

Calling a function name that does not exist.

The nested function is named square, multiplies number by itself using *, and is called by square().

Practice

1. What is a nested function in Swift?

easy

A. A function that calls itself

B. A function that returns another function

C. A function defined inside another function

D. A function defined outside any class or struct

Solution

1. Step 1: Understand the definition of nested functions

   Nested functions are functions written inside other functions to organize code better.

2. Step 2: Match the definition to the options

   A function defined inside another function correctly describes a function inside another function, which is the definition of nested functions.

3. Final Answer:

   A function defined inside another function -> Option C

4. Quick Check:

   Nested function = function inside function [OK]

Hint: Nested means inside another function [OK]

Common Mistakes:

• Confusing nested with recursive functions
• Thinking nested functions are global
• Mixing nested with returning functions

2. Which of the following is the correct syntax to define a nested function in Swift?

easy

A. func outer() { func inner() { } }

B. func outer() { func inner; }

C. func outer() { inner func() { } }

D. func outer() { func inner() }

Solution

1. Step 1: Review Swift function syntax

   Functions are defined with 'func name() { }'. Nested functions follow the same syntax inside another function.

2. Step 2: Check each option for correct syntax

   func outer() { func inner() { } } uses correct syntax with braces for both outer and inner functions. Others have missing braces or wrong order.

3. Final Answer:

   func outer() { func inner() { } } -> Option A

4. Quick Check:

   Nested function syntax = func inside func with braces [OK]

Hint: Look for 'func' with braces inside another function [OK]

Common Mistakes:

• Omitting braces for inner function
• Using semicolon instead of braces
• Placing 'func' keyword incorrectly

3. What will be the output of the following Swift code?

func greet() {
    func sayHello() {
        print("Hello")
    }
    sayHello()
}
greet()

medium

A. Hello

B. No output

C. Error: sayHello not found

D. HelloHello

Solution

1. Step 1: Understand function calls inside nested functions

   The outer function 'greet' defines 'sayHello' inside it and calls it once.

2. Step 2: Trace the execution

   Calling 'greet()' runs 'sayHello()', which prints "Hello" once.

3. Final Answer:

   Hello -> Option A

4. Quick Check:

   Nested call prints once = Hello [OK]

Hint: Inner function called once inside outer function [OK]

Common Mistakes:

• Thinking inner function runs twice
• Assuming inner function is global
• Expecting no output because inner function is nested

4. Identify the error in this Swift code using nested functions:

func calculate() {
    innerFunc() 
    func innerFunc() {
        print("Inside inner")
    }
}
calculate()

medium

A. No error, code runs fine

B. Missing return type for innerFunc

C. innerFunc cannot be nested inside calculate

D. innerFunc() called before its definition causes error

Solution

1. Step 1: Analyze function call order

   The code calls 'innerFunc()' before it is defined inside 'calculate()'. Swift requires functions to be defined before use.

2. Step 2: Understand Swift's function declaration rules

   Calling a nested function before its declaration causes a compile-time error.

3. Final Answer:

   innerFunc() called before its definition causes error -> Option D

4. Quick Check:

   Call before definition = error [OK]

Hint: Define nested functions before calling them [OK]

Common Mistakes:

• Assuming nested functions can be called before definition
• Thinking missing return type causes error here
• Believing nested functions can't be defined inside

5. How can you use nested functions to create a function that returns another function which adds a fixed number to its input? Choose the correct Swift code.

hard

A. func makeAdder(_ x: Int) -> Int {
func adder(y: Int) -> Int {
return x + y
}
return adder(5)
}

B. func makeAdder(_ x: Int) -> (Int) -> Int {
func adder(y: Int) -> Int {
return x + y
}
return adder
}

C. func makeAdder(_ x: Int) -> (Int) -> Int {
return func(y: Int) -> Int { x + y }
}

D. func makeAdder(_ x: Int) -> (Int) -> Int {
func adder(y: Int) -> Int {
return y
}
return adder
}

Solution

1. Step 1: Understand the goal

   We want a function that returns another function adding a fixed number 'x' to input 'y'.

2. Step 2: Check each option's logic

   func makeAdder(_ x: Int) -> (Int) -> Int { func adder(y: Int) -> Int { return x + y } return adder } defines nested 'adder' using 'x' and returns it correctly. func makeAdder(_ x: Int) -> Int { func adder(y: Int) -> Int { return x + y } return adder(5) } returns a value, not a function. func makeAdder(_ x: Int) -> (Int) -> Int { return func(y: Int) -> Int { x + y } } has invalid syntax. func makeAdder(_ x: Int) -> (Int) -> Int { func adder(y: Int) -> Int { return y } return adder } returns a function ignoring 'x'.

3. Final Answer:

   func makeAdder(_ x: Int) -> (Int) -> Int { func adder(y: Int) -> Int { return x + y } return adder } -> Option B

4. Quick Check:

   Nested function returns function adding x = func makeAdder(_ x: Int) -> (Int) -> Int { func adder(y: Int) -> Int { return x + y } return adder } [OK]

Hint: Return nested function that uses outer parameter [OK]

Common Mistakes:

• Returning a value instead of a function
• Incorrect nested function syntax
• Ignoring outer function parameter inside nested function