Forced unwrapping inside flatMap in combine swift

I am trying to do some forced unwrapping inside my flatMap function but getting following error on return nil line:

> 'nil' requires a contextual type

Following is my code:

func fetchOrgs() -> AnyPublisher<[THOrganizationV2?], THError> {
    let locale = userInformationProvider.defaultOrganizationLocale
    let orgID = organizationProvider.currentOrganizationID ?? ""
    
    return thProvider.fetchTHOrgs(locale: locale, orgID: orgID).flatMap { orgs in
        guard let org = orgs.first else {
            return nil// error here
        }
        if org.type == .xpert {
            return self.prepareThURL(with: org, orgID: orgID)
        }
        return THOrganizationV2(serviceURL: URL(string: org.url), type: OrganizationType(rawValue: (org.type)!.rawValue) ?? .aaa, authenticationToken: org.authenticationToken)
    }.eraseToAnyPublisher()
}

Signature of function called above in thProvider:

func fetchTHOrgs(locale: String, orgID: String?) -> AnyPublisher<[thOrganizationEntityV2], THError>

I have tried different combinations of map and flatMap but nothing seems to be working for me.

Edit:
My goal here is to convert array of thOrganizationEntityV2 to array of THOrganizationV2 and wants to handle forced unwrapping too.

Signature for prepareThURL:

private func prepareThURL(with org: THOrganizationEntityV2, orgID: String?) -> THOrganizationV2?

The compiler is looking at the block in the flatMap and can't determine what type the nil represents.

The flatMap operator expects its closure to return a Publisher of some sort, not an optional. In your case flatMap seems to be the wrong operator. Your code seems like it might be returning THOrganizationV2? which is not a Publisher.

In the block the compiler gets this far:

.flatMap { orgs in
    guard let org = orgs.first else { return nil }

and says "hmmm... I'm in a closure that has no declared return type and you're giving me a nil. I don't know what flavor of nil that is. Is it an Int?, a Float?, a OmpaLoompa?... I have no context to figure out what Type that particular nil corresponds to."

You might fix it by declaring a return type for the closure:

.flatMap { orgs -> THOrganizationV2? in
    guard let org = orgs.first else { return nil }

or by directly providing a contextual type for the nil:

.flatMap { orgs in
    guard let org = orgs.first else { return nil as THOrganizationV2? }

But once again, the flatMap publisher operator expects the return type to be a publisher. I don't think your THOrganizationV2 is a Publisher.

Looking at the type signatures in your code, it seems that what you might want is something like this:

   return thProvider
     .fetchTHOrgs(locale: locale, orgID: orgID)
     .map { orgs in
        return orgs.map { org -> THOrganizationV2? in
            guard let org = orgs.first else { nil }

            if org.type == .xpert {
                return self.prepareThURL(with: org, orgID: orgID)
            }

            return THOrganizationV2(
              serviceURL: URL(string: org.url), 
              type: OrganizationType(rawValue: (org.type)!.rawValue) ?? .aaa,
              authenticationToken: org.authenticationToken
            )
        }
    }

(I typed this into the answer editor, not a compiler so some work may be needed)

I've replaced flatMap with map. For each array of orgs that come in, the system maps it to an array of THOrganizationV2? and those become the output of the publisher so fetchOrgs should match it's type signature.