Swift Proposal: ConcurrentValue and @concurrent Closures
This proposal describes an approach to address one of the challenging problems in this space — how to type check value passing between structured concurrency constructs and actors messages. As such, this is a unifying theory that provides some of the underlying type system mechanics that make them both safe and work well together.
[…]
One safe way to transfer reference types is to make a deep copy of the data structures, ensuring that the source and destination concurrency domains each have their own copy of mutable state. This can be expensive for large structures, but is/was commonly used in some Objective-C frameworks. General consensus is that this should be explicit, not something implicit in the definition of a type.
[…]
This proposal introduces the concept of a “marker” protocol, which indicates that the protocol has some semantic property but is entirely a compile-time notion that does not have any impact at runtime.
[…]
The
ConcurrentValueprotocol models types that are allowed to be safely passed across concurrency domains by copying the value. This includes value-semantic types, references to immutable reference types, internally synchronized reference types,@concurrentclosures, and potentially other future type system extensions for unique ownership etc.
Previously:
- Swift AsyncSequence
- Swift Concurrency Interoperability With Objective-C
- Swift Proposal for async/await
- Swift Concurrency Roadmap
