Swiftly Functional: Unveiling the Power of Functional Programming in Swift
Tags: functionalprograming, ios, macos, tutorial
Published: 2024-01-09 10:05:36

Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data. Functional programming languages have several key traits that distinguish them from other paradigms like imperative or object-oriented programming. 
Swift is a multi-paradigm programming language developed by Apple. While Swift is not purely a functional programming language, it incorporates several functional programming concepts and supports functional programming style. Swift is designed to be flexible, allowing developers to write code in various paradigms, including imperative, object-oriented, and functional programming.

Here are some of the prominent traits of functional programming aspect of Swift.

### 1. First-class functions:

Functions are treated as first-class citizens, which means they can be assigned to variables, passed as arguments to other functions, and returned as values from other functions.

Swift treats functions as first-class citizens, allowing them to be assigned to variables, passed as arguments, and returned as values.

_Assigning a Function to a Variable:_

```
// Define a simple function
func greet(name: String) -> String {
    return "Hello, \(name)!"
}

// Assign the function to a variable
let greetingFunction: (String) -> String = greet

// Call the function through the variable
let result = greetingFunction("John")
print(result)  // Output: Hello, John!

```

_Function as a Parameter:_

```
// Define a function that takes another function as a parameter
func applyOperation(_ operation: (Int, Int) -> Int, a: Int, b: Int) -> Int {
    return operation(a, b)
}

// Define some operations
func add(a: Int, b: Int) -> Int {
    return a + b
}

func multiply(a: Int, b: Int) -> Int {
    return a * b
}

// Use the applyOperation function with different operations
let sumResult = applyOperation(add, a: 3, b: 5)
let productResult = applyOperation(multiply, a: 3, b: 5)

print(sumResult)      // Output: 8
print(productResult)  // Output: 15
```

_Function as a Return Type:_

```
// Define a function that returns another function
func createMultiplier(factor: Int) -> (Int) -> Int {
    return { number in
        return number * factor
    }
}


// Use the createMultiplier function to create a specific multiplier
let double = createMultiplier(factor: 2)
let triple = createMultiplier(factor: 3)

// Apply the created multipliers
let resultDouble = double(4)
let resultTriple = triple(4)

print(resultDouble)  // Output: 8
print(resultTriple)  // Output: 12

```


### 2. Immutability:

Emphasis on immutability ensures that once a data structure is created, it cannot be changed. Instead of modifying existing data, functional programming encourages creating new data structures with the desired values.

Swift supports immutability through the use of constants (let keyword) and immutable data structures such as Array, Dictionary etc.

### 3. Pure functions:

Functions in functional programming are considered pure if they have no side effects and always return the same output for the same input. Pure functions are predictable and easier to reason about.

Example of pure function in swift.

_Pure Function without side effects_

```
// Pure function: Adds two integers without side effects
func add(_ a: Int, _ b: Int) -> Int {
    return a + b
}

// Example usage
let result = add(3, 5)
print(result)  // Output: 8
```

In this example, the add function takes two integers as input and returns their sum. It doesn't modify any external state or have any side effects, making it a pure function.

#### Violation of ‘Pure Function’

Violating the principles of a pure function involves introducing side effects or dependencies on external state. 


_Function with side effects_

```
// Violation of purity: Modifying external state
var globalCounter = 0

func impureAdd(_ a: Int, _ b: Int) -> Int {
    globalCounter += 1
    return a + b
}

// Example usage
let result1 = impureAdd(3, 5)
let result2 = impureAdd(2, 4)

print(result1)  // Output: 8
print(globalCounter)  // Output: 2 (violating purity)

```

In this example, the impureAdd function modifies a global variable (globalCounter), introducing a side effect and violating the purity of the function.

### Referential transparency:

Referential transparency is a property of functions in which the function, given the same input, always produces the same output and has no side effects. In other words, you can replace a function call with its result without changing the program's behaviour. This property makes code more predictable and easier to reason about.

In Swift, achieving referential transparency involves writing functions that adhere to the principles of immutability and avoiding side effects. 

### Higher-order functions:

Higher-order functions take one or more functions as arguments or return functions as results. This allows for the creation of more abstract and reusable code.

In Swift, higher-order functions are a fundamental part of the language's functional programming capabilities.
Here are some common higher-order functions available in Swift:
Map Function - Applies a given transformation to each element of a sequence and returns an array of the results.

Filter Function - Returns an array containing the elements of a sequence that satisfy a given predicate.

Reduce Function - Combines the elements of a sequence using a specified binary operation and returns a single result.

Sorted Function - Returns the elements of a sequence, sorted using a given predicate.

CompactMap Function - Returns an array containing the non-nil results of applying a transformation to each element of a sequence.

FlatMap Function - Returns an array containing the concatenated results of applying a transformation to each element of a sequence that returns a sequence.

These higher-order functions in Swift allow you to write concise and expressive code, promoting a functional programming style. They enhance readability and maintainability while performing operations on sequences such as arrays, sets, and dictionaries.

### Recursion:

Functional programming languages often favour recursion over iterative loops for repetitive tasks. Recursion fits well with the functional paradigm and allows for concise and expressive code.

In Swift, you can use recursion to solve problems that can be broken down into smaller subproblems.

### Lazy evaluation:

