【Swift/Combine】flatMapメソッドの使い方！publisherを直列処理

func flatMap<T, P>(
    maxPublishers: Subscribers.Demand = .unlimited,
    _ transform: @escaping (Self.Output) -> P
) -> Publishers.FlatMap<P, Self> where T == P.Output, P : Publisher, Self.Failure == P.Failure

// Publisherを返す何かしらの非同期処理
func printAddNumber(num: Int) -> AnyPublisher<Int, Error> {
    return Future { promise in
        DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
            let reuslt = num + 1
            print("Number: \(reuslt)")
            promise(.success(reuslt))
        }
    }.eraseToAnyPublisher()
}

let cancellable = Just(1)
    .flatMap { number in
        print(number) // 1
        // Justのパイプラインにpublisher(非同期処理)を追加
        return printAddNumber(num: number)
    }
    // ここでは返却する型を明示的に指定しないと以下エラーが発生する
    // Generic parameter 'P' could not be inferred
    .flatMap { number -> AnyPublisher<Int, Error> in
        print(number) // 2
        // さらに別のpublisher(非同期処理)を追加
        return printAddNumber(num: number)
    }
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("All numbers printed successfully")
        case .failure(let error):
            print("Failed with error: \(error)")
        }
    }, receiveValue: { number in
        print("Received number: \(number)")
    })

func printAddNumber(num: Int) -> AnyPublisher<Int, Error> {
    return Future { promise in
        DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
            let reuslt = num + 1
            print("Number: \(reuslt)")
            promise(.success(reuslt))
        }
    }.eraseToAnyPublisher()
}

let nums = Array(1...5)
let cancellable = Publishers.Sequence(sequence: nums)
    .flatMap(maxPublishers: .max(1)) { number in
        return printAddNumber(num: number)
    }
    .flatMap { number -> AnyPublisher<Int, Error> i
        return printAddNumber(num: number)
    }
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("All numbers printed successfully")
        case .failure(let error):
            print("Failed with error: \(error)")
        }
    }, receiveValue: { number in
        print("Received number: \(number)")
    })

Number: 2
Number: 3
Number: 3
Received number: 3
Number: 4
Number: 4
Received number: 4
Number: 5
Number: 5
Received number: 5
Number: 6
Number: 6
Received number: 6
Number: 7
Received number: 7
All numbers printed successfully

class MyError: Error { }
class TestError: Error { }

var cancellables = Set<AnyCancellable>()

func publisher() -> AnyPublisher<String, MyError> {
    
    let helloPublisher = Just("Hello")
        .setFailureType(to: TestError.self)
    
    let worldPublisher = Just("World")
        .setFailureType(to: MyError.self)
    // コンパイルエラー発生
    return helloPublisher.flatMap { _ in
        worldPublisher
    }.eraseToAnyPublisher()
}

publisher()
    .sink { error in
        print(error)
    } receiveValue: { value in
        print(value)
    }.store(in: &cancellables)

No exact matches in call to instance method 'flatMap'

Candidate requires that the types 'TestError' and 'MyError' be equivalent (requirement specified as 'Self.Failure' == 'P.Failure') (Combine.Publisher)

let helloPublisher = Just("Hello")
    .setFailureType(to: TestError.self)
    .mapError { _ in MyError() }
    ----- OR ------
let helloPublisher = Just("Hello")
    .setFailureType(to: TestError.self)
    .catch { _ in Fail<String, MyError>(error: MyError()) } 

func publisher() -> AnyPublisher<String, MyError> {
    
    let intPublisher: AnyPublisher<Int, Never> = Just(2).eraseToAnyPublisher()
    
    let strPublisher = Just("Hello")
        .setFailureType(to: MyError.self)
    
    return intPublisher.flatMap { _ in
        strPublisher
    }.eraseToAnyPublisher()
}