Funcional ou POO em Swift: o que escolher para um projeto iOS?

Dois lados da mesma moeda: Abordagem funcional vs orientada a objetos em Swift

Quando comecei a programar para iOS, achava que a programação orientada a objetos era o único caminho correto. Classes, herança, polimorfismo — tudo soava como escritura sagrada para um desenvolvedor. Mas então descobri a programação funcional em Swift, e o mundo virou de cabeça para baixo. Acontece que é possível escrever código que não muta o estado, que é fácil de testar e que se parece com uma fórmula matemática.

Swift é uma linguagem única. Ela é multiparadigma. Isso significa que você pode misturar POO e abordagem funcional em um mesmo projeto, aproveitando o melhor dos dois mundos. Mas como não se confundir? Quando usar classes e quando usar closures e map? Vamos descobrir.

Swift orientado a objetos: o clássico que funciona

A programação orientada a objetos (POO) em Swift é construída em torno de classes, protocolos e herança. É um paradigma onde dados e comportamento vivem juntos. Você cria um modelo — por exemplo, "Usuário" — e esse objeto sabe como se apresentar, como alterar o nome ou calcular a idade.

Aqui está um exemplo clássico em Swift:

class User {\n    var name: String\n    var age: Int\n    \n    init(name: String, age: Int) {\n        self.name = name\n        self.age = age\n    }\n    \n    func greet() -> String {\n        return "Olá, meu nome é \\(name) e tenho \\(age) anos."\n    }\n    \n    func haveBirthday() {\n        age += 1\n    }\n}\n\nlet user = User(name: "Ana", age: 25)\nuser.haveBirthday()\nprint(user.greet()) // Olá, meu nome é Ana e tenho 26 anos.

Neste código, usamos a abordagem orientada a objetos em Swift. Temos estado (propriedades name, age) que pode mudar (método haveBirthday). Isso é intuitivo, especialmente se você veio de Java ou C++. Mas há um detalhe: estado mutável é fonte de bugs. Quanto mais objetos se alteram mutuamente, mais difícil é depurar o programa.

Swift funcional: o poder das closures e da imutabilidade

A programação funcional em Swift oferece uma visão diferente. Aqui, funções são "cidadãs de primeira classe". Você pode passá-las como parâmetros, retorná-las de outras funções e armazená-las em variáveis. O princípio principal são as funções puras (pure functions), que não alteram o estado externo e sempre retornam o mesmo resultado para as mesmas entradas.

Vejamos como o mesmo exemplo fica no estilo funcional:

struct User {\n    let name: String\n    let age: Int\n}\n\nfunc greet(user: User) -> String {\n    return "Olá, meu nome é \\(user.name) e tenho \\(user.age) anos."\n}\n\nfunc haveBirthday(user: User) -> User {\n    return User(name: user.name, age: user.age + 1)\n}\n\nlet user = User(name: "Ana", age: 25)\nlet olderUser = haveBirthday(user: user)\nprint(greet(user: olderUser)) // Olá, meu nome é Ana e tenho 26 anos.

Observe: usamos uma estrutura (struct), não uma classe. Structs em Swift são tipos de valor (value types). Elas são copiadas na atribuição. A função haveBirthday não muta o objeto original, mas cria um novo. Esta é a ideia central da abordagem funcional — a imutabilidade (immutability).

Comparação das abordagens: quando usar cada uma?

Agora vamos comparar honestamente a POO e a programação funcional em Swift. Cada uma tem seus pontos fortes.

Abordagem orientada a objetos em Swift

\n
• Prós: Intuitiva para modelar o mundo real. Excelente para componentes de UI (UIViewController, UIView). Herança simplifica a reutilização de código.
\n
• Contras: Mutabilidade