Programação Funcional em Swift: Nível Avançado

Programação Funcional em Swift: Nível Avançado

Programação funcional (PF) é um paradigma que trata a computação como a avaliação de funções matemáticas e evita a mudança de estado e dados mutáveis. Em Swift, que é uma linguagem multiparadigma, os recursos funcionais não são apenas suportados, mas profundamente integrados na linguagem e na biblioteca padrão. Se você já domina conceitos básicos como map, filter e reduce, é hora de se aprofundar em técnicas avançadas que ajudarão a escrever código mais seguro, previsível e testável para aplicativos iOS e macOS. Neste artigo, exploraremos functores, mônadas, avaliação preguiçosa e composição de funções com exemplos práticos.

1. Functores: Contêineres com Capacidade de Transformação

Um functor é um tipo de dado que implementa a função fmap (em Swift, map). A essência de um functor é que ele representa um contêiner cujo conteúdo pode ser transformado usando uma função passada, sem sair dos limites do contêiner. Um exemplo clássico é Optional.

Veja como um functor funciona com o exemplo de Optional:

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

Aqui, Optional é um functor. Se houver um valor dentro, map aplica o closure e retorna um novo Optional. Se não houver valor, a operação não é executada e obtemos nil. Isso elimina construções complicadas com if let.

Outro functor importante em Swift é Array. O map em um array aplica a função a cada elemento e retorna um novo array:

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

Criando seu próprio functor. Você pode implementar um functor para qualquer tipo personalizado definindo o método map. Por exemplo, um wrapper simples para registro de log:

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. Mônadas: Cadeias de Computação com Contexto

Uma mônada é um functor que adicionalmente implementa o método flatMap (ou bind). Enquanto map permite aplicar uma função que retorna um valor comum, flatMap permite aplicar uma função que ela mesma retorna um valor no mesmo contexto (por exemplo, outro Optional). Esta é uma ferramenta chave para construir cadeias de operações preservando o contexto.

O exemplo mais claro é trabalhar com valores opcionais. Suponha que temos uma função que extrai um número de uma string e uma função que divide um número por outro, mas ambas podem retornar 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// Sem flatMap, é necessário usar if let aninhados\nif let num1 = parseNumber("10") {\n    if let result = divideSafely(num1, by: 2) {\n        print(result) // 5\n    }\n}\n\n// Com flatMap, tudo fica mais elegante\nlet result = parseNumber("10").flatMap { divideSafely($0, by: 2) }\nprint(result) // Optional(5)\n\nlet failed = parseNumber("abc").flatM