Why Functions and closures in iOS Swift? - Purpose & Use Cases

The Big Idea

What if you could write a task once and use it everywhere without copying it?

The Scenario

Imagine you want to repeat a task many times in your app, like showing a greeting message in different places. Without functions, you'd have to write the same code again and again, which is tiring and confusing.

The Problem

Writing the same code multiple times makes your app bigger and harder to fix. If you want to change the greeting, you must find and update every copy. This wastes time and can cause mistakes.

The Solution

Functions let you write a task once and use it anywhere by calling its name. Closures are like mini-functions you can create on the spot, making your code neat and flexible.

Before vs After

✗ Before

print("Hello, User!")
print("Hello, User!")
print("Hello, User!")

✓ After

func greet() {
  print("Hello, User!")
}
greet()
greet()
greet()

What It Enables

Functions and closures let you build apps that are easier to read, fix, and grow with less effort.

Real Life Example

In a weather app, you can write a function to format temperature once, then use it everywhere to show consistent info without repeating code.

Key Takeaways

Functions save you from repeating code.

Closures let you create quick, reusable code blocks.

Both make your app cleaner and easier to manage.

Practice

1. What is a closure in Swift?
func greet() { print("Hello") }

easy

A. An unnamed block of code that can be stored and passed around

B. A named function that cannot be reused

C. A variable that holds a number

D. A type of loop

Solution

1. Step 1: Understand closure definition

   A closure is a block of code without a name that can be saved and used later.

2. Step 2: Compare with function

   Functions have names, closures do not but both can be reused.

3. Final Answer:

   An unnamed block of code that can be stored and passed around -> Option A

4. Quick Check:

   Closure = unnamed reusable code block [OK]

Hint: Closures are like functions without names [OK]

Common Mistakes:

• Confusing closures with variables
• Thinking closures must have names
• Mixing closures with loops

2. Which of the following is the correct syntax to declare a closure that takes no parameters and returns an Int?

easy

A. let closure = (Int) -> { return 5 }

B. let closure = { () -> Int in return 5 }

C. let closure = func() -> Int { return 5 }

D. func closure() -> Int { return 5 }

Solution

1. Step 1: Identify closure syntax

   Closures use curly braces with parameters and return type before 'in'.

2. Step 2: Check each option

   'let closure = { () -> Int in return 5 }' matches closure syntax. 'func closure() -> Int { return 5 }' declares a named function. 'let closure = func() -> Int { return 5 }' uses invalid syntax. 'let closure = (Int) -> { return 5 }' lacks 'in' keyword and has wrong parameter placement.

3. Final Answer:

   let closure = { () -> Int in return 5 } -> Option B

4. Quick Check:

   Closure syntax = curly braces + 'in' [OK]

Hint: Closures use braces and 'in' keyword [OK]

Common Mistakes:

• Using func keyword inside closure
• Missing 'in' keyword
• Wrong parameter syntax

3. What will be printed by this Swift code?

let multiply = { (a: Int, b: Int) -> Int in
  return a * b
}
print(multiply(3, 4))

medium

A. 34

B. 7

C. 12

D. Error

Solution

1. Step 1: Understand closure parameters and return

   The closure takes two Ints and returns their product.

2. Step 2: Calculate multiply(3, 4)

   3 * 4 equals 12, so print outputs 12.

3. Final Answer:

   12 -> Option C

4. Quick Check:

   3 times 4 = 12 [OK]

Hint: Closures return calculated values like functions [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Syntax errors in closure call

4. Identify the error in this closure declaration:

let add = { (a: Int, b: Int) Int in
  return a + b
}

medium

A. Missing '->' before return type

B. Missing 'in' keyword

C. Parameters should not have types

D. Closure cannot return Int

Solution

1. Step 1: Check closure signature syntax

   Return type must be preceded by '->' in closure signature.

2. Step 2: Identify missing arrow

   Code has '(a: Int, b: Int) Int' but should be '(a: Int, b: Int) -> Int'.

3. Final Answer:

   Missing '->' before return type -> Option A

4. Quick Check:

   Closure return type needs '->' [OK]

Hint: Return type needs '->' before it in closures [OK]

Common Mistakes:

• Omitting '->' in closure signature
• Placing 'in' incorrectly
• Removing parameter types

5. You want to sort an array of names alphabetically using a closure. Which code correctly uses a closure with the sorted(by:) method?

hard

A. let sortedNames = names.sorted(by: { s1, s2 -> Bool { return s1 > s2 } })

B. let sortedNames = names.sorted(by: { s1, s2 in s1 + s2 })

C. let sortedNames = names.sorted(by: (s1, s2) -> s1 < s2)

D. let sortedNames = names.sorted(by: { s1, s2 in s1 < s2 })

Solution

1. Step 1: Understand sorted(by:) closure

   It expects a closure that returns true if first element should come before second.

2. Step 2: Check each option

   'let sortedNames = names.sorted(by: { s1, s2 in s1 < s2 })' returns true when s1 < s2 (correct for ascending alphabetical order). The version with s1 > s2 sorts descending. The version with (s1, s2) -> s1 < s2 uses invalid syntax without braces or 'in'. The version with s1 + s2 returns String, not Bool.

3. Final Answer:

   let sortedNames = names.sorted(by: { s1, s2 in s1 < s2 }) -> Option D

4. Quick Check:

   sorted(by:) needs Bool-returning closure [OK]

Hint: sorted(by:) needs closure returning true/false [OK]

Common Mistakes:

• Returning wrong type from closure
• Using wrong comparison operator
• Incorrect closure syntax