Pitch: Narrowed Any — closed-class-of-conformers existentials with A | B
The "type-only unions" line of pitches has bounced off this forum many times on the same pre-judgements (TypeScript-style erasure, structural-union member synthesis, unsoundness with nominal typing). The shape below is deliberately not any of those: a closed-class-of-conformers existential that reuses Swift's existing any P machinery and asks the type system to learn nothing new.
Below is the full v1 surface syntax. The formal proposal is long (, will be renamed SE-NNNN-… at review) — for design rationale, alternatives considered, anticipated objections, and full implementation details I'd recommend reading it directly rather than re-doing the prose here. Prototype: miku1958/swift branch narrowed-any/phase1-poc.
Reading note. This is not TypeScript-style structural unions, not a sum / coproduct, not an anonymous enum. It is
Anyconstrained to a closed list of dynamic types — same existential machinery already shipped forany P, retargeted at a finite list of leaves rather than a single protocol's conformer set. Layout-equivalent toany; no new metadata kind, no new ABI category, no runtime change, no OS upgrade to adopt.
v1 syntax surface
// 1. Values: `A | B` is `Any` narrowed to a closed set of dynamic types.
let v: Int | String = 42 // OK — leaf injection (only implicit move)
let w: Int | String = "hi" // OK — same
let x: Int | String = 3.14 // ⛔ Double is not a leaf
// 2. Pattern matching is exhaustive over the closed leaf set — no `default` needed.
switch v {
case let n as Int: print("int: \(n)")
case let s as String: print("str: \(s)")
}
// 3. Typed throws across heterogeneous error domains (the headline use case).
func loadUser() throws(NetworkError | DecodingError | AuthError) -> User { … }
do {
let u = try loadUser()
} catch let e as NetworkError { … }
catch let e as DecodingError { … }
catch let e as AuthError { … } // exhaustive — no trailing `default` / `catch`
// 4. Generic constraints — same-type degraded form.
func process<T>(_ error: T) where T == NetworkError | DecodingError { … }
// ^^^^ note: == not : — the colon form is parser-rejected
// in v1 and reserved for the True set-membership
// future direction. Today's code uses == cleanly.
// 5. Untagged Codable round-trip — declaration order drives decode try-order.
typealias V = Int | String
let v1: V = "hello"
let json = try JSONEncoder().encode(v1) // → "hello" (just the leaf — no envelope, no `_kind`)
let back = try JSONDecoder().decode(V.self, from: json) // tries Int, then String
// 6. Composes anywhere a type is expected.
let arr: [Int | String] = [1, "two", 3]
let lookup: [String: Int | Double] = ["pi": 3.14]
let make: (Int | String) -> Void = { _ in }
extension Array where Element == Int | String { … }
Cross-shape conversion
let a: Int | String = 42
// Total cast — same leaf set, different spelling: free SIL relabel.
let b: String | Int = a // ⛔ implicit cross-shape — fix-it: ` as String | Int`
let b: String | Int = a as String | Int // ✅
// Partial overlap → `as?` / `as!`. Runtime decides per value.
let c: (Int | Double) | String = "hi"
if let s = c as? Int | String { print(s) } // .some("hi")
// Class-hierarchy subtyping at the leaf level — total when every source leaf
// subtypes some target leaf, even when no leaf names match.
let pet: Dog | Cat = ...
let animal = pet as Animal // ✅ Dog: Animal, Cat: Animal
// Disjoint leaf sets — hard error in `as` / `as?` / `as!`. `is` stays a warning.
let v: Int | Double = 7
v as? String // ⛔ error (Int|Double ∩ String = ∅)
_ = v is String // ⚠ warning — well-typed false
Container extensions and per-element costs
extension Array where Element == Int | String { func summary() -> String { … } }
[1, "two"] .summary() // ✅ ys: [Int | String] — exact match
[1, 2] .summary() // ⛔ leaf-typed [Int] — fix-it: ` as [Int | String]`
(["a", 7] as [Int | String]).summary() // ✅ cross-spelling — runtime-free SIL relabel
([1, 2] as [Int | String]).summary() // ✅ leaf injection — O(N) per-element wrap
| Reshape | Cost | Memory peak |
|---|---|---|
Cross-spelling [A|B] → [B|A] |
O(1) SIL relabel | unchanged |
Leaf injection [A] → [A|B] |
O(N) per-element wrap | ~4× (8 → 32-byte stride) |
Narrowed → leaf via as? |
O(N) walk + dynamic check | 1× new buffer or 0 |
Inhabited-subset rule for Never leaves
func mayThrow() throws(SomeError | Never) -> Int { … } // behaves like throws(SomeError)
func nothrows() throws(Never | Never) -> Int { 99 } // non-throwing — multi-leaf SE-0413
let r = try mayThrow()
let n = nothrows() // ✅ no try
switch (v: Int | Never) { // no `case _ as Never:` arm needed
case let n as Int: print(n)
}
Type identity is preserved: A | Never and A have different mangled names, signatures, and witness identities. The inhabited-subset rule governs only call-site reachability, not type identity.
The five load-bearing rules
- Leaf injection is the only implicit move. A leaf-typed value flows into a narrowed-
Anydeclaration that lists that leaf, anywhere in the recursive expansion. Every other narrowed-Any↔ narrowed-Anyconversion needs explicitas/as?/as!. - Spelling is identity.
Int | String≠String | Int≠(Int | String) | Bool. Different spellings are different types with different mangled names. The user's chosen spelling drives Codable try-order, switch-completion order, and witness selection — silently normalising would silently change behaviour. - Depth-1 principle: structurally nested, behaviourally flat.
(A | B) | Chas outer leaves{A | B, C}, butswitch/ leaf injection /as?walk the deep leaf set — three flat arms, not "narrow first, then expand". Same asInt??overOptional. SwiftUI's_ConditionalContent<_ConditionalContent<A,B>,C>already exhibits this; replacing it withT | Fretires the wrapper struct. - No normalisation.
T | T,Cat | Animal(whereCat: Animal),T | T?are all legal and stay as written. - Cross-shape
asfollows class-hierarchy convention.asfor total casts (source leaves ⊆ target leaves),as?/as!for partial overlap, hard error for disjoint (stricter than current Swift's5 as? Stringwarning, since the closed leaf set turns "no type in common" into a static fact).
The full design — including why each classical type-union law (commutativity, associativity, idempotence, absorption, optional-collapse) is deliberately rejected, the typed-throws O(N+M) composition argument, the conformance synthesis story, debugger-interaction notes for Codable, and the full set of objections answered — is in the proposal. There's enough nuance there that re-doing it as forum prose here would lose precision.
Implementation status
covers runtime-positive cases (single-file %target-run-simple-swift plus a split-file cross_module.swift + %target-run) and a verify-mode diagnostics.swift. Companion swift-syntax fork at miku1958/swift-syntax (branch narrowed-any/syntax-sync).
Working today: parser, AST node, mangling (XN), .swiftmodule / .swiftinterface round-trip; cross-shape as / as? / as! via swift_dynamicCast; pattern matching exhaustiveness; self-conforming Error / Sendable / marker protocols; per-witness dispatch for Hashable / Equatable / Comparable / CustomStringConvertible / Encodable / Decodable (JSONEncoder().encode(v), Set<Int | String>, < over Int | Double, \(v) interpolation — all work, no as! any P needed); untagged Codable round-trip; typed throws end-to-end (per-leaf try-propagation, inhabited-subset Never rule); where T == A | B (colon form parser-rejected); Set / Dict / Array / KeyPath / reflection; -O SILOptimizer integration.
Known v1 gaps (proposal §"Implementation status" has the full breakdown):
- Per-element leaf injection auto-fix-it at the extension boundary — landed; the implicit form (no cast at all) is the deferred follow-up.
- Cross-spelling fix-it — fires for leaf-injection, not yet for cross-spelling (separate Sema follow-up; cast itself works).
- Strict-invariant rule's function-type axis still silent — the three container sub-cases (
[A] → [A|B],[A|B] → [Any],Set<A> → Set<A|B>) now error correctly; function-type parameter narrowing ((Int) -> Void = fforf: (Int|String) -> Void) is the remaining v1-blocking item.
Deferred to focused follow-ups: direct member access on a narrowed-Any value (v.description); generalised per-narrowed-Any witness emission for user protocols; witness-merge; variance at the witness boundary; order-insensitive marker; true set-membership; SourceKit auto-cast completion. ~10 items total — see Future directions for the list.
Asks for the forum
- Is spelling-as-identity the right axiom (
A | B≠B | A,(A | B) | C≠A | B | C), or should v1 normalise / flatten? The proposal argues for spelling-as-identity to make Codable try-order, witness selection, and mangling tractable — cost is one explicitaswhen reshaping. - Does untagged Codable match library-author needs, or is
_kind-tagged the right default? v1 ships the untagged synthesis; user-overrideextension Int | String: Codable { ... }is paired with the broader extending-narrowed-Any-directly follow-up. - Typed throws is the killer use case — does
throws(NetErr | DecodeErr | AuthErr)with per-leaf catch arms (O(N+M)instead ofO(N×M)wrapper enums) match how you'd expect typed throws to compose across libraries? - Are there type positions beyond {value, constraint, pattern, throws} where you'd expect
A | B? The proposal sweeps function-type, tuple, container, and generic-argument positions — flag misses. - The prototype reuses
Any's singleton runtime metadata for ABI-additive evolution (no OS upgrade, back-deploys to any Swift-supporting target). One concrete consequence:Set<Int | String>.union/intersection-style collection-arithmetic ops crash because the runtime conformance walk reads element-type metadata asAny— basicSet<Int | String>(construct, contains, deduplicate) works fine. Acceptable v1 trade-off, or should narrowed-Anyget distinct metadata? - Of the ~10 deferred follow-ups in Future directions, any you'd expect to ship with v1 rather than as a follow-up?
Discussion welcome before the formal pitch lands as SE-NNNN.