Combiner: comment remplacer / rattraper une erreur sans compléter l'éditeur d'origine?

Insérez simplement flatMap comme suit et vous pouvez réaliser ce que vous voulez

let firstPublisher    = {(value: Int) -> AnyPublisher<String, Error> in
           Just(value).tryMap({ _ -> String in
           if Bool.random() {
               throw MyError.someError
           } else {
               return "we're in the else case"
            }}).eraseToAnyPublisher()
    }

    Just(1).flatMap{ (value: Int) in
        return  firstPublisher(value).replaceError(with: "replaced Error")
   }.sink(receiveCompletion: { (completed) in
            print(completed)
        }, receiveValue: { (sadf) in
            print(sadf)
       }).store(in: &cancellables)

Le modèle de travail ressemble à ceci:

 Just(parameter).
 flatMap{ (value)->AnyPublisher<String, Never> in 
 return MyPublisher(value).catch { <String, Never>() } 
 }.sink(....)

Si nous utilisons l'exemple ci-dessus, cela pourrait être comme ceci:

   self.myButton.publisher(for: \.touchUpInside).flatMap{
            (data: Bool) in
        return Just(data).tryMap({ _ -> String in
        if Bool.random() {
            throw MyError.someError
        } else {
            return "we're in the else case"
        }}).replaceError(with: "replaced Error")
    }.sink(receiveCompletion: { (completed) in
            print(completed)
        }, receiveValue: { (sadf) in
            print(sadf)
       }).store(in: &cancellables)

Ici, vous pouvez remplacer le firstPublisher par AnyPublisher qui prend un paramètre.

Ici aussi, le firstPublisher n'a qu'une seule valeur, il ne peut produire qu'une seule valeur. Mais si votre éditeur peut produire plusieurs valeurs, il ne se terminera pas avant que toutes les valeurs aient été émises.

Je suggère d'utiliser Publisher avec typealias Failure = Never et la sortie en tant que résultat facultatif: typealias Output = Result<YourSuccessType, YourFailtureType>

Pour ce faire, vous pouvez utiliser l'opérateur catch et l'éditeur Empty :

let stringErrorPublisher = Just("Hello")
    .setFailureType(to: Error.self)
    .eraseToAnyPublisher() // AnyPublisher<String, Error>

let stringPublisher = stringErrorPublisher
    .catch { _ in Empty<String, Never>() }
    .eraseToAnyPublisher() // AnyPublisher<String, Never>

Je me débattais aussi avec ce problème et j'ai finalement trouvé une solution. Une chose à comprendre est que vous ne pouvez pas récupérer d'un flux terminé. La solution consiste à renvoyer un Result au lieu d'une Error .

let subscriber = PassthroughSubject<Result<String, MyError>, Never>()

subscriber
    .sink(receiveValue: { result in
        switch result {
        case .success(let value):
            print("Received value: \(value)")
        case .failure(let error):
            print("Failure: \(String(describing: error))")
        }
    })

Pour toute autre personne lisant ce fil et essayant de compiler le code, vous devrez importer le code de cet article (pour la partie button.publisher(for: .touchUpIsinde) ).

Bonus, voici le code pour gérer les erreurs avec un PassthroughSubject et ne jamais terminer le flux:

let button = UIButton()
button.publisher(for: .touchUpInside)
    .map({ control -> Result<String, Error> in
        if Bool.random() {
            return .failure(MyError.someError)
        } else {
            return .success("we're in the else case")
        }
    }).sink (receiveValue: { (result) in
        switch(result) {
        case .success(let value):
            print("Received value: \(value)")
        case .failure(let error):
            print("Failure: \(String(describing: error))")
        }
    })

Vous ne pouvez pas utiliser PassthroughSubject<String, MyError>() directement, sinon, le flux se terminera lorsqu'une erreur se produit.

Je crois que la réponse d'E. Coms est correcte, mais je vais le dire beaucoup plus simple. La clé pour gérer les erreurs sans que le pipeline arrête le traitement des valeurs après une erreur est d'imbriquer votre éditeur de gestion des erreurs dans flatMap :

