0Pricing
Swift Academy · Lesson

Higher-Order Functions: map, flatMap, compactMap

Transforming sequences without mutation using Swift's collection functions.

Higher-Order Functions: map, flatMap, compactMap is a free Swift Academy lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome

Higher-order functions take or return other functions. Swift's collection library is built on them: `map`, `flatMap`, `compactMap`, `filter`, `reduce`.

map — Transform Each Element

```swift let nums = [1,2,3,4] let squared = nums.map { $0 * $0 } // [1,4,9,16] let strs = nums.map(String.init) // ["1","2","3","4"] ```

flatMap — Transform and Flatten

```swift let words = ["hello world","foo bar"] let all = words.flatMap { $0.split(separator:" ").map(String.init) } // ["hello","world","foo","bar"] ```

compactMap — Transform and Drop Nils

```swift let mixed = ["1","two","3"] let nums = mixed.compactMap { Int($0) } // [1,3] ```

Passing Function References

```swift func double(_ n: Int) -> Int { n * 2 } let result = [1,2,3].map(double) // [2,4,6] ``` Function references can stand in for closure literals.

Chaining Higher-Order Functions

```swift let total = (1...100) .filter { $0 % 2 == 0 } .map { $0 * $0 } .reduce(0, +) // sum of squares of even numbers 1-100 ```

flatMap on Optionals

```swift let maybeStr: String? = "42" let maybeInt = maybeStr.flatMap { Int($0) } // Optional(42) let nil2: String? = nil let also = nil2.flatMap { Int($0) } // nil ```

Custom Higher-Order Function

```swift func applyTwice(_ f: (T) -> T, _ value: T) -> T { f(f(value)) } print(applyTwice({ $0 * 2 }, 3)) // 12 ```

sorted(by:) as HOF

```swift let words = ["banana","apple","cherry"] let sorted = words.sorted { $0.count < $1.count } // ["apple","banana","cherry"] ``` `sorted(by:)` accepts a comparator function.

Practical: Process User Data

```swift struct User { var name: String; var score: Int } let users = [User(name:"A",score:80),User(name:"B",score:45),User(name:"C",score:92)] let topNames = users.filter { $0.score >= 80 }.map { $0.name }.sorted() // ["A","C"] ```

Quick Check

What does `compactMap` do that regular `map` does not?

Recap

Key takeaways: • `map` — transform every element • `flatMap` — transform + flatten nested results • `compactMap` — transform + drop nils • Pass function references directly: `.map(String.init)` • Chain for clean data pipelines Next: function composition and pipelines.

Frequently asked questions

Is the “Higher-Order Functions: map, flatMap, compactMap” lesson free?

Yes — the full text of “Higher-Order Functions: map, flatMap, compactMap” is free to read here on the web, and the Swift Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.

What will I learn in “Higher-Order Functions: map, flatMap, compactMap”?

Transforming sequences without mutation using Swift's collection functions. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Higher-Order Functions: map, flatMap, compactMap” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Pure Functions and Side-Effect-Free Design
  2. Higher-Order Functions: map, flatMap, compactMap
  3. Function Composition and Pipelines
  4. Lazy Sequences for Efficiency
← Back to Swift Academy