Async+ for Swift provides a simple chainable interface for your async and throwing code, similar to promises and futures

Thanks for the work! Nice little QoL improvements for those of us embracing Swift's native async/await implementation 🙌🏻

However, a lot of us are still (at least partially) still using Cocoapods for dependency management. In an ideal world, we would just use SPM for everything - but there are a lot of libraries that either:

1. Don't support it at all yet
2. Support it, but lose some required features that Cocoapods provides (i.e. subspecs)

Could you integrate this project with pods so all the rest of us can easily import it? 😄

Using the library with SPM in project built for iOS in Xcode 13.3. When trying to build the project it gives the error:

"AppKit is not available when building for iOS. Consider using #if targetEnvironment(macCatalyst) to conditionally import this framework when building for Mac Catalyst."

I can see the file Node is importing AppKit, is this intentional?

Feature for the next major release:

Calling something a Node is a little ambiguous - maybe ChainItem.

Additionally, GenericNodeFailableAsync should be called GenericPromise, and the same for all four derivatives of whether they fail and if they are async. I think this can make the library much easier to understand for users and contributors.

A feature for the next release:

We should be able to write this code:

extension Catchable {
    func myCatchOperation() -> SomeComplexType {
        self.catch {
            err in 
            ...
        }
    }
}

..and have this extension apply to both Promises and synchronous AsyncPlus.Results, giving them both a myCatchOperation. The alternative is writing two separate extensions: one for a Promise and one for a Result, which is much easier to understand for the user of the package, but redundant.

attempt {
    return 2
}.catch {
    err in 
    ...
}

^ should not be a valid pattern because the 2 goes unused in the catch block. I wish I could write where T != () - that would make thing much much easier to solve this without adding another bit of data to chain items.

I realized the Xcode schemes that I intended to only be for development appear for anyone who has installed the package.. while people used to Cocoapods may be used to this, it seems better practice for Swift Packages to not include these schemes. The downside is that for those developing async-plus, code generation will be treated as any other test...

However I'm pushing this quick fix so that the schemes go away for users of the package, which is more important for now.

• All operations now have associated protocols, and internal protocols have been given more sensible names.
• The type-flag system that was a burden for the compiler has been abolished in favor of more traditional usage of protocols.
• Code generation has been added and used sparingly in attempt to improve readability and reduce the chance of duplication errors. See Tests/CodeGeneration/README.md
• Values returned from then, attempt, and recover can no longer be ignored, meaning that it is no longer possible (at compile time) to call catch on these chains without another then that uses the chain's value (similar to PromiseKit's done).

In Swift, Task has an overloaded get that is throwing iff Failure is Never.

In the same way, we should probably combine .asyncThrows and .async and .value and .result into a single overloaded function called .get the result would be async and/or throwing depending on the underlying implementation. Then if the async/throwing status of a chain changes, you don't have to change the name of the thing that accesses (one fewer thing to change).