Swift Academy · Aula

Composição de funções e pipelines

Crie pipelines de dados compondo funções pequenas em transformações maiores.

Composição de funções e pipelines é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Boas-vindas

A composição de funções combina funções pequenas e focadas em transformações maiores. É a essência da programação funcional — construir comportamentos complexos a partir de partes simples.

Composição manual

```swift func double(_ n: Int) -> Int { n * 2 } func addOne(_ n: Int) -> Int { n + 1 } let result = addOne(double(5)) // 11 ```

Composição com uma função auxiliar

```swift func compose(_ f: @escaping (B)->C, _ g: @escaping (A)->B) -> (A)->C { { f(g($0)) } } let doubleAndAdd = compose(addOne, double) print(doubleAndAdd(5)) // 11 ```

Operador personalizado >>>

```swift infixop precedencegroup CompositionPrecedence { ... } func >>> (f: @escaping (A)->B, g: @escaping (B)->C) -> (A)->C { { g(f($0)) } } let pipeline = double >>> addOne >>> String.init print(pipeline(5)) // "11" ```

Cadeia de processamento com map/filter encadeados

```swift let process: ([Int]) -> [String] = { nums in nums.filter { $0 > 3 }.map { String($0 * 2) } } print(process([1,2,3,4,5])) // ["8","10"] ```

Estilo sem pontos

O estilo sem pontos evita nomear argumentos intermediários: ```swift let words = ["hello","WORLD","Swift"] let lower = words.map { $0.lowercased() } // named let lower2 = words.map(\.description) // point-free where applicable ```

KeyPaths como funções

Os KeyPaths do Swift podem ser usados como funções: ```swift struct User { var name: String } let users = [User(name:"Alice"),User(name:"Bob")] let names = users.map(\.name) // ["Alice","Bob"] ```

Construindo um fluxo de dados

```swift let pipeline: (String) -> Int? = { s in let trimmed = s.trimmingCharacters(in:.whitespaces) guard !trimmed.isEmpty else { return nil } return Int(trimmed) } [" 42 "," ","7"].compactMap(pipeline) // [42,7] ```

Aplicação parcial

```swift func add(_ a: Int) -> (Int) -> Int { { a + $0 } } let add5 = add(5) print([1,2,3].map(add5)) // [6,7,8] ```

Por que a composição é importante

Benefícios: • Cada função é pequena e testável • Os fluxos de dados são legíveis de cima para baixo • Reutilização: `double` funciona sozinho ou em qualquer fluxo de dados • Avaliação preguiçosa: combine com `.lazy` para evitar alocações intermediárias

Verificação rápida

Qual recurso do Swift permite que KeyPaths sejam usados diretamente como funções de transformação em map?

Recapitulação

Principais conclusões: • Componha funções pequenas em transformações maiores • `>>>` ou composição manual para fluxos de dados reutilizáveis • KeyPaths como funções para extrair propriedades com clareza • A aplicação parcial cria funções especializadas • Combine com `.lazy` para obter fluxos de dados sem cópias Próximo: sequências preguiçosas.

Perguntas Frequentes

A aula “Composição de funções e pipelines” é grátis?

Sim — o texto completo de “Composição de funções e pipelines” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Composição de funções e pipelines”?

Crie pipelines de dados compondo funções pequenas em transformações maiores. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Composição de funções e pipelines”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Funções puras e design sem efeitos colaterais
Funções de ordem superior: map, flatMap, compactMap
Composição de funções e pipelines
Sequências preguiçosas para maior eficiência

← Voltar para Swift Academy