[Proposal] Static member lookup on protocol metatypes
Swift currently supports static member lookup on concrete types. This improves call-site legibility by enabling us to use leading dot syntax when accessing static values. In this Swift evolution pitch, Sam Lazarus proposes extending static member lookup to protocol metatypes. This would be a nice addition, and would not have any effect of source of API stability.
Posted on November 22, 2020
#evolution
#protocol
Swift Concurrency Roadmap
This post from the official Swift forums outlines the Swift Concurrency Roadmap. The goal of this roadmap is to make concurrent programming in Swift convenient, efficient, and safe. There is a lot to unpack in this post, but it's definitely worth reading, and there are some great language features planned for the first phase of the roadmap.
Posted on November 9, 2020
#concurrency
#evolution
Placeholder types
Building on a previous Swift evolution thread, Frederick Kellison-Linn pitches a proposal to add what he calls placeholder types to Swift. These placeholder types could be used when we want to explicitly provide some type information but also want the compiler to infer some type information.
Posted on November 4, 2020
#evolution
#compiler
Unlock Existential Types for All Protocols
Swift currently allows protocols that meet certain criteria to be used as types. Using a protocol in such a way essentially creates an existential type. However, protocols with associated type or self requirements cannot currently be used to create such existential types. This Swift evolution pitch proposes removing this restriction.
Posted on October 22, 2020
#evolution
#protocol
#existential
Result builders
This Swift evolution proposal outlines the motivation and design for Result Builders, the Swift language feature previously known as Function Builders. Result Builders have been an available feature since Swift 5.1, albeit slightly hidden, and its implementation and capabilities have evolved since then.
Posted on October 18, 2020
#evolution
#result builders
Announcing Swift Algorithms
Swift Algorithms is a new open-source Swift package of sequence and collection algorithms. In this post, Nate Cook from the Swift standard library team at Apple gives a brief tour of this package and describes its relation to the Swift standard library.
Posted on October 15, 2020
#open-source
#collection
#sequence
#algorithm
#evolution
Standard library behavior change for LazyMapCollection prefix to act as a Sequence
The Swift standard library provides lazy variations of its Sequence and Collection types, on which operations such as map and filter are implemented lazily. This means that the actual computations will only occur when the results are needed. In this Swift evolution pitch, Greg Titus proposes an addition to the standard library that improves the behavior of the LazyMapCollection type.
Posted on September 16, 2020
#evolution
#collection
#sequence
Support Negative Availability Literals
The availability condition #available is used to execute code conditionally based on the required platform and version conditions. Currently, it's only possible to check if conditions are positively satisfied. In this Swift evolution pitch, Bruno Rocha proposes extending #available to support checking if conditions are not satisfied.
Posted on September 13, 2020
#evolution
Typed throws
Swift provides support for throwing, catching, propagating, and manipulating recoverable errors. To indicate that a function or method can throw an error, we add the throws keyword to the declaration. In this very detailed Swift evolution pitch, Jorge proposes adding the ability to specify the type of an error that a function will throw.
Posted on September 1, 2020
#evolution
#error
Extend implicit member syntax to cover chains of member references
This Swift evolution proposal suggests an expansion of implicit member syntax to more complex expressions than just a single static member or function. What this means is that when the type of an expression is implied by the context, developers would be able to use leading dot syntax, even when the expression consists of chains of member references. This is a very logical language evolution in my opinion.
Posted on August 30, 2020
#evolution