~Escapable, Span, Ownership Annotations, etc

[Jon_Shier]

@Dmitriy_Ignatyev

Our discussion is happening in the space of meanings and features at the leading edge of Swift’s evolution, including experimental, upcoming, and even not-yet-implemented features. However, my experience shows that a large number of developers are only fragmentarily and selectively aware of new Swift capabilities. Many developers still don’t know about Never, Duration, variadic generics, or typed throws, and even fewer are aware of move-only types, init accessors, InlineArray, or region-based isolation.

Developers may be unaware of these features because Swift does a poor job of surfacing their existence at the level most developers operate, and makes it difficult to try them out. I've never been able to use a toolchain to build an iOS app, which is still the vast majority of Swift code.

• Never: I'd actually say this is fairly common for anyone writing or using generic code. You have to at least type the word to use Combine, for example.
• Duration: Types with limited OS availability will naturally see limited use. iOS 16 only just became a common deployment target in the last year for many companies.
• variadic generics: Useful feature that is extremely buggy (or incomplete), so is avoided or dropped. It shouldn't be a surprise that, when a feature turns up bug reports or other issues in search results, it doesn't become popular.
• typed throws: Incomplete feature missing the most useful part, inference through closures. Unless you know the additional syntax required to let it be even partly useful, it just looks broken.
• move-only types: Niche feature that doesn't have any obvious use cases for most developers. I've only ever used it because that was the only way to get a logger working with @_transparent to call the runtime issue API.
• init accessors: Also niche, with odd syntax, so it isn't discoverable, but I have seen it used where appropriate in knowledgeable libraries.
• InlineArray: Also niche, and also runtime limited, so I wouldn't expect to see much usage until later this year at the earliest, probably next year.
• region-based isolation: This isn't a developer feature, and is enabled by default in Swift 6 mode, so all Swift 6 devs use it. I wouldn't expect developers to know about it at all, any more than other compiler intelligence features, but anyone who's transitioned from Swift 5 to 6 definitely knows about it, since it's a huge part of the compiler's concurrency intelligence that makes the feature actually work.

If Swift would like to make its features more discoverable, that's great. A linter for adopting new language features to better replace existing patterns would be well received. But given Swift's limited attempts to encourage adoption, and deployment limitations on its most popular platform, you can't really use such limited adoption to say that evolution at the cutting edge can proceed without considering such adoption.