Introduction

Argument labels are an important part of the interface of a Swift function, describing what particular arguments to the function do and improvi...

Introduction

Curried function declaration syntax func foo(x: Int)(y: Int) is of limited usefulness and creates a lot of language and implementation comple...

Introduction

There has been some confusion of semantics when a function parameter is marked as inout compared to var. Both give a mutable local copy of ...

Introduction

The increment/decrement operators in Swift were added very early in the development of Swift, as a carry-over from C. These were added without...

Introduction

This proposal describes how we can improve Swift's "Clang Importer", which is responsible for mapping C and Objective-C APIs into Swift, to tra...

Introduction

[Swift API Design Guidelines][api-design-guidelines] being developed as part of Swift 3. It is important that the Standard Library is an exemp...

Introduction

The C-style for-loop appears to be a mechanical carry-over from C rather than a genuinely Swift-specific construct. It is rarely used and not...

Introduction

Currently, the Swift standard library has two versions of flatMap. One which flattens a sequence of sequences after a transformation:

Introduction

The current version of Swift (2.1) requires using self when accessing instance members in closures. The proposal suggests extending this to a...

Introduction

There is no way to create a substring of a StaticString that is still typed as StaticString. There should be.

[Swift Evolution Discussion ...

Introduction

The typealias keyword is currently used to declare two kinds of types:

1. Type Aliases (alternative name for an existing type)
2. Associated...

Introduction

@noescape

Swift provides a @noescape declaration [attribute](https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Sw...

Introduction

Prior to Swift 2.2, calls to superclass methods like super.foo() in Native Swift classes were dispatched statically by recording a reference ...

Introduction

In order to allow AnySequence delegate calls to the underlying sequence, its initializer should have extra constraints.

[Swift Evolution Dis...

Introduction

Implement comparison operators on tuples up to some arity.

[Swift Evolution Discussion](https://forums.swift.org/t/proposal-implement-and-for-...

Introduction

Just as users can create Unsafe[Mutable]Pointers from Ints and UInts, they should be able to create Ints and UInts from `Unsafe[Mutable]P...

Introduction

The standard library Unmanaged<Instance> struct provides a t...

Introduction

The Swift compiler is currently able to generate a memberwise initializer for use in some circumstances, however there are currently many limit...

Introduction

Testing is an essential part of modern software development. Tight integration of testing into the Swift Package Manager will help ensure a sta...

Introduction

This proposal aims to add a new build configuration option to Swift 2.2: #if swift.

Swift-evolution threads:

• [Swift 2.2: #if swift languag...

Introduction

Swift includes support for first-class functions, such that any function (or method) can be placed into a value of function type. However, when...

Introduction

In Swift 2, Objective-C selectors are written as string literals (e.g., "insertSubview:aboveSubview:") in the type context of a Selector. T...

Introduction

The design of commonly-used libraries has a large impact on the overall feel of a programming language. Great libraries feel like an extension ...

Introduction

Introduce a new operator an "Optional Value Setter". If the optional is set via this operator then the new value is only set if there isn't an...

Introduction

Scoped access level allows hiding implementation details of a class or a class extension at the class/extension level, instead of a file. It is...

Introduction

When developing framework and reusable code, we need to develop classes that are partially abstract with partial implementation. Protocol and ...

Introduction

Going back and forth from Strings to their byte representations is an important part of solving many problems, including object serialization, ...

Introduction

This proposal aims to eliminate Swift's use of "screaming snake case" like __FILE__ and `__FUNCTI...

Introduction

Function call expressions (which include several syntactic forms that apply an argument list to something of function type) currently have a du...

Introduction

There are property implementation patterns that come up repeatedly. Rather than hardcode a fixed set of patterns into the compiler, we should p...

Introduction

The inout keyword indicates copy-in/copy-out argument behavior. In its current implementation the keyword prepends argument names. We propose...

Introduction

Add a new extension method to Sequence called first(where:) that returns the found element.

Discussion on swift-evolution started with a p...

Introduction

Given a list of constants in an Objective-C file, add an attribute that will enable Swift to import them as either an Enum or a Struct, using `...

Introduction

In being accepted, Swift Evolution SE-0028 (0028-modernizing-debug-identifiers.md) overloads the use of #line to mean both an identifier that...

Introduction

Swift's behavior when closures capture inout parameters and escape their enclosing context is a common source of confusion. We should disallo...

Introduction

Enumeration cases are essentially static not instance type members. Unlike static members in structures and classes, enumeration cases can be m...

Introduction

There are several inconsistencies in how comments are treated when determining whether an operator is prefix, postfix, or infix. They are somet...

Introduction

This is a proposal for adding initial package manager support for the C, C++, Objective-C, and Objective-C++ languages (henceforth, simply refe...

Introduction

Playground literals tokenize colors, files, and images. They provide drag-and-drop convenience and in-context visualizations that offer easy re...

Introduction

Attribute arguments are unlike other Swift language arguments. At the call site, they use = instead of colons to distinguish argument names f...

Introduction

We propose to expand and improve the naming conventions established by the API Guidelines and the standard library with regard to conversion re...

Introduction

An unapplied method reference, such as Type.instanceMethod in the following example, currently produces a curried function value of type ...

Introduction

In Swift 2, it is possible to match multiple patterns in cases. However cases cannot contain multiple patterns if the case declares variables. ...

Introduction

Swift imports C declarations, allowing Swift code to natively interact with C libraries and frameworks. But, such imported APIs do not feel nat...

Introduction

Add 2 new Sequence functions prefix(while:) and drop(while:), with overrides as appropriate on Collection, LazySequenceProtocol, and ...

Introduction

We propose to normalize the first parameter declaration in methods and functions. In this proposal, first parameter declarations will match the...

Introduction

In Swift's current incarnation, annotating methods and functions with @warn_unused_result informs the compiler that a non-void return type *sh...

Introduction

This proposal aims to add generic typealiases to Swift.

Swift-evolution thread: [here](https://forums.swift.org/t/proposal-generic-type-aliase...

Introduction

This proposal suggests moving the existing @noescape and @autoclosure attributes from being declaration attributes on a parameter to being ...

...

...

Introduction

Currently, the documentation for IteratorType.next() has the precondition that when calling next(), no preceding call to next() should ha...

Introduction

Since function parameters are immutable by default, allowing function parameters to be explicitly labeled as let is a bit of a syntactic red...

Introduction

This proposal seeks to remove the ImplicitlyUnwrappedOptional type from the Swift type system and replace it with an IUO attribute on declara...

Introduction

In Objective-C, pointers (whether to objects or to a non-object type) can be marked as nullable or nonnull, depending on whether the pointe...

Introduction and Motivation

Swift-evolution thread: ["Allow trailing closures in 'guard' conditions"](https://forums.swift.org/t/proposal-allow-trailing-clo...

Introduction

Objective-C's lightweight generics feature allows Objective-C classes to be parameterized on the types they work with, similarly to Swift's g...

Introduction

Provide an ObjectiveCBridgeable protocol that allows a Swift type to control how it is represented in Objective-C by converting into and back...

Introduction

When SE-0006, Apply API Guidelines to the Standard Library was proposed, the lack of ...

Introduction

Swift generally follows in the Smalltalk/Objective-C tradition of compound method names with significant, order-sensitive argument labels, but ...

Introduction

The autoreleasepool function in the standard library does not currently support a return value or error handling, making it difficult and err...

Introduction

In Objective-C and Swift, key-paths used by KVC and KVO are represented as string literals (e.g., "friend.address.streetName"). This proposal...

Introduction

Swift is able to import C libraries in the same manner as Swift libraries.

For this to occur the library must be represented by a clang modu...

Introduction

Proposal SE-0022 was accepted and implemented to provide a #selector expression to reference Objective-C method sel...

...

Introduction

Function types in Swift use parentheses around their parameter list (aligning with the function declaration syntax, as well as the syntax used ...

Introduction

The current FloatingPoint protocol is quite limited, and provides only a small subset of the features expected of an IEEE 754 conforming type. ...

Introduction

Within a class scope, Self means "the dynamic class of self". This proposal extends that courtesy to value types and to the bodies of class...

Introduction

One of the core principles of Swift is "mutability when you need it." This is espoused by Apple's official documentation about Swift:

• [Value...

Introduction

Swift currently has support for "optional" requirements in Objective-C protocols, to match with the corresponding feature of Objective-C. We do...

Introduction

The Swift API Design Guidelines consider enum cases as values that use the lowerCamel...

Introduction

In Swift 1.2, we attempted to remove all implicit bridging conversions from the language. Unfortunately, problems with how the v1.2 compiler imp...

Introduction

This proposal introduces an optional once argument to the @noescape attribute. The @noescape(once) attribute enforces that the closure do...

Introduction

Swift does not offer any way to efficiently search sorted collections. This proposal seeks to add a few different functions that implement the ...

Introduction

Expanding the build configuration suite to test for the ability to import certain modules was [first introduced](https://forums.swift.org/t/id...

Introduction

UnsafeMutablePointer includes several methods to non-destructively copy elements from memory pointed to by another UnsafeMutablePointer ins...

Introduction

Replace syntax of operator declaration, and replace numerical precedence with partial ordering of operators:

// Before
infix operator...

Introduction

This proposal is to add rotation and in-place reversing methods to Swift's standard library collections.

[Swift-evolution thread](https://foru...

Introduction

When working with escaping Swift closures, it is a common pattern to have the closure capture self weakly to avoid creating an object referen...

Introduction

Swift numeric types all currently have a family of conversion initializers. In many use cases they leave a lot to be desired. Initializing an...

Introduction

This proposal suggests moving the where clause to the end of the declaration syntax, but before the body, for readability reasons. It has bee...

Introduction

This is a proposal for changing the behavior for iterative development of a group of packages. In particular, we will change the default locati...

Introduction

Dynamic casts using as?, as!, and is are currently able to dynamically perform Cocoa bridging conversions, such as from String to `NSSt...

Introduction

Swift permits trailing commas after the last element in array or dictionary literal. This proposal extends that to parameters and tuples.

Orig...

Introduction

This is a proposal for changing the command names used for invoking the Swift package manager. Instead of hanging all functionality off of `swi...

Introduction

As part of Swift 3 API Naming and the introduction of Swift Core Libraries, we are dropping the NS prefix from key Foundation types in Sw...

Introduction

Make lazy declaration modifier an attribute by renaming it to @lazy. Example:

struct ResourceManager {
  @lazy var resource: NSDa...

Introduction

The existing libdispatch module imports the C API almost verbatim. To move towards a more natural Swift interface and away from the C API, this...

Introduction

Swift's String type ships with a large number of initializers that take one unlabeled argument. One of these initializers, defined as `init<T...

Introduction

Swift's grammar currently requires that type references only appear as part of a constructor call T(x) or member access T.x. To get the met...

Introduction

When a type conforms to a protocol that declares an operator as a requirement, that operator must be implemented as a global function defined o...

Introduction

This proposal is from the Generics Manifesto and brings the typealias...

Introduction

Slice types provided by the standard library should allow publ...

Introduction

This proposal introduces sequence(first:next:) and sequence(state:next:), a pair of global functions that return (potentially-infinite) seq...

Introduction

The current protocol<> construct, which defines an existential type consisting of zero or more protocols, should be replaced by an infix & ...

Introduction

This proposal establishes dynamicType as a named operator rather than a property.

Swift-evolution thread: [RFC: didset and willset](https://...

Introduction

This proposal normalizes naming for "negative" attributes by adopting a rule that replaces property names starting with no with adjectives ...

Introduction

This proposal adopts consistent conjoined keyword lowercasing.

Swift-evolution thread: [RFC: didset and willset](https://forums.swift.org/t/rf...

Introduction

Swift condition clauses appear in guard, if, and while statements. This proposal re-architects the condition grammar to enable an arbitra...

Introduction

The Dictionary type should allow initialization from a sequence of (Key, Value) tuples and offer methods that merge a sequence of `(Key, Va...

Introduction

This proposal addresses sizeof, sizeofValue, strideof, strideofValue, align, and alignOf. It discards the value-style standalone fu...

Introduction

We should remove the rarely-used @noreturn function type attribute and instead express functions that don't return in terms of a standard uni...

Introduction

The current default of closure arguments to functions (i.e., arguments to functions that themselves have function type such as (T) -> U) is t...

Introduction

This proposal cleans up Swifts integer APIs and makes them more useful for generic programming.

The language has evolved in ways that affect i...

Introduction

This proposal removes where clauses from for-in loops, where they are better expressed (and read) as guard conditions.

Swift Evolution Dis...

Introduction

Starting in Sierra, Apple's Mac-based OS (OS X) will be renamed "macOS". All user-facing Swift APIs must go through Swift Evolution. While this...

Introduction

Swift enforces type safe access to memory and follows strict aliasing rules. However, code that uses unsafe APIs or imported types can circumve...

Introduction

In Swift, a type T may choose to conform to a protocol P, where P has [associated types](https://developer.apple.com/library/ios/document...

Introduction

For legacy and historical reasons Swift has supported a protocol named Boolean for abstracting over different concrete Boolean types. Thi...

Introduction

Swift's type system should properly distinguish between functions that take one tuple argument, and functions that take multiple arguments.

Di...

Introduction

Swift's type system should not allow function argument labels to be expressed as part of a function type.

Discussion: [pre-proposal](https://f...

Introduction

Swift's error handling model interoperates directly with Cocoa's NSError conventions. For example, an Objective-C method with an NSError** ...

Introduction, Motivation

The standard library lacks equivalents to the floor() and ceil() functions found in the standard libraries of most other langua...

Introduction

This proposal updates parameters and generic type parameters from value names to header names for ManagedBuffer, ManagedProtoBuffer, an...

Introduction

This proposal renames the *LiteralConvertible protocols to ExpressibleBy*Literal.

Swift-evolution thread: [Literal Syntax Protocols](htt...

Introduction

Objective-C interfaces that use id and untyped collections should be imported into Swift as taking the Any type instead of AnyObject.

Sw...

Introduction

Since the first release of Swift, marking a class public has provided two capabilities: it allows other modules to instantiate and use the cl...

Introduction

We propose a revision to the names and argument labels of closure parameters in standard library APIs.

Swift-evolution thread: [Take 2: Stdlib...

Introduction

One great goal for Swift 3 is to sort out any source breaking language changes. This proposal aims to fix access modifier inconsistency on exte...

Introduction

This proposal revises the signature for the collection partition algorithm. Partitioning is a foundational API for sorting and for searching th...

Introduction

Swift's Comparable protocol requires 4 operators, [<, <=, >, and >=](https:...

Introduction

Currently, subscript declarations follow the following model:

subscript(externalName internalName: ParamType) -> ElementType {
    get { … }
...

Introduction

Swift provides optional types as a means of achieving safety by making the notion of "having" or "not having" a value explicit. This requires ...

Introduction

Int.init(ObjectIdentifier) and UInt.init(ObjectIdentifier) should have a 'bitPattern:’ label to make it clear at the use site that we inter...

Introduction

Remove NonObjectiveCBase and isUniquelyReferenced<T: NonObjectiveCBase>(_ object: T). isUniquelyReferenced can be replaced by `isUniquely...

Introduction

This proposal wants to revise metatypes T.Type, repurpose public T.self notation to return a new Type<T> type instance rather than a me...

Introduction

This proposal deals with three routines and one class related to pointers and buffers. The goal of this proposal is to update the API to match ...

Introduction

This proposal aims to change some UnicodeScalar initializers (ones that are non-failable) from non-failable to failable. i.e., in case a `Uni...

Introduction

The Swift Package Manager uses a convention-based rather than a declarative approach for various aspects of package configuration. This is as ...

Introduction

This proposal suggest replacing String initializers taking Character or UnicodeScalar as a repeating value by a more general initializer that t...

Introduction

We propose to add a type-erased AnyHashable container to the standard library.

The implementation of [SE-0116 "Import Objective-C id as Sw...

Introduction

Sequence and Collection offer many special operations which access or manipulate its first or last elements, but they are plagued by inconsis...

Introduction

Swift currently defines two similar functions, joined(separator:) and flatten(). joined(separator:) has a specialized implementation for ...

Introduction

This proposal removes nulTerminatedUTF8 and renames nulTerminatedUTF8CString to enhance clarity and reduce mismatch between user expectatio...

Introduction

As new, source-incompatible versions of Swift come into use, there is a growing need for packages to be authored in a way that makes them usabl...

Introduction

This proposal is to introduce, as a bugfix, a replacement for sizeofValue(_:) and related functions.

Swift-evolution thread: [MemoryLayout f...

Introduction

We propose to deprecate or move protocols that shouldn't be a part of the standard library's public API going forward.

Swift-evolution threads...

Introduction

This is a purely additive proposal to improve the Swift 3 migration experience.

SE-0107: UnsafeRawPointer formaliz...

Introduction

A handful of Swift numeric types are bridged to NSNumber when passed into Objective-C object contexts. We should extend this bridging behavio...

Introduction

Optionals can be used as values of Any type. After SE-0116, this means you can pass an Optional to an Objective-C me...

Introduction

Swift's existing @available(...) attribute indicates the lifecycle of a given declaration, either unconditionally or relative to a particular...

Introduction

This proposal seeks to introduce a where clause to associated type declarations and improvements to protocol constraints to bring associated ...

Introduction

Conditional conformances express the notion that a generic type will conform to a particular protocol only when its type arguments meet certain...

Introduction

The mainline Swift compiler emits an error message when the $ character (U+0024) is used as an identifier by itself, which is a source breaki...

Introduction

This is a proposal for adding package manager features to "pin" or "lock" package dependencies to particular versions.

Motivation

As used ...

Introduction

This proposal introduces the concept of products to the Swift Package Manager, and proposes enhancements to the Package.swift syntax to let...

Introduction

The version of UnsafeMutablePointer.initialize(from:) that takes a Collection should be deprecated in favor of a new method on `UnsafeMutab...

Introduction

Make it possible to have generic subscripts. Example:

extension Collection {
  subscript<Indices: Sequence>(indices: Indices) -> [Ite...

Introduction

This proposal adds enhancements to swift package edit to support development of packages without strict versioning ("top of tree" development...

Introduction

This proposal adds enhancements to the package manifest to support development of packages without strict versioning. This is one of two featur...

Introduction

This proposal adds support for the Swift compiler's new "language compatibility version" feature to the package manager.

Motivation

The Sw...

Introduction

This proposal introduces a "Swift tools version" which is declared for each Swift package. The tools version declares the minimum version of th...

Introduction

First of all, in Swift, the Objective-C copy property attribute translates to @NSCopying.

Like Objective-C, in Swift, avoiding accessing i...

Introduction

This proposal addresses significant unexpected performance gaps when using dictionaries. It introduces type-specific collections for a `Diction...

Introduction

In Swift 3, associated values of an enum case are represented by a tuple. This implementation causes inconsistencies in case declaration, const...

Introduction

This proposal brings more expressive power to the type system by allowing Swift to represent existentials of classes and subtypes which conform...

Introduction

This proposal lifts restrictions on associated types in protocols. Their constraints will be allowed to reference any protocol, including proto...

Introduction

This is a proposal for redesigning the Package.swift manifest APIs provided by Swift Package Manager.
This proposal only redesigns the exis...

Introduction

This proposal presents the problems that came with the the access level modifications in [SE-0025](https://github.com/apple/swift-evolution/blo...

Introduction

One can explicitly write @objc on any Swift declaration that can be expressed in Objective-C. As a convenience, Swift also infers @objc i...

Introduction

We propose a family of concrete Key Path types that represent uninvoked references to properties that can be composed to form paths through ma...

Introduction

This proposal enhances the Package.swift manifest APIs to support custom target layouts, and removes a convention which allowed omission of t...

Introduction

This proposal is to implement a subset of the changes from the [Swift 4 String Manifesto](https://github.com/apple/swift/blob/master/docs/Strin...

Introduction

This proposal disallows the final keyword when declaring functions in protocol extensions.

*Discussion took place on the Swift Evolution mai...

Introduction

This proposal comprises a variety of commonly (and less commonly) suggested improvements to the standard library's Dictionary type, from merg...

Introduction

Foundation's current archival and serialization APIs (NSCoding, NSJSONSerialization, NSPropertyListSerialization, etc.), while fitting fo...

Introduction

As part of the proposal for a Swift archival and serialization API (SE-0166), we are also proposing new...

Introduction

This proposal introduces multi-line string literals to Swift source code. This has been discussed a few times on swift-evolution most recently ...

Introduction

In Swift 3, a declaration marked private may be accessed by anything nested in the scope of the private declaration. For example, a private p...

Introduction

NSNumber has been a strange duck in the Swift world especially when it has come to bridging and interacting with other protocols. An attempt ...

Introduction

A new variant of reduce should be added to the standard library. Instead of taking a combine function that is of type `(A, Iterator.Element...

Introduction

This proposal introduces the concept of a "one-sided" range, created via prefix/postfix versions of the existing range operators.

It also int...

Introduction

As part of the introduction of the Law of Exclusivity, the current swap(_:_:) function must be addressed, as this most common uses of swap ...

Introduction

This proposal implements the filter operation on RangeReplaceableCollection to return the same type as the filtered collection.

Motivat...

Introduction

This proposal makes the package manager's dependency resolution behavior clearer and more intuitive. It removes the pinning commands (`swift pac...

Introduction

In Swift 3, it is possible to modify a variable while it's being used or modified by another part of the program. This can lead to unexpected ...

Introduction

This proposal aims to add functionality to the standard library for clamping a value to a provided Range. The proposed function would allow t...

Introduction

This proposal adds a unicodeScalars view to Character, similar to that on String.

Motivation

The Character element type of `String...

Introduction

The proposal introduces a new swift run command to build and run an executable defined in the current package.

Motivation

It is common t...

Introduction

Today String shares an Index type with its CharacterView but not with its UTF8View, UTF16View, or UnicodeScalarView. This proposal...

Introduction

This proposal adds support for declaring the language standard for C and C++ targets in a SwiftPM package.

Motivation

The C++ language sta...

Introduction

This proposal is a refinement of SE-0168 which introduces the ability to escape newlines in single and mu...

Introduction

This proposal modifies a small number of methods in the standard library that are commonly used with the Substring type:

• Modify the `init...

Introduction

*This document is a spin-off from a much larger [original proposal](https://github.com/tayloraswift/swift-evolution/blob/e888af466c9993de977f69...

Introduction

Developers have to write large amounts of boilerplate code to support equatability and hashability of complex types. This proposal offers a way...

Introduction

This proposal removes support for the keywords weak and unowned for property declarations in a protocol.

Swift-evolution thread: [Ownershi...

Introduction

We propose to deprecate the controversial version of a Sequence.flatMap method and provide the same functionality under a different, and pote...

Introduction

Key-path expressions can now include subscripts to reference individual positions in collections and other subscriptable types, but only when t...

Introduction

Adding a property to a public struct in Swift ought to not be a source-breaking change. However, a client in another target can currently exten...

Introduction

This proposal introduces a platform condition to differentiate device and simulator builds. This condition subsumes a common pattern of conditi...

Introduction

Eliminate the associated type IndexDistance from Collection, and modify all uses to the concrete type Int instead.

Motivation

`Colle...

Introduction

Currently, adding a new case to an enum is a source-breaking change, something that's at odds with Apple's established process for evolving API...

Introduction

We propose introducing a pair of new attributes, @inlinable and @usableFromInline. The @inlinable attribute exports the body of a functio...

Introduction

> *It is a truth universally acknowledged, that a programmer in possession of an enum with many cases, must eventually be in want of dynamic ...

Introduction

This proposal introduces a new @dynamicMemberLookup attribute. Types that use it provide "dot" syntax for arbitrary names which are resolved...

Introduction

This proposal introduces #warning and #error directives that will cause the Swift compiler to emit a custom warning or an error during comp...

Introduction

It is common to want to remove all occurrences of a certain element from a collection. This proposal is to add a removeAll algorithm to the s...

Introduction

The standard library currently includes API which allows a type to customize its description in Xcode playgrounds and Swift Playgrounds. Thi...

Introduction

I propose adding a mutating func toggle to Bool. It toggles the Bool.

• Swift-evolution thread: [Discussion thread topic for that propos...

Introduction

Like many computer languages, Swift uses an escape character (\) to create a special interpretation of subsequent characters within a string ...

Introduction

This proposal adds a new API in PackageDescription to support declaring dependency on a package using its path on disk instead of the git URL...

Introduction

This proposal's main focus is to create a unified random API, and a secure random API for all platforms.

*This idea has been floating around s...

Introduction

The behavior of Sequence.elementsEqual is confusing to users given its name. Having surveyed alternative solutions to this problem, it is pro...

Introduction

The standard library should include methods for finding the last element in a sequence, and the index of the last element in a collection, that...

Introduction

We propose to extend the toplevel withUnsafePointer(to:_:) and withUnsafeBytes(of:_:) functions to work with read-only values.

Swift-evolu...

...

Introduction

It is common to want to confirm that every element of a sequence equals a value, or matches certain criteria. Many implementations of this can ...

Introduction

This proposal introduces a new type of target "system library target", which moves the current system-module packages feature from package to t...

Introduction

This proposal changes the current Package.swift manifest API for declaring for Swift language versions from freeform Integer array to a new `...

Introduction

This proposal introduces the ability for Swift code to query the in-memory layout of stored properties in aggregates using key paths. Like the ...

Introduction

We propose adding a number of properties to the Unicode.Scalar type to support both common and advanced text processing use cases, filling in...

Introduction

This proposal introduces a compiler directive that is syntactically equivalent to the #if swift version check but checks against the versio...

Introduction

T(literal) should construct T using the appropriate literal protocol if possible.

Swift-evolution thread: [Literal initialization via coerci...

Introduction

This proposal renames the confusing and misnamed [DictionaryLiteral](https://github.com/apple/swift/blob/c25188bafd1c775d4ceecc4a795f614f0045...

Introduction

Extend Never so it conforms to Equatable and Hashable.

Swift-evolution thread: [Conform Never to Equatable and Hashable](https://forums.s...

Introduction

This proposal is a follow-up to [SE-0195 - Introduce User-defined "Dynamic Member Lookup" Types](https://github.com/apple/swift-evolution/blob/...

Introduction

This proposal introduces an annotating forced-unwrapping operator to the Swift standard library. It augments the ?, ??, and ! family, add...

Introduction

This proposal adds a combined filter/map operation to Dictionary, as a companion to the mapValues and filter methods introduced by [SE-0165...

Introduction

A dependency mirror refers to an alternate source location which exactly replicates the contents of the original source. This is a proposal for...

Introduction

While Swift's Sequence models brings a lot of niceties that we didn't have access to in Objective-C, like map and filter, there are other...

Introduction

@allevato (a co-author here) proposed [Add Unicode Properties to Unicode.Scalar](https://github.com/apple/swift-evolution/blob/master/proposals...

Introduction

Chaining multiple .map()s and .filter()s on a lazy collection leads to suboptimal codegen, as well as large, painful type names. To improve...

Introduction

This proposal suggests a new initializer and method for Array and ContiguousArray that provide access to an array's uninitialized storage b...

Introduction

This proposal augments the functionality implemented for proposal [SE-0020](https://github.com/apple/swift-evolution/blob/master/proposals/0020...

Introduction

This proposal adds var isEven: Bool, var isOdd: Bool, and func isMultiple(of other: Self) -> Bool to the BinaryInteger protocol. `isEve...

Introduction

This is a proposal for enhancing the package resolution process to resolve the minimal set of dependencies that are used in a package graph.

#...

Introduction

Add the ability to reference the identity key path, which refers to the entire input value it is applied to.

Swift-evolution thread: [Some sma...

Introduction

String interpolation is a simple and powerful feature for expressing complex, runtime-created strings, but the current version of the `Expressi...

Introduction

This proposal would expose a common subset of operations on the SIMD types supported by most processors in the standard library. It is based on...

Introduction

Swift's try? statement currently makes it easy to introduce a nested optional. Nested optionals are difficult for users to reason about, and...

Introduction

Optionals are a key feature of Swift and a powerful tool that seamlessly interacts with code. In particular, they serve a great means in expres...

Introduction

This proposal removes four customization points from protocols in the standard library:

• map, filter, and forEach from Sequence
• `fi...

Introduction

This proposal introduces a weakening of the existing Numeric protocol named AdditiveArithmetic , which defines additive arithmetic opera...

Introduction

This proposal recommends eliminating the associated type from Sequence, moving it up to start at Collection. Current customization points o...

Introduction

Swift's current error-handling, using throws, try, and catch, offers automatic and synchronous handling of errors through explicit syntax...

Introduction

This is a proposal for adding support for specifying a per-platform minimum required deployment target in the Package.swift manifest file.

#...

Introduction

This proposal introduces two new methods, on Sequence and MutableCollection. These methods will allow generic code to make use of the `with...

Introduction

This is a proposal for adding support for declaring some commonly used target-specific build settings in the Package.swift manifest file. As ...

Introduction

SE-0167 introduced Codable conformance for some types in the standard library, but not the Range family of types....

Introduction

This proposal describes additions to the standard library that provide an interchange format for diffs as well as diffing/patching functionalit...

Introduction

[SE-0180][] introduced a computed variable and initializer surrounding the concept of an encodedOffset for serialization purposes. Unfortunat...

Introduction

This proposal aims to solve a simple outstanding problem with the way the Swift compiler currently synthesizes the memberwise initializer for s...

Introduction

Swift’s String type is designed for Unicode correctness and abstracts away the underlying binary representation of the string to model it as ...

Introduction

This proposal is the first part of a group of changes we're considering in a [design document for improving the UI of the generics model](https...

Introduction

This proposal suggests a new initializer for Array and ContiguousArray that provides access to an array's uninitialized storage buffer.

Sw...

Introduction

This proposal introduces two new protocols to the standard library: ElementaryFunctions and Real. These protocols combine to provide "basic...

Introduction

One of the most common API requests from performance-minded users of string is a way to get direct access to the raw underlying code units. Now...

Introduction

String and related types are missing trivial and obvious functionality, much of which currently exists internally but has not been made API. We...

Introduction

This proposal introduces the ability to use the key path expression \Root.value wherever functions of (Root) -> Value are allowed.

Swift-e...

Introduction

We propose that the Swift project adopt a set of code style guidelines and provide a formatting tool that lets users easily diagnose and update...

Introduction

Early adopters of SIMD types and protocols have encountered a few missing things as they've started to write more code that uses them. In addit...

Introduction

This proposal attempts to enable stronger-typed version of the dynamic member lookup by extending functionality of an existing `@dynamicMemberL...

Introduction

This proposal introduces "statically" callable values to Swift. Callable values are values...

Introduction

We propose allowing static subscript and, in classes, class subscript declarations. These could be used through either TypeName[index] or...

Introduction

Swift provides a pleasant shorthand for short closures: if a closure contains just a single expression, that expression is implicitly returned-...

Introduction

This proposal introduces two new protocols: ContiguousCollection, which refines Collection, and MutableContiguousCollection, which refine...

...

Introduction

There are property implementation patterns that come up repeatedly. Rather than hardcode a fixed set of patterns into the compiler (as we have ...

Introduction

The internet is full advice about what not to do when comparing floating-point values:

• "Never compare floats for equality."
• "Always use an...

Introduction

One of Swift's goals is to be a good language for libraries with binary compatibility concerns, such as those shipped as part of Apple's OSs. T...

Introduction

This proposal introduces an Identifiable protocol, a general concept that is broadly useful— for diff algorithms, user interface libraries, a...

Introduction

Introduce a new standard library function, demangle, that takes a mangled Swift symbol, like $sSS7cStringSSSPys4Int8VG_tcfC, and output the...

Introduction

This proposal suggests a new initializer for String that provides access to a String's uninitialized storage buffer.

Motivation

String...

Introduction

We propose changing the Swift Evolution process to publish accepted proposals as individual SwiftPM packages, as well as a SwiftPreview packa...

Introduction

This proposal introduces OffsetBound, which can represent a position in a collection specified as an offset from either the beginning or end ...

Introduction

SE-185 introduced synthesized, opt-in `...

Introduction

This proposal aims to lift the restriction on attaching where clauses to member declarations that can reference only outer generic parameters...

Introduction

Introduce two changes to didSet semantics -

1. If a didSet observer does not reference the oldValue in its body, then the call to fetch...

Introduction

Modify the rule that all uses of self in escaping closures must be explicit by allowing for implicit uses of self in situations where the u...

Introduction

We can use a Range<Index> to refer to a group of consecutive positions in a collection, but the standard library doesn't currently provide a ...

Introduction

Packages should be able to contain images, data files, and other resources needed at runtime. This proposal describes SwiftPM support for spec...

Introduction

SwiftPM currently supports source-only packages for several languages, and with a very proscriptive build model which considerably limits exact...

Introduction

This proposal introduces the ability for Swift package authors to conditionalize target dependencies on platform and configuration with a simil...

Introduction

Today, #file evaluates to a string literal containing the full path to the current source file. We propose to instead have it evaluate to a h...

Introduction

Swift has a beautiful concise yet expressive syntax. As part of that, escaped identifiers are adopted to allow usage of reserved keywords. This ...

Introduction

Currently, each catch clause in a do-catch statement may only contain a single pattern and where clause. This is inconsistent with the behavior...

Introduction

Introduce the Float16 type conforming to the BinaryFloatingPoint and SIMDScalar protocols, binding the IEEE 754 binary16 format (aka *f...

Introduction

This proposal builds on top of the Package Manager Resources proposal to allow defining localized versions...

...

Introduction

The aim of this proposal is to lift an existing restriction, which is that enum cases cannot participate in protocol witness matching.

Swift-e...

Introduction

A Swift language feature for designating a type as the entry point for beginning program execution. Instead of writing top-level code, users ca...

Introduction

This proposal adopts a C/C++-style weak concurrency memory model in Swift, describing how Swift code interoperates with concurrency primitives ...

Introduction

Introduce Equatable, Comparable, and Hashable conformance for all tuples whose elements are themselves Equatable, Comparable, and `Ha...

Introduction

Currently, variadic parameters in Swift are subject to two main restrictions:

• Only one variadic parameter is allowed per parameter list
• If...

Introduction

In [SE-0274][], the core team accepted a proposal to change the behavior of #file. This proposal modifies that plan to transition into new be...

Introduction

SE-0279 "Multiple Trailing Closures" threa...

Introduction

When the type of an expression is implied by the context, Swift allows developers to use what is formally referred to as an "implicit member ex...

Introduction

Checking some mathematical properties of integers (e.g. parity, divisibility, etc.) is widely used in scientific and engineering applications. ...

Introduction

This proposal describes result builders, a new feature which allows certain functions (specially-annotated, often via context) to implicitly ...

Introduction

Swift historically supported the #available condition to check if a specific symbol is available for usage, but not the opposite. In this...

Introduction

This is a proposal for adding support for Package Collections to SwiftPM. A package collection is a curated list of packages and associated...

Introduction

Swift Package Manager downloads dependencies using Git. Our proposal defines a standard web service interface that it can also use to download ...

Introduction

Property Wrappers were introduced in Swift 5.1, and h...

Introduction

This proposal lets Swift Package authors declare targets as executable in the package manifest. This replaces the current approach of inferring...

Introduction

Codable was introduced in SE-0166 with s...

Introduction

Modern Swift development involves a lot of asynchronous (or "async") programming using closures and completion handlers, but these APIs are har...

Introduction

Swift's concurrency feature involves asynchronous functions and actors. While Objective-C does not have corresponding language features, asynch...

Introduction

Swift's async/await feature provides an intuitive, built-in...

Introduction

Using static member declarations to provide semantic names for commonly used values which can then be accessed via leading dot syntax is an imp...

Introduction

Asynchronous Swift code needs to be able to work with existing synchronous code that uses techniques such as completion callbacks and delegate ...

Introduction

Because Swift package manifests are written in Swift using the PackageDescription API, it is difficult to automate common tasks like adding a n...

Introduction

A key goal of the Swift Concurrency effort is to “provide a mechanism for isolating state in concurrent programs to eliminate data races.” Suc...

Introduction

This is a proposal for extensible build tools support in Swift Package Manager. The initial set of functionality is intentionally basic, and fo...

Introduction

async/await is a language mechanism for writing natural, efficient asynchronous code. Asynchronous functions (introd...

Introduction

This proposal extends SwiftPM binary targets to also support other kinds of prebuilt artifacts, such as command line tools. It does not in and ...

Introduction

The Swift concurrency model intends to provide a safe programming model that statically detects [data races](https://en.wikipedia.org/wiki/Race...

Introduction

I propose to extend the language and allow Double and CGFloat types to be used interchangeably by means of transparently converting one type in...

Introduction

Swift has conditional compilation block #if ... #endif which allows code to be conditionally compiled depending on the value of one or more c...

Introduction

Swift allows one to use a protocol as a type when its requirements meet a rather unintuitive list of criteria, among which is the absence of ...

Introduction

Nominal types such as classes, structs, and enums in Swift support [computed properties](https://docs.swift.org/swift-book/LanguageGuide/Proper...

Introduction

With Swift embracing asynchronous functions and actors, asynchronous code will be everywhere.

Therefore, the need for debugging, tracing and ...

Introduction

This proposal aims to fix the lack of Collection conformance of the sequences returned by zip(_:_:) and enumerated(), preventing them from...

Introduction

The [Swift actors proposal][actors] introduces the notion of actor-isolated declarations, which are declarations that can safely access an ac...

Introduction

The continuation types added in SE-0300 act as adaptors fo...

Introduction

When Swift's type inference is unable to work out the type of a particular expression, it requires the programmer to provide the necessary type...

Introduction

Actors are a new kind of reference type that protect their instance data from concurrent access. Swift actors achieve this wi...

Introduction

Structured concurrency provides a paradigm for spawning concurrent child tasks in scoped task groups, est...

...

Introduction

This proposal conforms Never to Identifiable to make it usable as a "bottom type" for generic constraints that require Identifiable.

...

Introduction

The current conformance of Swift's Dictionary to the Codable protocols has a somewhat-surprising limitation in that dictionaries whose key ...

Introduction

The [package registry service][SE-0292] defines endpoints for fetching packages.

This proposal extends the existing [package registry specific...

Introduction

This proposal introduces new Standard Library functions for manipulating temporary buffers that are preferentially allocated on the stack inste...

Introduction

Program setup generally occurs in the main function where developers expect to perform operations before other parts of the program are run. Ob...

Introduction

C has special rules for pointer aliasing, for example allowing char * to alias other pointer types, and allowing pointers to signed and unsig...

Introduction

SE-0303 introduced the ability to define...

Introduction

I propose to improve inference behavior of multi-statement closures by enabling parameter and result type inference from the closure body. This...

Introduction

Actors are a relatively new nominal type in Swift that provides data-race safety for its mutable state. The protection is achieved by _isolatin...

Introduction

An opaque result type may be used as the result typ...

Introduction

The concepts of time can be broken down into three distinct parts:

1. An item to provide a concept of now plus a way to wake up after a given ...

Introduction

This is a lightning proposal to extend the existing Swift language slightly to allow #if conditional inclusion of elements in array and dicti...

Introduction

SE-0302 introduced the Sendable protocol, including Sendable requirements for various l...

Introduction

SE-0303 introduced the ability to define...

Introduction

The function withMemoryRebound(to:capacity:_ body:) executes a closure while temporarily binding a range of memory to a different type than t...

Introduction

This proposal introduces some quality-of-life improvements for UnsafePointer and its Mutable and Raw variants.

1. Add an API to obtain a...

Introduction

Existential types in Swift have an extremely lightweight spelling: a plain protocol name in type context means an existential type. Over the ye...

Introduction

With the recent introduction of actors to the language, Swift ga...

Introduction

Swift 5.5 introduced mechanisms to eliminate data races from the language, including the Sendable protocol ([SE-0302](https://github.com/appl...

Introduction

SE-0306, which introduced actors to Swift, states that async f...

Introduction

Swift does not allow multiple modules in a program to share the same name, and attempts to do so will fail to build. These name collisions can ...

Introduction

The Swift concurrency model allows tasks to resume on different threads from the one they were suspended on. For this reason, API that relies o...

Introduction

Swift's syntax for generics is designed for generality, allowing one to express complicated sets of constraints amongst the different inputs an...

Introduction

Swift 5.3.1 introduced [statically linking the Swift runtime libraries on Linux](https://forums.swift.org/t/static-linking-on-linux-in-swift-5-...

Introduction

Bringing concurrency to top-level code is an expected continuation of the concurrency work in Swift. This pitch looks to iron out the details o...

Introduction

With the recent introduction of actors to the language, Swift ga...

Introduction

Optional binding using if let foo = foo { ... }, to create an unwrapped variable that shadows an existing optional variable, is an extremely ...

Introduction

As a step toward the goal of improving the UI of generics outlined in [Improving the UI of Generics](https://forums.swift.org/t/improving-the-u...

Introduction

It's currently impossible to use a default value expression with a generic parameter type to default the argument and its type:

func ...

...

Introduction

Swift does not currently provide a clear way to load data from an arbitrary source of bytes, such as a binary file, in which data may be stored...

Introduction

Swift strings provide an obsessively Unicode-forward model of programming with strings. String processing with Collection's algorithms is woe...

Introduction

[Declarative string processing] aims to offer powerful pattern matching capabilities with expressivity, clarity, type safety, and ease of use. ...

Introduction

Existential types in Swift allow one to store a value whose specific type is unknown and may change at runtime. The dynamic type of that stored...

Introduction

Existential types complement the Swift type system’s facilities for abstraction. Like generics, they enable a function to take and return multi...

Introduction

We propose the introduction of regex literals to Swift source code, providing compile-time checks and typed-capture inference. Regex literals h...

Introduction

A regex declares a string processing algorithm using syntax familiar across a variety of languages and tools throughout programming history. We...

Introduction

This proposal describes a convention for writing a new form of sample code called snippets. Snippets are short, single-file examples that can...

Introduction

The Swift standard library's string processing algorithms are underpowered compared to other popular programming and scripting languages. Some ...

Introduction

[SE-0346] introduced the concept of primary associated types to the language. This document proposes to adopt this feature in the Swift Standar...

Introduction

A Swift language feature for requiring certain values to be knowable at compile-time. This is achieved through an attribute, @const, constrai...

Introduction

Since their introduction in SE-0244, opaque result ...

Introduction

Specifying the type arguments to a generic type in Swift is almost always written in angle brackets, such as Array<String>. Extensions are a ...

Introduction

Swift 6 is accumulating a number of improvements to the language that have enough source-compatibility impact that they could not be enabled by...

Introduction

This proposal describes Regex's rich Unicode support during regex matching, along with the character classes and options that define and modi...

Introduction

Many Swift libraries vend currency protocols, like Equatable, Hashable, Codable, among others, that unlock worlds of common functionality for t...

Introduction

As of SE-0269, implicit self is permit...

Introduction

In this document, we propose adding a new operator, marked by the context-sensitive keyword consume, to the language. consume ends the life...

Introduction

Over time, Swift has introduced a number of new attributes to communicate additional information in source code. Existing code can then be upda...

Introduction

Integer literals in Swift source code can express an arbitrarily large value. However, types outside of the standard library which conform to `...

Introduction

This proposal is to add conformance to the protocol CustomDebugStringConvertible to AnyKeyPath.

Motivation

Currently, passing a keypa...

Introduction

The types in the UnsafeMutablePointer family typically require manual management of memory allocations, including the management of their ini...

Introduction

This feature allows deinit's of actors and global-actor isolated types (GAITs) to access non-sendable isolated state, lifting restrictions im...

Introduction

Swift's sorting algorithm was changed to be stable before Swift 5, but we've never updated the documentation to provide that guarantee. Let's c...

Introduction

The implementation of the result builder transform (introduced by [SE-0289](https://github.com/apple/swift-evolution/blob/main/proposals/0289-r...

Introduction

The Clock protocol introduced in Swift 5.7 provides a way to suspend until a future instant, but does not provide a way to sleep for a durat...

Introduction

SE-0352 "Implicitly Opened Existentials" has...

Introduction

This proposal introduces a @backDeployed attribute to allow ABI-stable libraries to make their own public APIs available on older OSes. When ...

Introduction

We propose new borrowing and consuming parameter modifiers to allow developers to explicitly choose the ownership convention that a functio...

Introduction

A package registry may require authentication for some or all of its API in order to identify user performing the action and authorize the req...

Introduction

This proposal seeks to increase the safety, efficiency, and secrecy of Swift Reflection Metadata by improving the existing mechanism and provid...

Introduction

This proposal introduces the ability to use if and switch statements as expressions, for the purpose of:

• Returning values from functions,...

Introduction

We propose to introduce a new type of structured concurrency task group: Discarding[Throwing]TaskGroup. This type of group is similar to `T...

Introduction

Expression macros provide a way to extend Swift with new kinds of expressions, which can perform arbitrary syntactic transformations on their a...

Introduction

@UIApplicationMain and @NSApplicationMain used to be the standard way for iOS and macOS apps respectively to declare a synthesized platform...

Introduction

This proposal seeks to improve the usability of existing Objective-C libraries from Swift by reducing the negative impact forward declarations ...

Introduction

In Swift, declarations are annotated with attributes to opt into both built-in language features (e.g. @available) and library functionality ...

Introduction

This proposal introduces package as a new access modifier. Currently, to access a symbol in another module, that symbol needs to be declared...

Introduction

Cross-compilation is a common development use case. When cross-compiling, we need to refer to these concepts:

• a toolchain is a set of to...

Introduction

We propose introducing helper methods for creating AsyncStream and AsyncThrowingStream instances which make the stream's continuation easie...

Introduction

Attached macros provide a way to extend Swift by creating and extending declarations based on arbitrary syntactic transformations on their argu...

Introduction

This proposal introduces the concept of noncopyable types (also known as "move-only" types). An instance of a noncopyable type always has u...

Introduction

A package registry makes packages available to consumers. Starting with Swift 5.7, SwiftPM supports dependency resolution and package download ...

Introduction

As Swift Concurrency continues to mature it is becoming increasingly important to offer adopters tighter control over where exactly asynchronou...

Introduction

Many modern Swift libraries include ad-hoc variadic APIs with an arbitrary upper bound, typically achieved with overloads that each have a diff...

Introduction

Macros provide a way to extend Swift by performing arbitrary syntactic transformations on input source code to produce new code. One example fo...

Introduction

Making responsive apps often requires the ability to update the presentation when underlying data changes. The observer pattern allows a subj...

Introduction

Extend Never so that it conforms to the Encodable and Decodable protocols, together known as Codable.

Motivation

Swift can synthes...

Introduction

SE-0382 "Expression macros" introduced macros into Sw...

Introduction

Previously SE-0393 introduced type parameter packs and several related concepts, allowing generic function declarati...

Introduction

Building upon the Value and Type Parameter Packs proposal [SE-0393](https://forums.swift.org/t/se-0393-value-and-type-parameter-packs/63859...

Introduction

Init accessors generalize the out-of-line initialization feature of property wrappers to allow any computed property on types to opt into defin...

Introduction

SE-0316: Global Actors introduced annotations like `@Main...

Introduction

This proposal generalizes the conformance macro role as an extension macro role that can add a member list to an extension in addition to a...

Introduction

This is a proposal for adding package manager support for targets containing both Swift and [C based language sources][SE-0038] (henceforth, re...

Introduction

Allows protocols to be nested in non-generic struct/class/enum/actors, and functions.

Motivation

Nesting nominal types inside other nomi...

Introduction

We propose adding new String failable initializers that validate encoded input, and return nil when the input contains any invalid elements...

Introduction

SE-0314 introduced new Async[Throwing]Stream types which...

Introduction

The move from conformance macros to extension macros in [SE-0402](https://github.com/apple/swift-evolution/blob/main/proposals/0402-extension-m...

Introduction

Building upon the Value and Type Parameter Packs proposal SE-0393, t...

Introduction

Declaring the visibility of a dependency with an access-level modifier on import declarations enables enforcing which declarations can referenc...

Introduction

This proposal adds a limited set of low-level atomic operations to the Standard Library, including native spellings for C++-style memory orderi...

Introduction

Default value expressions are permitted for default arguments and default stored property values. There are several issues with the current act...

Introduction

This proposal defines options for the usage of global variables free of data races. Within this proposal, global variables encompass any storag...

Introduction

Swift's error handling model allows functions and closures marked throws to note that they can exit by throwing an error. The error values th...

Introduction

Swift Concurrency assigns values to isolation domains determined by actor and task boundaries. Code running in distinct isolation domains can...

Introduction

Macros augment Swift programs with additional code, which can include new declarations, expressions, and statements. One of the key ways in whi...

Introduction

Today, keypath literals can only be narrowly converted to a function which exactly matches the argument and return type. This proposal allows k...

Introduction

Swift Concurrency uses tasks and actors to model concurrency and primarily relies on actor isolation to determine where a specific piece of cod...

Introduction

This proposal is focused on a few corner cases in the language surrounding functions as values and key path literals when using concurrency. We...

Introduction

This year we are improving the usability of Swift for command line and server-side development by adding first-class support for backtraces to ...

Introduction

Under Swift's [actors design][SE-0306], every function in Swift has an actor isolation: it is either isolated to some specific actor or non-iso...

Introduction

This proposal generalizes AsyncSequence in two ways:

1. Proper throws polymorphism is accomplished with adoption of typed throws.
2. A new ...

Introduction

This proposal aims to lift the restriction afore set in [SE-0382 "Expression macros"](https://github.com/apple/swift-evolution/blob/main/propos...

Introduction

Many Swift programs need to interoperate with frameworks written in C/C++/Objective-C whose implementations cannot participate in static data r...

Introduction

SE-0392 (Custom Actor Executors) added support f...

...

Introduction

We propose a new, limited protocol BitwiseCopyable that can be conformed to by types that are "bitwise-copyable"[^1]--that ...

Introduction

The noncopyable types introduced in SE-0390: Noncopyable structs and enums cannot be used with generic...

Introduction

Swift's distributed actors offer developers a flexible bring-your-own-runtime approach to building distributed systems using the actor paradigm...

Introduction

We propose allowing noncopyable fields in deinit-less aggregates to be consumed individually, so long as they are defined in the current module...

Introduction

This proposal extends region isolation to enable the application of an explicit sending annotation to function parameters and results. A func...

Introduction

The actor isolation of a function is an important part of how it's used. Swift can reason precisely about the isolation of a specific function...

Introduction

Pattern matching over noncopyable types, particularly noncopyable enums, can be generalized to allow for pattern matches that borrow their subj...

Introduction

This proposal introduces a mutual exclusion lock, or a mutex, to the standard library. Mutex will be a new synchronization primitive in the s...

Introduction

This proposal encompasses a collection of changes to concurrency rules concerning global-actor-isolated types to improve their usability.

...

Introduction

The current Swift Package Manager manifest API for specifying Swift language version(s) applies to an entire package which is limiting when ado...

Introduction

We propose an alternative to @objc classes where Objective-C header @interface declarations are implemented by Swift extensions marked wi...

...

Introduction

Key path expressions access properties dynamically. They are declared with a concrete root type and one or more key path components that define...