dependencies: [
    .package(url: "https://github.com/hainayanda/CombineAsync.git", .upToNextMajor(from: "1.2.0"))
]

 .target(
    name: "MyModule",
    dependencies: ["CombineAsync"]
)

// implicitly await with 30 second timeout
let result = await publisher.sinkAsynchronously()

// or with timeout explicitly
let timedResult = await publisher.sinkAsynchronously(timeout: 1)

let results = await arrayOfPublishers.sinkAsynchronously()

// or with timeout
let timedResults = await arrayOfPublishers.sinkAsynchronously(timeout: 1)

let future = Future { 
    try await getSomethingAsync()
}

publisher.asyncSink { output in
    await somethingAsync(output)
}

publisher.autoReleaseSink { completion in
    // do something on completed
} receiveValue: { output in
    // do something to receive value
}

publisher.autoReleaseSink(retainedTo: self) { _ in
    // do something on completed
} receiveValue: { 
    // do something on receive value
}

publisher.autoReleaseSink(timeout: 60) { _ in
    // do something on completed
} receiveValue: { 
    // do something on receive value
}

// the closure will be released after completion, or 60 second, or when self is released.
publisher.autoReleaseSink(retainedTo: self, timeout: 60) { _ in
    // do something on completed
} receiveValue: { 
    // do something on receive value
}

// the closure will be released after completion or 30 seconds, or when the self is released.
let retainCancellable = publisher.autoReleaseSink(retainedTo: self, timeout: 30) { _ in
    // do something on completed
} receiveValue: { 
    // do something on receive value
}

let typeErased = retainCancellable.eraseToAnyCancellable()

...
...

switch retainCancellable.state { 
    case .retained: 
    print("closure still retained")
    case .released: 
    print("closure already released")
}

// will ignore error and produce AnyPublisher<Output, Never>
publisher.ignoreError()

// will convert the error to output and produce AnyPublisher<Output, Never>
publisher.replaceError { error in convertErrorToOutput(error) }

// will try to convert the error to output and produce AnyPublisher<Output, Failure>
// if the output is nil, it will just pass the error
publisher.replaceErrorIfNeeded { error in convertErrorToOutputIfNeeded(error) }

// will collect all the emitted elements from all publishers
let allElementsEmittedPublisher = arrayOfPublishers.merged()

// will collect only the first emitted element from all publishers
let firstElementsEmittedPublisher = arrayOfPublishers.mergedFirsts()

// map
let mapped = try await arrayOfID.asyncMap { await getUser(with: $0) }

// compact map
let compactMapped = try await arrayOfID.asyncCompactMap { await getUser(with: $0) }

// with timeout
let timedMapped = try await arrayOfID.asyncMap(timeout: 10) { await getUser(with: $0) }
let timedCompactMapped = try await arrayOfID.asyncCompactMap(timeout: 10) { await getUser(with: $0) }

// map
let futureMapped: AnyPublisher<[User], Error> = arrayOfID.futureMap { await getUser(with: $0) }

// compact map
let futureCompactMapped: AnyPublisher<[User], Error> = arrayOfID.futureCompactMap { await getUser(with: $0) }

publisher.asyncMap { output in
    await convertOutputAsynchronously(output)
}

myArrayPublisher.mapSequence { element in
    // do map the element of the sequence to another type
}

myArrayPublisher.map { output in
    output.map { element in
        // do map the element of the sequence to another type
    }
}