Why Functions as types in Swift? - Purpose & Use Cases

The Big Idea

What if you could pass around actions like simple values and make your code magically flexible?

The Scenario

Imagine you want to pass a specific action, like adding or multiplying numbers, to different parts of your program. Without functions as types, you'd have to write separate code for each action everywhere you want to use it.

The Problem

This manual way is slow and confusing. You might copy and paste code, which can cause mistakes. Changing one action means hunting down every place you wrote it. It's like rewriting the same recipe over and over instead of sharing it.

The Solution

Functions as types let you treat actions like values. You can pass them around, store them, and reuse them easily. This means you write the action once and use it anywhere, making your code cleaner and safer.

Before vs After

✗ Before

func add(a: Int, b: Int) -> Int { return a + b }
let result = add(a: 2, b: 3)

✓ After

let add: (Int, Int) -> Int = { $0 + $1 }
let result = add(2, 3)

What It Enables

This lets you build flexible programs where you can swap and reuse actions like building blocks, making your code smarter and easier to change.

Real Life Example

Think of a calculator app where you can choose different operations (add, subtract, multiply). Using functions as types, the app can easily switch between these operations without rewriting code.

Key Takeaways

Manual repetition of actions is slow and error-prone.

Functions as types let you pass and reuse actions like values.

This makes your code cleaner, flexible, and easier to maintain.