WWDC | WWDC session videos | Frontend Framework library

Back-deploying concurrency to older OS versions bundles a concurrency runtime library along with your app with the support required for this feature, much like Swift used to do with the standard library prior to ABI stability in Swift 5, when Swift could be shipped with the OS.

This bundles parts of the Concurrency portions of the standard library (stable link) along with some additional support and stubs for functionality (stable link).

This bundling isn't necessary when deploying to OS versions new enough to contain these runtime features as part of the OS.

Since the feature on iOS 15+ (and associated OS releases) was stated to require kernel changes (for the new cooperative threading model) which themselves cannot be backported, the implementation of certain features includes shims based on existing functionality which does exist on those OSes, but which might perform a little bit differently, or less efficiently.

You can see this in a few places in Doug Gregor's PR for backporting concurrency — in a few places, checks for SWIFT_CONCURRENCY_BACK_DEPLOYMENT change the implementation where some assumptions no longer hold, or functionality isn't present. For example, the GlobalExecutor can't make assumptions about dispatch_get_global_queue being cooperative (because that threading model doesn't exist on older OSes), so when backporting, it has to create its own queue for use as the global cooperative queue. @objc-based actors also need to have their superclass swizzled, which doesn't need to happen on non-backdeployed runtimes. (Symbols also have to be injected in some places into the backdeploy libs, and certain behaviors have to be stubbed out, but that's a bit less interesting.)

Overall, there isn't comprehensive documentation on the exact differences between backdeploying and not (short of reading all of the code), but it should be safe to assume that the effective behavior of the backdeployed lib will be the same, though potentially at the cost of performance.

If you really are going to do something slow and synchronous, Task.detached is a closer analog to GCD’s dispatching to a global queue. If you just use Task(priority: ...) { ... } you are leaving it to the discretion of the concurrency system to decide which thread to run it on. (And just because you specify a lower priority does not guarantee that it might not run on the main thread.)

For example:

The key is to keep a reference to the Task, and if found, await its value.

Perhaps:

In IAP's apple generate a receipt against each transaction containing a lot of information like a digital signature to validate the purchase, history of transactions including successful and unsuccessful transaction, the current status of the subscription, expiry date, and much more.

You have to validate the receipt by fetching from the Apple server to get all this information. you can check this to know how to fetch receipt data.

for validation, we can go with 2 techniques

1. On-device validation(validation on the device locally if you're not using server in your app)
2. Server-side validation(Recommended)

you can read more about choosing receipt validation technique here.

When you fetch receipt it will give you a receiptData and you will convert it to base64EncodedString and hit API for receipt.

For SandBox use https://sandbox.itunes.apple.com/verifyReceipt and for production use https://buy.itunes.apple.com/verifyReceipt. pass it two parameters Receipt base64String and App-Specific Shared Secret you can find App-Specific Shared Secret on App store on the top right corner of your in-app purchases list.

You will receive a response containing all information about the subscription.

Check this video of title Engineering Subscriptions from WWDC 2018. This video is really helpful in understanding subscriptions.

I figured that the problem was on the size of my stroke. This will work:

Hi I think this might be because:

Looking at the WWDC video, it appears that what you are calling sendBackEA is what WWDC calls bringForward, and what you are calling bringForwardEA is what WWDC calls sendBack.

Just like how you move the first selected element forward one index (index decreases) in sendBackEA, then move all the other selected elements to immediately after that first selected element. bringForwardEA should do the reverse: move the last selected element backward one index (index increases), then move all the other selected elements to immediately before the last selected element. (See circa 19:10 in the video)

You seem to have confused yourself by trying to increase the indices of all the selected index by 1. This obviously cannot be done with a partition in general.

Also note that partition(by:) already modifies the collection, you don't need to get each partition, then recombine.

Your 4 methods can be written like this:

When creating a shortcut action, Shortcuts get mixed up with app identifiers. You therefore need to delete all the compiled versions of your app.

Arrays are a struct, therefore a value type. However, there are some copy-on-write optimizations, which may be the reason for this refCount.

In the documentation for Array, it states:

Arrays, like all variable-size collections in the standard library, use copy-on-write optimization. Multiple copies of an array share the same storage until you modify one of the copies. When that happens, the array being modified replaces its storage with a uniquely owned copy of itself, which is then modified in place. Optimizations are sometimes applied that can reduce the amount of copying.

It also gives an example:

In the example below, a numbers array is created along with two copies that share the same storage. When the original numbers array is modified, it makes a unique copy of its storage before making the modification. Further modifications to numbers are made in place, while the two copies continue to share the original storage.