Lazy evaluation delays the evaluation of an expression until its value is actually needed. This can lead to more efficient and resource-friendly code, especially in scenarios where not all values need to be computed.

Swift, by default, is not a lazy-evaluated language, but it provides features that allow you to implement lazy evaluation. Here are some concepts related to lazy evaluation in Swift:
Lazy Properties - In Swift, you can use the lazy keyword to define lazy properties. A lazy property is only evaluated once, the first time it is accessed, and its value is then cached for future accesses.

```
class Example {
    lazy var expensiveOperation: String = {
        // Perform some expensive computation
        return "Result of expensive operation"
    }()
}

```

Lazy Sequences - Swift provides a LazySequence type that allows you to create sequences with elements that are computed lazily.

```
let lazySequence = (1...5).lazy.map { $0 * 2 }
print(Array(lazySequence)) // [2, 4, 6, 8, 10]

```

Lazy Collections - Similarly, you can use LazyCollection to create lazy collections. Operations on a lazy collection are only performed when the result is needed.

```
let lazyArray = Array(1...5).lazy.filter { $0.isMultiple(of: 2) }
print(Array(lazyArray)) // [2, 4]

```

Lazy evaluation is particularly useful in scenarios where not all elements of a data structure or the result of an operation are immediately required. It can help improve performance and reduce memory usage by avoiding unnecessary computations until they are needed.


### Pattern matching:

Pattern matching is a powerful mechanism for checking a value against a pattern. It allows concise and expressive code for complex data structures.

Swift, like many modern programming languages, provides extensive support for pattern matching. 

Here are some common use cases and examples of pattern matching in Swift:

Switch Statements - The switch statement in Swift supports pattern matching. Each case can include patterns to match values against.

```
let someValue = 42

switch someValue {
case 0:
    print("It's zero")
case 1...10:
    print("It's between 1 and 10")
case let x where x > 100:
    print("It's greater than 100")
default:
    print("It's something else")
}

```

Tuple Patterns - You can use tuple patterns to match against tuples.

```
let point = (2, 3)

switch point {
case (0, 0):
    print("At the origin")
case (_, 0):
    print("On the x-axis")
case (0, _):
    print("On the y-axis")
case (1...5, 1...5):
    print("Inside a 5x5 square")
default:
    print("Outside the known area")
}
```

Enum Case Patterns - Pattern matching is commonly used with enums to match against specific cases.

```
enum Result {
    case success(String)
    case failure(Error)

    func process() {
        switch self {
        case .success(let message):
            print("Success: \(message)")
        case .failure(let error):
            print("Failure: \(error.localizedDescription)")
        }
    }
}

let result = Result.success("Data loaded successfully")
result.process()
```

Optional Patterns - You can use optional patterns to check whether an optional has a value or is nil.


```
let someOptional: Int? = 42

switch someOptional {
case .some(let value):
    print("It has a value: \(value)")
case .none:
    print("It's nil")
}
```

Wildcard Patterns - The underscore (_) can be used as a wildcard pattern to match any value.

```
let x: Int? = 42

switch x {
case _ where x != nil:
    print("It's not nil")
default:
    print("It's nil")
}
```

Type Casting Patterns - You can use type casting patterns to check the type of an instance.

```
let value: Any = 42

switch value {
case is String:
    print("It's a String")
case is Int:
    print("It's an Int")
default:
    print("It's of unknown type")
}

```

These examples illustrate some of the ways pattern matching is used in Swift. Pattern matching is not limited to switch statements; it's also utilised in other contexts like if, for, and while statements. Swift's pattern matching capabilities contribute to its expressive and readable syntax.

### Immutable data structures:

Functional programming languages often provide built-in support for immutable data structures, such as immutable lists or trees. These structures facilitate the creation of persistent and thread-safe data.

In Swift, immutability refers to the concept of creating objects or data structures that cannot be modified after their initial creation. Immutable data structures are beneficial for various reasons, including improved code safety, better concurrency support, and easier reasoning about code. While Swift itself doesn't provide built-in immutable data structures in the same way some functional programming languages do, you can create immutable structures using some language features.

Here are some approaches to creating immutable data structures in Swift:

**Structs with let Properties** - Swift’s struct types are value types, and if you declare their properties with let, those properties become immutable constants.

```
struct ImmutablePoint {
    let x: Double
    let y: Double
}

var point = ImmutablePoint(x: 1.0, y: 2.0)
// point.x = 3.0 // This will cause a compilation error

```

In this example, ImmutablePoint is a struct with two immutable properties (x and y).

**Enums with Associated Values** - Enums in Swift can have associated values, and by using let in the associated value, you can create immutable structures.

```
enum ImmutableShape {
    case circle(radius: Double)
    case square(side: Double)
}

let circle = ImmutableShape.circle(radius: 5.0)
// circle = .square(side: 3.0) // This will cause a compilation error

```

#### Type systems:

Many functional programming languages have strong, static type systems that help catch errors at compile-time, providing better reliability and maintainability.

Swift has a type system that supports both object-oriented and functional programming paradigms. While it is not a purely functional programming language, Swift incorporates several features in its type system that are beneficial for functional programming.

Some popular functional programming languages include Haskell, Lisp, Scala, Erlang, and F#. Each of these languages exhibits these traits to varying degrees, and they contribute to the overall benefits of functional programming, such as code clarity, modularity, and ease of parallelisation.