Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Swift · Question Set
Functional Patterns & Higher-Order Functions interview questions for placements and exams.
Questions
11
Included in this set
Subject
Swift
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Swift.
In functional programming, immutability means data does not change after creation; instead operations produce new data. Swift can support this via `let`, value types, and immutable patterns. This makes code safer, especially in concurrent contexts.
For complete preparation, combine this set with full subject-wise practice for Swift. You can also explore other subjects and sets from the links below.
In Swift `map` applies a transform closure to each element and returns a collection of results. `compactMap` applies a transform returning an optional and removes any nils from the result, producing a non-optional collection of non-nil results. `flatMap` is used when the transform returns a sequence (or optional) and you want to flatten nested collections (or flatten optionals plus sequences). /n/n For example: `let nums = ["1","2","a","3"]; let ints1 = nums.map { Int($0) }` gives `[Optional(1), Optional(2), nil, Optional(3)]`; `let ints2 = nums.compactMap { Int($0) }` gives `[1,2,3]`; `let groups = [[1,2],[3,4]]; let flat = groups.flatMap { $0 }` gives `[1,2,3,4]`. /n/n Understanding when to use each is often asked in Swift interviews.
You create a function that either accepts a closure as an argument, or returns a closure, or both. For example: `func times(_ n: Int) -> ((Int) -> Int) { return { x in return x * n } }`. /n/n Here `times(3)` returns a function that multiplies its argument by 3. This illustrates returning a function. You could also accept a function argument: `func applyTwice<T>(_ f: (T) -> T) -> ((T) -> T) { return { x in f(f(x)) } }`. /n/n This demonstrates higher-order behaviour. Creating and using custom higher-order functions in Swift shows deeper mastery beyond standard `map`/`filter`.
In Swift a higher-order function is one that either receives functions as parameters or returns functions as its result. This enables abstraction over behaviour, not just data.
The `map` function applies a transformation closure to each element of a collection (e.g., array) and returns a new collection containing the results. This is a classic functional-pattern in Swift.
In Swift the `filter` higher-order function evaluates a closure for each element and returns a new collection containing only those elements for which the closure returns true. It’s often used for extracting subsets of data.
The `reduce` function in Swift takes an initial seed value and a closure that combines the accumulated result and each element, returning a single value. It is very useful for summarizing or aggregating collections.
In Swift when closures capture `self` or other references you can provide a capture list (e.g., `[weak self]`) to control how those references are captured, often to avoid retain cycles in reference-type contexts.
Key-paths in Swift (like `\.name`) are typed references to properties you can use in higher-order functions for concise code. For example: `people.map(\.name)` extracts the name property from each person. This pattern improves readability and reduces boilerplate.
In Swift you can mark a collection as `lazy` so that when you chain higher-order functions like `map`, `filter`, `reduce`, the work is deferred and fused. This can reduce overhead and improve performance when you only need part of the result.
Function composition means combining simple functions to build more complex ones. For instance if you have `func double(_ x: Int) -> Int { return x * 2 }` and `func addThree(_ x: Int) -> Int { return x + 3 }`, you could compose them into `func doubleThenAddThree(_ x: Int) -> Int { return addThree(double(x)) }`. /n/n In Swift you can write helper functions like `func compose<A,B,C>(_ f: @escaping (B) -> C, _ g: @escaping (A) -> B) -> ((A) -> C) { return { x in f(g(x)) } }`. /n/n Composition helps build pipelines of operations (e.g., filtering, transforming, mapping) and leads to concise, readable, maintainable code especially when handling data flows in Swift.