1
666
3
finished

Production:

import UIKit
import Combine

enum MyError: Error {
  case someError
}

let cancel = [1,2,3]
  .publisher
  .flatMap { value in
    Just(value)
      .tryMap { value throws -> Int in
        if value == 2 { throw MyError.someError }
        return value
    }
    .replaceError(with: 666)
  }
  .sink(receiveCompletion: { (completed) in
    print(completed)
  }, receiveValue: { (sadf) in
    print(sadf)
  })

Vous pouvez exécuter cet exemple dans une aire de jeux.

Concernant la modification du PO:

Modifier Étant donné un éditeur avec AnyPublisher<String, Error> , comment puis-je le transformer en AnyPublisher<String, Never> sans terminer lorsqu'une erreur se produit, c'est-à-dire ignorer les erreurs émises par l'éditeur d'origine?

Vous ne pouvez pas.

Il y avait un film de la WWDC mentionné, et je crois que c'est "Combine in Practice" à partir de 2019, commencez à regarder vers 6h24: https://developer.apple.com/wwdc19/721

Oui, .catch() met fin à l'éditeur en amont (film 7:45) et le remplace par un .catch donné dans les arguments de .catch ce qui entraîne généralement la .finished de .finished lors de l'utilisation de Just() comme éditeur de remplacement.

Si l'éditeur d'origine doit continuer à fonctionner après un échec, une construction impliquant .flatMap() est requise (film 9:34). L'opérateur entraînant un éventuel échec doit être exécuté dans le .flatMap , et peut y être traité si nécessaire. L'astuce est d'utiliser

PlaygroundSupport.PlaygroundPage.current.needsIndefiniteExecution = true

enum MyError: Error {
    case someError
}
let cancellable = Timer.publish(every: 1, on: .main, in: .default)
    .autoconnect()
    .flatMap({ (input) in
        Just(input)
            .tryMap({ (input) -> String in
                if Bool.random() {
                    throw MyError.someError
                } else {
                    return "we're in the else case"
                }
            })
            .catch { (error) in
                Just("replaced error")
        }
    })
    .sink(receiveCompletion: { (completion) in
        print(completion)
        PlaygroundSupport.PlaygroundPage.current.finishExecution()
    }) { (output) in
        print(output)
}

au lieu de

.catch { return Just(replacement) } // DOES STOP UPSTREAM PUBLISHER

À l'intérieur de .flatMap vous remplacez toujours l'éditeur et ne vous souciez donc pas de savoir si cet éditeur de remplacement est résilié par .catch , car c'est déjà un remplaçant et notre éditeur d'origine en amont est en sécurité. Cet exemple est tiré du film.

C'est aussi la réponse à votre question Edit .flatMap sur la façon de transformer un <Output, Error> en <Output, Never> , puisque le .flatMap ne génère aucune erreur, c'est Jamais avant et après le flatMap. Toutes les étapes liées aux erreurs sont encapsulées dans le flatMap. (Astuce pour vérifier l' Failure=Never : si vous obtenez l' .assign(to:) Xcode pour .assign(to:) alors je crois que vous avez un échec = Jamais stream, cet abonné n'est pas disponible autrement. Et enfin le code complet du terrain

.flatMap { data in
    return Just(data).decode(...).catch { Just(replacement) }
}

L'éditeur émet jusqu'à ce qu'il se termine ou échoue (avec une erreur), après quoi le flux sera arrêté.

Une façon de surmonter ce problème consiste à utiliser un résultat comme type d'éditeur

Éditeur

service.value
        .sink { [weak self] in
            switch $0 {
            case let .success(value): self?.receiveServiceValue(value)
            case let .failure(error): self?.receiveServiceError(error)
            }
        }
        .store(in: &subscriptions)

Abonné

protocol SerivceProtocol {
    var value: Published<Result<Double, MyError>>.Publisher { get }
}