Swiftpack.co - Swift Packages by glessard

The markdown parsing is broken/disabled for release notes. Sorry about that, I'm chasing the source of a crash that's been bringing this website down for the last couple of days. Move choice between weak and strong CAS out of the C parameter list in `CAtomics` - In the `CAtomics` module, all types have direct `CompareAndExchangeWeak` and `CompareAndExchangeStrong` functions rather than a single function with a parameter selecting between strong and weak. - The old version of `CompareAndExchange` with a `CASType` parameter still exists, but forwards to either of the other two, making it objectively worse. - `SwiftAtomics` internally adapts to the above, but is otherwise unchanged. - use `intptr_t` in tagged pointer unions. - Changes the default memory ordering parameters in SwiftAtomics. The defaults are now `.acquire` for loading operations, `.release` for storing operations, and `.acqrel` for read-modify-write operations. - Removes the `load()` function on `AtomicReference`. `load` required locking, and it failed once every several million attempts (under contention), and that just wasn't good enough. (It fails seldom enough that what I thought had been extensive testing prior to version 4.2.0 was in fact insufficient.) There's been a fair bit of trying to fix it in the last year, but nothing has completely worked. The correct solution may require collaboration with Swift's ARC reference-counting runtime, and therefore will have to wait until a similar type appears in the standard library. This release has major changes to the `CAtomics` package, in that it no longer uses swift-style function names, but uses (once more) C-style names: it switches from using the `SWIFT_NAME` macro to `__attribute__((overloadable))`. This allows all the necessary changes to have a similar shape, as `AtomicInt.load(_ order: LoadMemoryOrder)` becomes `CAtomicsLoad(_ atomic: UnsafeMutablePointer<AtomicInt>, order: LoadMemoryOrder)`. The Swift-style module is renamed to `SwiftAtomics`, which is less presumptuous than just `Atomics`. (Still presumptuous, but the standard library is unlikely to ever have a module named `SwiftAtomics`.) Finally, tagged pointers are now usable from the `SwiftAtomics` module, after having been usable from `CAtomics` since `4.4.0`. - The Swift 5 compiler no longer imports structs with large alignments. This defeats the approach I previously took to pad structs. - In order to get padded structs to mitigate false sharing effects, the package now inserts explicit padding rather than explicitly requesting a large alignment. This is not the ideal solution, but it's good enough for most cases. - The padded types are renamed from 4.4.0, with abject apologies to anyone who might be affected. I should have tried building with Swift 5 a tad earlier. - Adds tagged pointers to the CAtomics package, taking advantage of 128-bit atomic instructions in x64 and ARM64 - Adds cache-aligned variants to various types from CAtomics. These types take an entire cache line to themselves, which can be useful in some cases. - Adds initializers, such as `AtomicInt32.init(_ value: Int32)` and `AtomicRawPointer.init(_ pointer: UnsafeRawPointer)`. Previously one had to use a default initializer followed by a call to the `initialize` method. - Adds a compare-and-swap operation to `AtomicReference` - Supports the Windows build of Swift The underlying C package has a nicer interface when used from Swift.

The markdown parsing is broken/disabled for release notes. Sorry about that, I'm chasing the source of a crash that's been bringing this website down for the last couple of days.

The markdown parsing is broken/disabled for release notes. Sorry about that, I'm chasing the source of a crash that's been bringing this website down for the last couple of days. - API improvements when the `Failure` type is `Never`: some accessors become non-Optional, while some functions become non-throwing. - Made the `cancel()` method available only when it is usable by repeating it in conditional extensions. - Added a customization point for cancellation for subclasses of `Deferred`. - Added versions of `recover()` for error types more specific than `Error`. Major update to `deferred`, adding typed errors as a generic parameter, using the same parameter names as the standard library's `Result`. Another major change involves execution scheduling: execution now starts only once a `Deferred`'s result has been explicitly requested in some way. The `notify` method is the primary way to accomplish this (along with `onValue` and `onError`), as well an explicit call to `beginExecution()`. Finally, the URLSessionTask wrapper has been moved to its own package, `DeferredHTTP`. Encapsulation improvements and improved lock-freedom. Improves performance by consolidating notifications and deallocations - fewer calls to dispatch_async - more work done in each dispatch_async Improvements to and full testing of `DeferredURLSessionTask`. Added a `split` method for any `Deferred` whose value type is a tuple of 2, 3 or 4 elements. The return value is a tuple of `Deferred`; if the original `Deferred`'s outcome is an `Error`, then every `Deferred` in the split is determined with the same `Error`. - added parameter labels to `determine()` methods (with fix-its.) The parameter-less versions didn't save anything much, while causing grief when `Value` has a type that implements `Error` - improved behaviour of `firstValue()`. Its outcome is now an error only when all the inputs are errors. - the old behaviour is still provided by `firstDetermined()`. made `class Transferred: Deferred` public as a convenience. renamed `Determined<T>` to `Outcome<T>` (no changes necessary.) renamed some parameter labels for clarity (with deprecation/rename warnings.)

The markdown parsing is broken/disabled for release notes. Sorry about that, I'm chasing the source of a crash that's been bringing this website down for the last couple of days. Package description updated for Swift 4