Functional Programming in Swift: Advanced Level

Functional Programming in Swift: Advanced Level

Functional programming (FP) is a paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. In Swift, which is a multi-paradigm language, functional capabilities are not just supported but deeply integrated into the language and standard library. If you have already mastered basic concepts like map, filter, and reduce, it's time to delve into advanced techniques that will help you write safer, more predictable, and testable code for iOS and macOS applications. In this article, we will explore functors, monads, lazy evaluation, and function composition with practical examples.

1. Functors: Containers with Transformation Capability

A functor is a data type that implements the fmap function (in Swift — map). The essence of a functor is that it represents a container whose contents can be transformed using a passed function without leaving the container. A classic example is Optional.

Let's see how a functor works using Optional as an example:

let maybeNumber: Int? = 5\nlet result = maybeNumber.map { $0 * 2 }\nprint(result) // Optional(10)\n\nlet nilValue: Int? = nil\nlet nilResult = nilValue.map { $0 * 2 }\nprint(nilResult) // nil

Here, Optional is a functor. If there is a value inside, map applies the closure and returns a new Optional. If there is no value — the operation is not performed, and we get nil. This eliminates cumbersome if let constructs.

Another important functor in Swift is Array. map on an array applies a function to each element and returns a new array:

let numbers = [1, 2, 3, 4]\nlet doubled = numbers.map { $0 * 2 }\nprint(doubled) // [2, 4, 6, 8]

Creating your own functor. You can implement a functor for any custom type by defining a map method. For example, a simple logging wrapper:

struct Logged<T> {\n    let value: T\n    let log: [String]\n    \n    func map<U>(_ transform: (T) -> U) -> Logged<U> {\n        let newValue = transform(value)\n        return Logged<U>(value: newValue, log: log + ["Transformed \\(value) to \\(newValue)"])\n    }\n}\n\nlet logged = Logged(value: 10, log: ["Initial value"])\nlet transformed = logged.map { $0 + 5 }\nprint(transformed.log) // ["Initial value", "Transformed 10 to 15"]

2. Monads: Chains of Computations with Context

A monad is a functor that additionally implements the flatMap (or bind) method. While map allows you to apply a function that returns a regular value, flatMap allows you to apply a function that itself returns a value in the same context (e.g., another Optional). This is a key tool for building chains of operations while preserving context.

The most illustrative example is working with optional values. Suppose we have a function that extracts a number from a string, and a function that divides a number by another number, but both can return nil:

func parseNumber(_ string: String) -> Int? {\n    return Int(string)\n}\n\nfunc divideSafely(_ a: Int, by b: Int) -> Int? {\n    guard b != 0 else { return nil }\n    return a / b\n}\n\n// Without flatMap you have to use nested if let\nif let num1 = parseNumber("10") {\n    if let result = divideSafely(num1, by: 2) {\n        print(result) // 5\n    }\n}\n\n// With flatMap everything becomes more elegant\nlet result = parseNumber("10").flatMap { divideSafely($0, by: 2) }\nprint(result) // Optional(5)\n\nlet failed = parseNumber("abc").flatM