0Pricing
Swift Academy · Aula

map e flatMap em Result

Encadeie transformações em valores de sucesso sem instruções switch aninhadas.

map e flatMap em Result é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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

`map` e `flatMap` em `Result` permitem transformar valores de sucesso sem instruções switch aninhadas, mantendo o código simples e legível.

map em resultados

```swift let r: Result = .success(5) let doubled = r.map { $0 * 2 } // .success(10) let failed: Result = .failure(MyError.bad) let same = failed.map { $0 * 2 } // .failure(MyError.bad) ```

mapError em resultados

```swift let r: Result = .failure(URLError(.notConnectedToInternet)) let mapped = r.mapError { AppError.network($0) } // Result ```

flatMap — encadeando operações sujeitas a falhas

```swift func parseJSON(_ data: Data) -> Result { ... } func validate(_ user: User) -> Result { ... } let result: Result = fetchResult .flatMap { parseJSON($0) } .flatMap { validate($0).mapError { $0 as Error } } ```

flatMapError

```swift func recover(_ e: NetworkError) -> Result { .success(cachedData) } let result = networkResult.flatMapError { recover($0) } ```

map versus flatMap em resultados

• `map`: transforma o valor de sucesso; se a transformação retornar `T`, o resultado será `Result` • `flatMap`: a transformação retorna `Result`; evita o aninhamento `Result,E>`

Encadeando três operações

```swift fetchData(url) .map { parse($0) } .flatMap { validate($0) } .map { transform($0) } // Each step only runs if previous succeeded ```

Comparação com encadeamento de opcionais

O encadeamento de resultados é semelhante ao encadeamento de opcionais para erros: ```swift // Optional chain: name?.uppercased()?.prefix(5) // Result chain: result.map { $0.uppercased() }.map { $0.prefix(5) } ```

Convertendo para um opcional

```swift let opt = result.success // Value? — nil on failure let val = try? result.get() // Value? — nil on failure ```

Recuperando com um padrão semelhante a ??

```swift let value = (try? result.get()) ?? defaultValue ```

Verificação rápida

O que `result.flatMap { transform($0) }` faz quando `result` é `.failure`?

Recapitulação

Principais conclusões: • `map` transforma o sucesso e repassa a falha • `mapError` transforma o tipo da falha • `flatMap` encadeia operações que também retornam Result • Evita instruções switch aninhadas • Encadeie operações para criar pipelines limpos que propagam erros Próximo: tipos de erro personalizados.

Perguntas Frequentes

A aula “map e flatMap em Result” é grátis?

Sim — o texto completo de “map e flatMap em Result” é 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 “map e flatMap em Result”?

Encadeie transformações em valores de sucesso sem instruções switch aninhadas. 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 2 de 4.

Quanto tempo leva a aula “map e flatMap em Result”?

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

  1. Fundamentos de Result
  2. map e flatMap em Result
  3. Tipos de erro personalizados com LocalizedError
  4. Integração de Result com async/await
← Voltar para Swift Academy