Chaining + zipping multiple network requests using Swift and Combine

Question

Overall use case is 4 network requests

A. Request 1 and 2 need to be in parallel and wait for both to complete
B. Request 3 happens after 1 and 2 complete
C. Request 4 happens after 3 completes

After C the final output should be of a AnyPublisher type

I am trying to use Combine to achieve the above and so far I am able to do A using Publishers.Zip and C using flatMap. What I am struggling with is B. I can do that using nested completion handlers but not using flatMap

This is the sample code with Strings (not actual code)

func overallFunc(arg1: "arg1", arg2: "arg2", arg3: "arg3", arg4: "arg4" ) -> AnyPublisher {
let pub1 = func1(arg1: arg1, arg2: arg2)
let pub2 = func2(arg1: arg3, arg2: arg4)

let combinedPub = Publishers.Zip(pub1, pub2)

combinedPub
   .flatMap {(response1, response2) in
     return func3(arg1: response1.attribute1, arg2: response2.attribute2)
   }
}

The func1, func2 and func3 all return URLSession.shared.dataTaskPublisher with return type say AnyPublisher

Now I am struggling with completing the code for overallFunc. The complier gives the following error around flatMap.

Type of expression is ambiguous without more context

If I add an extra return in the last line of overallFunc then the error changes to No 'flatMap' candidates produce the expected contextual result type 'AnyPublisher'

In short I want to use flatMap on the result of Publishers.Zip and return another publisher so that I can add another flatMap to do the 4th request but am not able to figure out the right syntax and order of things to do that.

user_506441 · Answer

I think your attempt to obfuscate the code has removed the problem you were having. The following code compiles just fine:

func func1(arg1: String, arg2: String) -> AnyPublisher { fatalError() }
func func2(arg1: String, arg2: String) -> AnyPublisher { fatalError() }
func func3(arg1: String, arg2: String) -> AnyPublisher { fatalError() }
func func4(arg1: String) -> AnyPublisher { fatalError() }

func overallFunc(arg1: String, arg2: String, arg3: String, arg4: String) -> AnyPublisher {
    Publishers.Zip(
        func1(arg1: arg1, arg2: arg2),
        func2(arg1: arg3, arg2: arg4)
    )
        .flatMap { (response1, response2) in
            func3(arg1: response1 ?? "", arg2: response2 ?? "")
        }
        .flatMap { response3 in
            func4(arg1: response3 ?? "")
        }
        .eraseToAnyPublisher()
}

user_415303 · Answer

The result of flatMap is going to be a String? (the result of request 3) that you then want to pass to map. That map will convert the String into the fourth request. You could then add a subscriber to the fourth request which will be the result of your overall sequence. So...

pub1
  .zip(pub2)
  .flatMap { (response1, response2) in
     func3(arg1: response1.attribute1, arg2: response2.attribute2)
  }
  .map {
     (func3Result : String?) in
      /* return publisher of 4th request */
  }
  .eraseToAnyPublisher()

The result of all of this will be the publisher of the 4th request.

Chaining + zipping multiple network requests using Swift and Combine

2 Answers