Per-API comparison of the Apple Swift standard library against MiniSwift's native (ir-to-c) implementation, across the practical core surface. Native backend: ✅ runtime + IR lowering · 🟡 partial / with caveat · ❌ name-resolves only.
init()init(_ value: Bool)init(booleanLiteral value: Bool)init?(_ description: String)prefix static func ! (a: Bool) -> Boolstatic func && (lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows -> Boolstatic func || (lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows -> Boolstatic func == (lhs: Bool, rhs: Bool) -> Boolmutating func toggle()var description: String { get }func hash(into:) ; var hashValue: Intstatic func random<T>(using generator: inout T) -> Bool where T : RandomNumberGeneratorusing: &rng custom RNG calls consume rng.next() on WASM/native; verified with custom and system RNG smoke paths.static func random() -> Boolinit(from: any Decoder) throws ; func encode(to: any Encoder) throwsJSONEncoder/JSONDecoder Bool true/false scalar paths work on WASM/native.var customMirror: Mirror { get }customMirror.displayStyle == nil scalar Mirror sentinel is verified for true/false.extension Bool : CVarArg, BitwiseCopyableinit(integerLiteral value: Self)init<T>(_ source: T) where T : BinaryIntegerinit<T>(_ source: T) where T : BinaryFloatingPoint ; Int(_ : Double/Float)init(_ source: Float16) ; init?(exactly: Float16)-0.0, and fractional nil on WASM/native.init?<T>(exactly source: T)init<Other>(clamping source: Other) where Other : BinaryIntegerinit<T>(truncatingIfNeeded source: T) where T : BinaryIntegerinit(bitPattern x: UInt)init(bitPattern pointer: OpaquePointer?) ; init(bitPattern objectID: ObjectIdentifier)init?<S>(_ text: S, radix: Int = 10) where S : StringProtocol.some(0), Int.min, Int.max, invalid nil, overflow nil, and narrow Int8/UInt8 range smoke paths.init?(_ description: String)Int.min; radix overload is covered by init?(_:radix:).init(littleEndian value: Self) ; init(bigEndian value: Self)static func + (Self,Self)->Self ; static func += (inout Self,Self)static func - (Self,Self)->Self ; static func -= (inout Self,Self)static func * (Self,Self)->Self ; static func *= (inout Self,Self)static func / (Self,Self)->Self ; static func /= (inout Self,Self)static func % (Self,Self)->Self ; static func %= (inout Self,Self)prefix static func - (operand: Self) -> Selfmutating func negate()static func &+ (Self,Self)->Self ; static func &+= (inout Self,Self)static func &- (Self,Self)->Self ; static func &-= (inout Self,Self)static func &* (Self,Self)->Self ; static func &*= (inout Self,Self)func addingReportingOverflow(_ rhs: Self) -> (partialValue: Self, overflow: Bool)func subtractingReportingOverflow(_ rhs: Self) -> (partialValue: Self, overflow: Bool)func multipliedReportingOverflow(by rhs: Self) -> (partialValue: Self, overflow: Bool)func dividedReportingOverflow(by rhs: Self) -> (partialValue: Self, overflow: Bool)(self, true) without trapping in native/WASM.func remainderReportingOverflow(dividingBy rhs: Self) -> (partialValue: Self, overflow: Bool)(self, true) and Int.min % -1 returns (0, true) without trapping.func multipliedFullWidth(by other: Self) -> (high: Self, low: Self.Magnitude)(high, low) in WASM/native for the supported 64-bit path (3*4 -> 0,12 verified).func dividingFullWidth(_ dividend: (high: Self, low: Self.Magnitude)) -> (quotient: Self, remainder: Self)high == 0 (34 / 17 -> 2 r0).func quotientAndRemainder(dividingBy rhs: Self) -> (quotient: Self, remainder: Self)func isMultiple(of other: Self) -> Boolfunc signum() -> Selfstatic func & (Self,Self)->Self ; static func &= (inout Self,Self)static func | (Self,Self)->Self ; static func |= (inout Self,Self)static func ^ (Self,Self)->Self ; static func ^= (inout Self,Self)prefix static func ~ (x: Self) -> Selfstatic func << <RHS>(Self,RHS)->Self ; static func <<= ... where RHS : BinaryIntegerstatic func >> <RHS>(Self,RHS)->Self ; static func >>= ... where RHS : BinaryIntegerstatic func &<< (Self,Self)->Self ; static func &>> (Self,Self)->Self (+ generic + assign forms)1 &<< 65, 8 &>> 65).static func == (Self,Self)->Bool ; static func != (Self,Self)->Boolstatic func < / <= / > / >= (Self,Self)->Boolstatic func == <Other>(Self,Other)->Bool where Other : BinaryInteger (+ family)Int8 < Int, UInt8 == Int).static var min: Self { get }static var max: Self { get }static var bitWidth: Int { get }var bitWidth: Int { get }var leadingZeroBitCount: Int { get }var trailingZeroBitCount: Int { get }var nonzeroBitCount: Int { get }var byteSwapped: Self { get }var bigEndian: Self { get } ; var littleEndian: Self { get }var magnitude: Self.Magnitude { get } ; Int.magnitude: UIntvar words: Self.Words { get }.count and subscript 0 are verified.var description: String { get }func hash(into:) ; var hashValue: Intstatic var isSigned: Bool { get }func distance(to other: Self) -> Int (Stride for ints)func advanced(by n: Self.Stride) -> Selfstatic func random(in range: Range<Self>) -> Self ; static func random(in: ClosedRange<Self>) -> Selfstatic func random<T>(in range: Range<Self>/ClosedRange<Self>, using generator: inout T) -> Self where T : RandomNumberGeneratorusing: &rng custom RNG calls consume rng.next() for Int half-open and closed ranges on WASM/native.extension FixedWidthInteger : Codableextension Int : CVarArgvar customMirror: Mirror { get }@frozen struct Int128 / UInt128 : FixedWidthInteger (full member surface)@frozen public struct Double@frozen public struct Float@frozen public struct Float16public init()public init(_ v: Int)public init<Source>(_ value: Source) where Source : BinaryIntegerpublic init?<Source>(exactly value: Source) where Source : BinaryInteger2^53 succeeds and 2^53+1 is nil.public init(_ other: Float)/(_ other: Double)/(_ other: Float16)public init?(exactly other: Float)/(_:Double).some; Float/Double NaN returns nil.public init(sign: FloatingPointSign, exponent: Int, significand: Double).minus, 2, 1.5 -> -6.0 verified).public init(signOf: Double, magnitudeOf: Double)-1.0, 2.5 -> -2.5; positive sign over negative magnitude verified).public init(bitPattern: UInt64)Float(bitPattern:).public var bitPattern: UInt64 { get }public init(nan payload: Double.RawSignificand, signaling: Bool)public init(floatLiteral value: Double)static func +/-/*//(lhs: Self, rhs: Self) -> Selfstatic func +=/-=/*=//=(lhs: inout Self, rhs: Self)prefix static func -(x: Self) -> Self; mutating func negate()static func ==/</<=/>/>=(lhs: Self, rhs: Self) -> Boolvar magnitude: Self { get }func squareRoot() -> Selfmutating func formSquareRoot()var x = 9.0; x.formSquareRoot() verified as 3.0.func addingProduct(_ lhs: Self, _ rhs: Self) -> Selfmutating func addProduct(_ lhs: Self, _ rhs: Self)func truncatingRemainder(dividingBy other: Self) -> Selfmutating func formTruncatingRemainder(dividingBy other: Self)5.0.formTruncatingRemainder(dividingBy: 1.5) verified as 0.5.func remainder(dividingBy other: Self) -> Selfremainder() natively; wasm lowers x - nearestEven(x/y) * y); 7.0.remainder(dividingBy: 2.0) == -1.0 verified against real Swift.mutating func formRemainder(dividingBy other: Self)var x = 7.0; x.formRemainder(dividingBy: 2.0) verified as -1.0 against real Swift.func rounded(_ rule: FloatingPointRoundingRule = .toNearestOrAwayFromZero) -> Selffunc rounded() -> Selfmutating func round(_ rule: FloatingPointRoundingRule)var nextUp: Self { get }nextafter.var nextDown: Self { get }var sign: FloatingPointSign { get }var exponent: Self.Exponent { get }8.0.exponent == 3 verified).var significand: Self { get }x / binade and are covered by precision metadata tests.var ulp: Self { get }ulpOfOne; positive finite smoke paths pass for Double/Float.var isFinite: Bool { get }var isNaN: Bool { get }var isInfinite: Bool { get }var isZero: Bool { get }var isNormal: Bool { get }var isSubnormal: Bool { get }var isSignalingNaN: Bool { get }var isCanonical: Bool { get }var floatingPointClass: FloatingPointClassification { get }func isEqual(to:)/isLess(than:)/isLessThanOrEqualTo(_:) -> Boolfunc isTotallyOrdered(belowOrEqualTo other: Self) -> Boolstatic func minimum/maximum/minimumMagnitude/maximumMagnitude(_ x: Self, _ y: Self) -> Selfstatic var radix: Int { get }static var pi: Self { get }static var nan: Self / signalingNaN: Self { get }static var infinity: Self { get }isInfinite verified.static var greatestFiniteMagnitude: Self { get }isFinite.static var leastNormalMagnitude/leastNonzeroMagnitude: Self { get }static var ulpOfOne: Self { get }func isMultiple(of other: Self) -> Bool6.5.isMultiple(of: 0.5) verified).static func random(in range: Range<Self>) -> Selfstatic func random<T>(in range: Range<Self>, using generator: inout T) -> Selfusing: &rng custom RNG calls consume rng.next() for Double half-open ranges on WASM/native.static func random(in range: ClosedRange<Self>) -> Selfstatic func random<T>(in range: ClosedRange<Self>, using generator: inout T) -> Selfusing: &rng custom RNG calls consume rng.next() for Double closed ranges on WASM/native.init<Source>(_ value: Source) where Source : BinaryFloatingPointinit?<Source>(exactly value: Source) where Source : BinaryFloatingPointDouble(exactly:) handles finite values, infinity, and NaN nil.init(sign:exponentBitPattern:significandBitPattern:)static var exponentBitCount/significandBitCount: Int { get }var exponentBitPattern: RawExponent / significandBitPattern: RawSignificand { get }var binade: Self { get }6.0.binade == 4.0 verified).var significandWidth: Int { get }func distance(to other: Double) -> Double; func advanced(by amount: Double) -> Doublevar description: String { get }public init?(_ text: String)Double?; valid decimal/exponent strings bind, while invalid and trailing-garbage strings produce nil on native/WASM.var hashValue: Int; func hash(into:)hashValue, hash(into:), and Hasher.combine(Double) share the same deterministic bit-pattern hash path for MiniSwift Float/Double values; verified native/WASM.func encode(to:); init(from:)public func abs<T>(_ x: T) -> T where T : Comparable, T : SignedNumericpublic func min/max<T>(_ x: T, _ y: T, ...) -> T where T : Comparablefunc pow(_ x: Double, _ y: Double) -> Doublefunc sin/cos/tan(_ x: Double) -> Doublefunc sqrt(_ x: Double) -> Doublefunc exp/log(_ x: Double) -> Doublefunc floor/ceil/trunc/round(_ x: Double) -> Double@frozen public enum FloatingPointSign : Int { case plus; case minus }.plus/.minus enum cases compare correctly, and finite Float/Double .sign values compare against them.public enum FloatingPointRoundingRule { case toNearestOrAwayFromZero; .toNearestOrEven; .up; .down; .towardZero; .awayFromZero }@frozen public enum FloatingPointClassification { .signalingNaN, .quietNaN, .negativeInfinity, ... }init()init(_ c: Character)init(_ substring: Substring)init(stringLiteral: String)init(stringInterpolation: DefaultStringInterpolation)init(_ scalar: Unicode.Scalar)init(repeating: String, count: Int)init(repeating: Character, count: Int)init<T>(_ value: T, radix: Int = 10, uppercase: Bool = false) where T: BinaryIntegerinit<T>(_ value: T) where T: LosslessStringConvertibleinit<Subject>(describing: Subject)init<S>(_ s: S) where S.Element == Character[Character] and String(s.reversed()) construction are verified; arbitrary custom Sequence<Character> materialization remains limited.init(_ unicodeScalars: String.UnicodeScalarView)String("hé".unicodeScalars)); deeper view/index identity remains simplified.init<C,Enc>(decoding: C, as: Enc.Type)String(decoding: [UInt8]/Data, as: Unicode.UTF8.self) smoke path by copying bytes through the Data runtime. Generic Sequence inputs, alternate encodings/codecs, validation, and deep Unicode semantics are still missing.init?<Enc>(validating: Sequence, as: Enc.Type)[UInt8]/Data + Unicode.UTF8.self inputs materialize as non-nil String? through the same byte-copy path as String(decoding:as:). Invalid UTF-8 detection, nil-producing validation, generic Sequence inputs, and alternate encodings are still missing.init(cString: UnsafePointer<CChar>)String(cString:) identity-converts pointer views produced by withCString; arbitrary external C memory, validation, ownership, and codec semantics remain shallow.init?(validatingCString: UnsafePointer<CChar>)withCString pointer views through the failable initializer and materializes a non-nil optional for valid runtime strings; invalid UTF-8 validation, nil/error paths, arbitrary external C memory, and codec fidelity remain shallow.init(unsafeUninitializedCapacity: Int, initializingUTF8With: (UnsafeMutableBufferPointer<UInt8>) throws -> Int) rethrowsUnsafeMutableBufferPointer<UInt8> smoke path, honors the returned initialized byte count by writing a NUL terminator, and supports simple ASCII/UTF-8 bytes. Throwing/rethrowing behavior, validation, reliable metadata-backed .count on the produced heap string, and full Unicode codec semantics are still missing.init(from: any Decoder) throws; func encode(to: any Encoder) throwsstatic func + (lhs: String, rhs: String) -> Stringstatic func += (lhs: inout String, rhs: String)var count: Int { get }var isEmpty: Bool { get }func hasPrefix(_ prefix: String) -> Boolfunc hasSuffix(_ suffix: String) -> Boolfunc contains(_ other: String) -> Boolmutating func append(_ other: String)mutating func append(_ c: Character)mutating func append<S>(contentsOf: S) where S.Element == Charactermutating func insert(_ newElement: Character, at i: String.Index)mutating func insert<S>(contentsOf: S, at i: String.Index)@discardableResult mutating func remove(at i: String.Index) -> Charactermutating func removeSubrange(_ bounds: Range<String.Index>)mutating func removeAll(keepingCapacity: Bool = false)mutating func removeFirst() -> Character; removeLast(); popLast() -> Character?mutating func replaceSubrange<C>(_ subrange: Range<String.Index>, with: C)mutating func reserveCapacity(_ n: Int)subscript(i: String.Index) -> Character { get }subscript(bounds: Range<Index>) -> Substring { get }var startIndex: String.Index; var endIndex: String.Indexfunc index(after: Index) -> Index; func index(before: Index) -> Indexfunc index(_ i: Index, offsetBy: Int) -> Indexfunc index(_ i: Index, offsetBy: Int, limitedBy: Index) -> Index?String.Index model returns a real Int? optional; forward/backward limits, zero-offset startIndex, stored optional, force unwrap, and nil edges are regression-tested.func distance(from: Index, to: Index) -> Intfunc firstIndex(of: Character) -> Index?; firstIndex(where:) -> Index?of: and closure predicates; uses MiniSwift's flat String.Index offset model.func lastIndex(of: Character) -> Index?func range(of: String) -> Range<Index>?Range<Index>? in MiniSwift's flat String.Index model; optional binding, force unwrap, empty needle, nil miss, lower/upper bounds, and s[range] slicing are regression-tested.func prefix(_ maxLength: Int) -> Substringfunc suffix(_ maxLength: Int) -> Substringfunc prefix(while: (Character) -> Bool) -> Substringfunc dropFirst(_ k: Int = 1) -> Substring; dropLast(_ k: Int = 1) -> Substringfunc split(separator: Character, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Substring]func split(separator: some StringProtocol, ...) -> [Substring]func components(separatedBy: String) -> [String][String] including empty components; native + WASM smoke paths are covered.func joined(separator: String) -> Stringjoined() and joined(separator:) lower to native/WASM string-array join helpers; verified on [String].func uppercased() -> Stringfunc lowercased() -> Stringvar capitalized: String { get }"miniSWIFT stdLIB" -> "Miniswift Stdlib").func trimmingCharacters(in: CharacterSet) -> Stringfunc replacingOccurrences(of: String, with: String) -> Stringfunc padding(toLength: Int, withPad: String, startingAt: Int) -> Stringfunc reversed() -> ReversedCollection<...> / [Character]String(s.reversed()); implemented as eager string materialization.static func == (lhs: String, rhs: String) -> Boolstatic func < (lhs: String, rhs: String) -> Bool__str_cmp; <, >, <=, >= smoke paths verified.func lexicographicallyPrecedes(_ other: ...) -> Boolfunc localizedCompare(_:) -> ComparisonResultstatic func ~= (lhs: String, rhs: Substring) -> Bool~= and string switch-case lower to string equality; String/Substring smoke paths are covered.func hash(into:); var hashValue: Int { get }var description: String; var debugDescription: Stringmutating func write(_ other: String); func write<T>(to: inout T)var unicodeScalars: String.UnicodeScalarViewvar utf8: String.UTF8View.count works and ASCII byte iteration is verified (for byte in "ABC".utf8); full byte-perfect non-ASCII UTF8View/index semantics remain partial.var utf16: String.UTF16Viewvar utf8CString: ContiguousArray<CChar> { get }func makeIterator() -> String.Iterator; mutating func next() -> Character?var it = s.makeIterator(); it.next() returns optional Character-as-String payloads and nil at end; for-in over Characters remains supported by the loop lowering.var isContiguousUTF8: Bool; mutating func makeContiguousUTF8(); withUTF8(_:)func withCString<R>(_ body: (UnsafePointer<Int8>) throws -> R) rethrows -> RUnsafePointer<Int8> view over MiniSwift's null-terminated string pointer and returns the closure result; verified for String(cString:) round-trip, but scoped lifetime, arbitrary return inference, throwing propagation, and CChar layout fidelity remain partial.func enumerated() -> EnumeratedSequencefunc elementsEqual(_ other:) -> Boolfunc max<T:Comparable>(_ x: T, _ y: T) -> Tfunc contains(_: some RegexComponent) -> Bool; firstMatch(of:); wholeMatch(of:); replacing(_:with:)init()prefix/suffix/dropFirst/count/uppercased/hasPrefix/split etc.init(_ s: Substring); __substr_to_stringshares String.Index with parentvar base: String { get }Equatable/Comparable/HashablehashValue, hash(into:), and Hasher.combine normalize Substring contents through __substr_to_string and share String hashing.init(_ content: Unicode.Scalar)init(_ s: String)init(extendedGraphemeClusterLiteral: Character)Equatable/Comparable/Hashablevar description: String; var debugDescription: Stringvar isASCII: Bool { get }var asciiValue: UInt8? { get }var isLetter: Bool { get }var isNumber: Bool { get }var isWhitespace: Bool { get }var isUppercase: Bool; var isLowercase: Boolvar isPunctuation: Bool; var isSymbol: Boolvar isHexDigit: Bool { get }var hexDigitValue: Int? { get }var wholeNumberValue: Int? { get }var isWholeNumber/isNewline/isCased/...: Boolfunc uppercased() -> String; func lowercased() -> Stringvar utf8: UTF8View; var utf16: UTF16View; var unicodeScalarsfunc write<T>(to: inout T) where T: TextOutputStreaminit?(_ v: UInt32)init(_ v: UInt8); init?(_ v: UInt16); init?(_ v: Int)init(unicodeScalarLiteral: Unicode.Scalar)init?(_ description: String)var value: UInt32 { get }var isASCII: Bool { get }var description: String; var debugDescription: Stringfunc escaped(asASCII: Bool) -> StringUnicode.Scalar(...) calls lower to escaped strings for ASCII controls and common non-ASCII/asASCII cases on native and WASM; variable scalars, generic paths, and full escaping coverage remain unmodeled.Equatable/Comparable/Hashablevar properties: Unicode.Scalar.Properties { get }isAlphabetic/isASCIIHexDigit/isDiacritic/isEmoji/numericValue/name/...: Bool/...numericValue, and name smoke paths are verified; full Unicode data semantics remain partial.var utf8: Unicode.Scalar.UTF8View; var utf16: Unicode.Scalar.UTF16View.count lowers for UTF-8/UTF-16 width smoke paths; true view objects, indexing, iteration, and dynamic scalar widths remain simplified.enum Unicode.UTF8: UnicodeCodec; encode/decode/width/...Unicode.UTF8/UTF16/UTF32.width(Unicode.Scalar(...)) lowers for literal scalar smoke paths. Codec instances, encode/decode parser state, error buffering, generic iterators, and full UnicodeCodec conformance remain missing.enum Unicode.ASCII: Unicode.EncodingUnicode.ASCII.isASCII(_:) lowers for literal code-unit/scalar smoke paths. Unicode.Encoding protocol modeling, ASCII encode/decode/transcode parser state, replacement character payloads, and generic encoding plumbing remain missing.enum UnicodeDecodingResult { case scalarValue/emptyInput/error }emptyInput/error case values and equality smoke paths lower on native and WASM; associated scalarValue, codec integration, Sendable/BitwiseCopyable fidelity remain unmodeled.protocol StringProtocol: BidirectionalCollection, Comparable, ... where Element == Character, Index == String.Indexfunc hasPrefix<P: StringProtocol>(_ prefix: P) -> Boolfunc lowercased() -> String; func uppercased() -> Stringstatic func == <RHS: StringProtocol>(lhs: Self, rhs: RHS) -> Bool==, !=, <, >, <=, and >=.var utf8: UTF8View { get }; var utf16; var unicodeScalarsinit(arrayLiteral elements: Element...)init()init<S>(_ s: S) where Element == S.Element, S: Sequenceinit(repeating repeatedValue: Element, count: Int)init<E>(unsafeUninitializedCapacity: Int, initializingWith: (inout UnsafeMutableBufferPointer<Element>, inout Int) throws(E) -> Void) throws(E)Array(unsafeUninitializedCapacity:) { buffer, initializedCount in ... } lowers through a temporary UnsafeMutableBufferPointer, honors initializedCount writeback, and materializes only the initialized prefix. Throwing behavior is ignored and the Array<Element>(...) generic spelling still has a separate parser/lowering caveat.init<E>(capacity: Int, initializingWith: (inout OutputSpan<Element>) throws(E) -> Void)Array(capacity:) { out in out.append(...) } lowers with an array-backed OutputSpan token and preserves appended elements. append(addingCapacity:), true OutputSpan value identity, initialized-count/lifetime rules, throwing behavior, and non-array span families remain partial.init(from decoder: any Decoder) throwsmutating func append(_ newElement: Element)mutating func append<S>(contentsOf: S) where Element == S.Element, S: Sequencemutating func insert(_ newElement: Element, at i: Int)mutating func insert<C>(contentsOf: C, at i: Int) where Element == C.Element, C: Collection@discardableResult mutating func remove(at index: Int) -> Elementmutating func removeFirst() -> Element; mutating func removeFirst(_ k: Int)mutating func removeLast() -> Element; mutating func removeLast(_ k: Int)mutating func popLast() -> Element?mutating func removeAll(keepingCapacity: Bool = false)mutating func removeAll(where: (Element) throws -> Bool) rethrowsmutating func removeSubrange(_ bounds: Range<Int>)mutating func replaceSubrange<C>(_ subrange: Range<Int>, with: C) where Element == C.Element, C: Collectionmutating func reserveCapacity(_ minimumCapacity: Int)mutating func swapAt(_ i: Int, _ j: Int)subscript(index: Int) -> Element { get set }subscript(bounds: Range<Int>) -> ArraySlice<Element> { get set }var count: Int { get }var isEmpty: Bool { get }var capacity: Int { get }var underestimatedCount: Int { get }var startIndex: Int; var endIndex: Int { get }var indices: Range<Int> { get }func index(after i: Int) -> Int; func index(before i: Int) -> Intfunc formIndex(after i: inout Int); func formIndex(before i: inout Int)func index(_ i: Int, offsetBy: Int) -> Int; ... limitedBy: Int) -> Int?func distance(from start: Int, to end: Int) -> Intvar first: Element? { get }; var last: Element? { get }func firstIndex(of: Element) -> Int?; func firstIndex(where: (Element) -> Bool) -> Int?func lastIndex(of: Element) -> Int?; func lastIndex(where: (Element) -> Bool) -> Int?func contains(_ element: Element) -> Bool; func contains(where:) -> Boolfunc randomElement() -> Element?; func randomElement<T: RandomNumberGenerator>(using: inout T) -> Element?next() state consumption verified.mutating func reverse()func reversed() -> [Element]mutating func sort(); mutating func sort(by: (Element, Element) -> Bool)func sorted() -> [Element]; func sorted(by:) -> [Element]mutating func shuffle(); mutating func shuffle<T: RandomNumberGenerator>(using:)using: generator overloads.func shuffled() -> [Element]; func shuffled<T>(using:) -> [Element]using: generator overloads.static func + (lhs: [Element], rhs: [Element]) -> [Element]static func += (lhs: inout [Element], rhs: [Element])static func == (lhs: [Element], rhs: [Element]) -> Bool where Element: Equatablefunc hash(into: inout Hasher); var hashValue: Int where Element: Hashablevar description: String; var debugDescription: String { get }var customMirror: Mirror { get }func encode(to encoder: any Encoder) throws where Element: Encodablefunc withContiguousStorageIfAvailable<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R?.some(result) for Array-backed storage; buffer is an Array-compatible view, not a true UnsafeBufferPointer/lifetime/ABI model.mutating func withContiguousMutableStorageIfAvailable<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R?.some(result) with an Array-compatible mutable buffer view; closure subscript writes update the array, but real UnsafeMutableBufferPointer lifetime/ABI semantics are not modeled.func withUnsafeBufferPointer<R,E>(_ body: (UnsafeBufferPointer<Element>) throws(E) -> R) throws(E) -> Rfunc withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> RArray<Int> word-slot subscript read/write with count == array.count * 8. True byte layout, element-size generality, lifetime/throwing semantics, and non-Int arrays remain shallow.var span: Span<Element> { get }; var mutableSpan: MutableSpan<Element> { mutating get }span/mutableSpan expose count/subscript reads through the existing Array token. No real Span/MutableSpan ownership, ABI, lifetime, writeback, or OutputSpan model.e.g. func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]func makeIterator() -> IndexingIterator<[Element]>makeIterator().next() returns optional element payloads/nil at end.init(); init<S: Sequence>(_:); init(repeating:count:); init(arrayLiteral:)var startIndex: Int; var endIndex: Int { get }subscript(Int)->Element; var count/first/last/isEmpty/indicesfunc firstIndex(of:) -> Int?; func contains(_:) -> BoolRangeReplaceableCollection/MutableCollection requirementsSequence/Collection algorithm surfaceoperators, Equatable, Hashable, CustomStringConvertible, var capacitybuffer-pointer and span accessorswithUnsafeBufferPointer and contiguous mutable storage closure support through flat ArraySlice desugaring; raw bytes/span and true pointer lifetime/ABI semantics remain unsupported.Encodable/Decodable conformanceinit(); init<S: Sequence>(_:); init(repeating:count:); init(arrayLiteral:)Array(ContiguousArray), and ContiguousArray(ArraySlice) conversions are verified native + WASM.RangeReplaceableCollection/MutableCollection requirementssubscript(Int)->Element; query/index propertiesfunc contains(_ element: Element) -> Bool where Element: EquatableSequence/Collection algorithm surfaceoperators, Equatable, Hashable, CustomStringConvertible, CustomReflectablebuffer-pointer and span accessorswithUnsafeBufferPointer and contiguous mutable storage closure support through ContiguousArray-to-Array desugaring; raw bytes/span and true pointer lifetime/ABI semantics remain unsupported.Encodable/Decodable conformanceinit()init(minimumCapacity: Int)init(dictionaryLiteral elements: (Key, Value)...)Dictionary(dictionaryLiteral:) initializer infer [Key: Value] and lower through the ExpressibleByDictionaryLiteral/runtime dict-set path.init<S>(uniqueKeysWithValues: S) where S.Element == (Key, Value)zip(keys, values) and tuple-array pair sequences; infers [Key: Value], stores non-Int values correctly, and duplicate keys trap like Swift.init<S>(_ keysAndValues: S, uniquingKeysWith combine: (Value, Value) throws -> Value) rethrowszip(keys, values) path; duplicate keys call the combine closure and inferred [Key: Value] type feeds subscripts.init<S>(grouping values: S, by keyForValue: (S.Element) throws -> Key) rethrows where Value == [S.Element][String: [Element]]; key closure receives the element with its closure environment, sub-arrays are created via __dict_get_or_init_arr, and grouped counts/order are verified native against Swift.init(from decoder: any Decoder) throwsJSONDecoder().decode([String:Int].self, from:) decodes a JSON object smoke path; full Decoder/container semantics, non-string keys, and broad value types remain unmodeled.subscript(key: Key) -> Value? { get set }if let optional binding checks __dict_get presence before loading the payload.subscript(key: Key, default: @autoclosure () -> Value) -> Value { get set }counts[k, default: 0] += 1 inserts missing keys and updates existing keys.subscript(position: Index) -> Element { get }(key,value) through MiniSwift's Int-backed Dictionary.Index surrogate; positional tuple read is regression-tested.@discardableResult mutating func updateValue(_ value: Value, forKey key: Key) -> Value?@discardableResult mutating func removeValue(forKey key: Key) -> Value?@discardableResult mutating func remove(at index: Index) -> Element(key,value) tuple; removal and returned key/value are regression-tested.mutating func removeAll(keepingCapacity: Bool = false)mutating func popFirst() -> Element?var keys: Dictionary<Key, Value>.Keys { get }var values: Dictionary<Key, Value>.Valuesstruct Keys : Collection, Equatable==; regression-tested.struct Values : MutableCollectionstruct Index : Comparable, HashableDictionary<Key,Value>.Index annotations, comparisons, and hashValue work through MiniSwift's Int-backed surrogate; regression-tested.struct Iterator : IteratorProtocolfunc makeIterator() -> Iteratorfunc index(forKey key: Key) -> Index?Dictionary.Index, hashValue, and positional subscript tests.func index(after i: Index) -> Indexfunc formIndex(after i: inout Index)index(after:).var startIndex: Index / var endIndex: Index { get }0 and count); empty/nonempty bounds are regression-tested.var count: Int { get }var isEmpty: Bool { get }var capacity: Int { get }mutating func reserveCapacity(_ minimumCapacity: Int)var first: Element? { get }func randomElement() -> Element?func mapValues<T>(_ transform: (Value) throws -> T) rethrows -> [Key : T]func compactMapValues<T>(_ transform: (Value) throws -> T?) rethrows -> [Key : T][String:Int?] → [String:Int]).func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Key : Value]$0.value predicates and returns a new dictionary with matching entries; verified.mutating func merge<S>(_ other: S, uniquingKeysWith combine: (Value, Value) throws -> Value) rethrowszip(keys, values) pair sources call the combine closure on conflicts; arbitrary custom Sequence witness dispatch remains shallow.mutating func merge(_ other: [Key : Value], uniquingKeysWith combine: (Value, Value) throws -> Value) rethrowsm.merge([...]) { _, new in new } updates and inserts; native lowering also calls nontrivial combine closures on conflicts.func merging(_ other:..., uniquingKeysWith combine: (Value, Value) throws -> Value) rethrows -> [Key : Value]func reduce<R>(_ initialResult: R, _ next: (R, Element) -> R) -> Rfunc contains(where predicate: (Element) throws -> Bool) rethrows -> Boolstatic func == (lhs: [Key : Value], rhs: [Key : Value]) -> Boolfunc hash(into:) ; var hashValue: InthashValue returns a deterministic count-based MiniSwift placeholder; custom Hashable struct keys now work for literal, subscript lookup, and subscript assignment via synthesized-hash key canonicalization. hash(into:), key/value mixing, and Swift-compatible seeding remain shallow.var description: String { get } ; var debugDescription: Stringvar customMirror: Mirror { get }displayStyle reports dictionary; children/labels remain shallow.func encode(to encoder: any Encoder) throwsJSONEncoder().encode([String:Int]) emits a JSON object Data payload; full Encoder/container semantics, non-string keys, and broad value types remain unmodeled.init(arrayLiteral elements: Element...)init()init(minimumCapacity: Int)init<S>(_ sequence: S) where Element == S.Element, S: Sequenceinit(from decoder: any Decoder) throwsJSONDecoder().decode(Set<Int>.self, from:) top-level JSON array smoke support; existential Decoder/container semantics and broader element coverage remain partial.mutating func insert(_ newMember: Element) -> (inserted: Bool, memberAfterInsert: Element)(inserted, memberAfterInsert) tuple payload verified native + WASM for concrete Set<Int>.mutating func update(with newMember: Element) -> Element?mutating func remove(_ member: Element) -> Element?mutating func remove(at position: Set<Element>.Index) -> Elementmutating func removeAll(keepingCapacity: Bool = false)mutating func removeFirst() -> Elementmutating func popFirst() -> Element?func contains(_ member: Element) -> BoolHashable struct keys through synthesized-hash canonicalization.var count: Int { get }var isEmpty: Bool { get }var first: Element? { get }func randomElement() -> Element?var capacity: Int { get }mutating func reserveCapacity(_ minimumCapacity: Int)func union<S>(_ other: S) -> Set<Element> where S: Sequencemutating func formUnion<S>(_ other: S) where S: Sequencefunc intersection<S>(_ other: S) -> Set<Element> where S: Sequencemutating func formIntersection<S>(_ other: S) where S: Sequencefunc subtracting<S>(_ other: S) -> Set<Element> where S: Sequencemutating func subtract<S>(_ other: S) where S: Sequencefunc symmetricDifference<S>(_ other: S) -> Set<Element> where S: Sequencemutating func formSymmetricDifference<S>(_ other: S) where S: Sequencefunc isSubset<S>(of: S) -> Bool where S: Sequence / func isSubset(of: Set) -> Boolfunc isStrictSubset<S>(of: S) -> Bool / func isStrictSubset(of: Set) -> Boolfunc isSuperset<S>(of: S) -> Bool / func isSuperset(of: Set) -> Boolfunc isStrictSuperset<S>(of: S) -> Bool / func isStrictSuperset(of: Set) -> Boolfunc isDisjoint<S>(with: S) -> Bool / func isDisjoint(with: Set) -> Boolstatic func == (lhs: Set, rhs: Set) -> Boolstatic func < / <= / > / >= (Set, Set) -> Bool (strict/subset)</>; equal-size negative cases covered in setalg suitefunc hash(into:) ; var hashValue: IntHashable struct contains/duplicate-insert smoke now passes via MiniSwift deterministic key canonicalization, but full stdlib hashing details remain incomplete.func sorted() -> [Element]func min() -> Element? ; func max() -> Element?func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> Set<Element>Set<Int>.filter is verified native + WASM.func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]func reduce<R>(_ initial: R, _ next: (R, Element) -> R) -> Rfunc makeIterator() -> Set<Element>.Iteratorvar startIndex/endIndex: Index; subscript(Index) -> Element; func index(after:); func firstIndex(of:) -> Index?__set_get_ptr; start/end, index(after:), subscript, and firstIndex(of:) verified native + WASM.var description: String ; var debugDescription: StringSet([...]) (Set order remains unspecified).var customMirror: Mirror { get }func encode(to encoder: any Encoder) throwsJSONEncoder().encode(Set<Int>) emits a sorted JSON array Data payload; existential Encoder/container semantics and broader element coverage remain partial.protocol SetAlgebra<Element> : Equatable, ExpressibleByArrayLiteralinit()func contains(_ member: Element) -> Boolfunc union/intersection/symmetricDifference(_ other: Self) -> Selfmutating func insert(_:) -> (Bool,Element); update(with:) -> Element?; remove(_:) -> Element?mutating func formUnion/formIntersection/formSymmetricDifference/subtract(_ other: Self)func subtracting(_:) -> Self; isSubset/isSuperset/isDisjoint(of/with:) -> Bool; var isEmptyinit<S>(_ sequence: S) where S: Sequence, Element == S.Elementprotocol OptionSet : RawRepresentable, SetAlgebrainit(rawValue: Self.RawValue)static let x = T(rawValue: 1 << n)let s: T = [.a, .b] (ExpressibleByArrayLiteral)[.a, .b].rawValue == 3).func contains(_ member: Self) -> Bool (Element==Self)mutating func insert(_:) -> (inserted: Bool, memberAfterInsert: Element)(inserted, memberAfterInsert) tuple payload verified native + WASM.mutating func remove(_ member: Element) -> Element?mutating func update(with newMember: Element) -> Element?func union(_ other: Self) -> Selffunc intersection(_ other: Self) -> Selffunc symmetricDifference(_ other: Self) -> Selfinit() // rawValue == 0mutating func formUnion/formIntersection/formSymmetricDifference(_ other: Self) (FixedWidthInteger)var isEmpty: Bool { get }@frozen enum Optional<Wrapped> : ~Copyable, ~Escapablecase nonecase some(Wrapped)let x? both work.init(nilLiteral: ())let x: T? = nil lowers to .none tag.init(_ value: consuming Wrapped)if let x = opt { } / guard let x = opt else { }opt?.member / opt?.method()some(0) and verify struct fields plus String/Array ?.count; String/Array ?.contains(...) ?? default method-chain smoke works. Mutation through chains, arbitrary methods, and key-path optional chaining remain partial.opt!func ?? <T>(optional: consuming T?, defaultValue: @autoclosure () throws -> T) rethrows -> Topt ?? default returns wrapped or default. autoclosure lazy eval honored.func ?? <T>(optional: consuming T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T?T? ?? T? chaining works.func map<E,U>(_ transform: (Wrapped) throws(E) -> U) throws(E) -> U? where U : ~Copyablefunc flatMap<E,U>(_ transform: (Wrapped) throws(E) -> U?) throws(E) -> U? where U : ~Copyablevar unsafelyUnwrapped: Wrapped { get }mutating func take() -> Wrapped?take() returns the current optional and nils the source in native/WASM.static func == (lhs: Wrapped?, rhs: Wrapped?) -> Bool where Wrapped : Equatablestatic func == (lhs: borrowing Wrapped?, rhs/lhs: _OptionalNilComparisonType) -> Boolopt == nil, nil == opt); works for non-Equatable Wrapped.static func != (lhs: borrowing Wrapped?, rhs/lhs: _OptionalNilComparisonType) -> Boolif opt != nil.static func ~= (lhs: _OptionalNilComparisonType, rhs: borrowing Wrapped?) -> Boolswitch opt { case nil: } verified; case let x?: binding verified. Pattern matching works for non-Equatable Wrapped.func hash(into:) where Wrapped : Hashable; var hashValue: Intvar debugDescription: String { get } (CustomDebugStringConvertible)Optional(value) or Optional("value")/nil in wasm/native. Custom Wrapped and broader reflection-backed debug output remain shallow.String(describing: opt) / "\(opt)"String(describing:) and string interpolation now format scalar/String Optional payloads as Optional(value)/Optional("value")/nil; custom/pointer Wrapped output remains partial.opt as Any (e.g. print(opt as Any))let boxed: Any = opt as Any storage work by string-boxing Optional(value)/nil; full existential container semantics and non-primitive payloads remain partial.var customMirror: Mirror { get } (CustomReflectable)func encode(to: any Encoder) throws where Wrapped : EncodableJSONEncoder().encode(Int?/String?) top-level smoke support for some/nil; existential Encoder/container semantics and broad Wrapped coverage remain partial.init(from: any Decoder) throws where Wrapped : DecodableJSONDecoder().decode(Optional<Int/String>.self, from:) supports numeric/string/null top-level JSON; full Decoder/container semantics and escaped-string parity remain partial.conditional conformances where Wrapped : <protocol>@frozen struct Range<Bound> where Bound : Comparableinit(uncheckedBounds: (lower: Bound, upper: Bound))init(_ other: ClosedRange<Bound>) where Bound: Strideable, Stride: SignedIntegerlet lowerBound: Boundlet upperBound: Boundfunc contains(_ element: Bound) -> Boolvar isEmpty: Bool { get }var count: Int { get } (RandomAccessCollection)func overlaps(_ other: Range/ClosedRange<Bound>) -> Boolfunc contains(_ other: Range/ClosedRange<Bound>) -> Boolfunc clamped(to limits: Range<Bound>) -> Range<Bound>func relative<C>(to: C) -> Range<Bound> (RangeExpression)extension Range: Sequence, Collection, BidirectionalCollection, RandomAccessCollection where Bound: Strideable, Stride: SignedIntegervar startIndex/endIndex: Bound { get }func index(after i: Bound) -> Boundfunc index(before i: Bound) -> Boundfunc index(_ i: Bound, offsetBy n: Int) -> Boundfunc distance(from: Bound, to: Bound) -> Intvar indices: Range<Bound>.Indices { get } (== self)subscript(position: Bound) -> Bound { get }subscript(bounds: Range<Bound>) -> Range<Bound> { get }static func ==; var hashValue; func hash(into:)Range equality true/false paths, hashValue, hash(into:), and Hasher.combine(range) are verified by numbers_and_basic_values/range/test_range_88_hash_into_equality.swift.var description/debugDescription: String { get }init(from:) throws / encode(to:) throws where Bound: CodableRange<Int> as Swift-compatible [lower,upper]; full Decoder/Encoder container semantics and generic Bound coverage remain unmodeled.var customMirror: Mirror { get }@frozen struct ClosedRange<Bound> where Bound : Comparableinit(uncheckedBounds: (lower: Bound, upper: Bound))init(_ other: Range<Bound>) where Bound: Strideable, Stride: SignedIntegerlet lowerBound/upperBound: Boundfunc contains(_ element: Bound) -> Boolvar isEmpty: Bool { get } (always false)var count: Int { get } (RandomAccessCollection)func overlaps(_ other: ClosedRange/Range<Bound>) -> Boolfunc contains(_ other: Range/ClosedRange<Bound>) -> Boolfunc clamped(to limits: ClosedRange<Bound>) -> ClosedRange<Bound>func relative<C>(to: C) -> Range<Bound>extension ClosedRange: Sequence, Collection, BidirectionalCollection, RandomAccessCollection where Bound: Strideable, Stride: SignedIntegerenum Index { case pastEnd; case inRange(Bound) }lowerBound...upperBound+1) rather than materializing Apple's enum payload; verified through start/end/index/distance/subscript.var startIndex/endIndex: ClosedRange.Index { get }startIndex == lowerBound, endIndex == upperBound + 1 for integer ClosedRange; verified native/WASM.func index(after/before:)/(_:offsetBy:) -> Indexfunc distance(from: Index, to: Index) -> Intto - from over the Int-backed ClosedRange index model; verified native/WASM.subscript(position: Index) -> Bound { get }static func ==; hash(into:); hashValueClosedRange equality true/false paths and hash lowering share the range metadata hash path; covered by range/closedrange regression suites.var description/debugDescription: Stringinit(from:) throws / encode(to:) throws where Bound: CodableClosedRange<Int> as Swift-compatible [lower,upper]; full Decoder/Encoder container semantics and generic Bound coverage remain unmodeled.@frozen struct PartialRangeFrom<Bound> where Bound : Comparableinit(_ lowerBound: Bound)let lowerBound: Boundfunc contains(_ element: Bound) -> Bool3... contains 5 and rejects 2.func relative<C>(to: C) -> Range<Bound>extension PartialRangeFrom: Sequence; struct Iterator: IteratorProtocol; next()->Bound?makeIterator(), next(), while let, and optional-print paths are verified by test_range_77_partial_from_iterator.swift.init(from:) throws / encode(to:) throwsPartialRangeFrom<Int> as Swift-compatible [lower]; full Decoder/Encoder container semantics and generic Bound coverage remain unmodeled.@frozen struct PartialRangeUpTo<Bound> where Bound : Comparableinit(_ upperBound: Bound)let upperBound: Boundfunc contains(_ element: Bound) -> Bool..<5 contains 4 and rejects 5.func relative<C>(to: C) -> Range<Bound>init(from:) throws / encode(to:) throwsPartialRangeUpTo<Int> as Swift-compatible [upper]; full Decoder/Encoder container semantics and generic Bound coverage remain unmodeled.@frozen struct PartialRangeThrough<Bound> where Bound : Comparableinit(_ upperBound: Bound)let upperBound: Boundfunc contains(_ element: Bound) -> Bool...5 contains 5 and rejects 6.func relative<C>(to: C) -> Range<Bound>init(from:) throws / encode(to:) throwsPartialRangeThrough<Int> as Swift-compatible [upper]; full Decoder/Encoder container semantics and generic Bound coverage remain unmodeled.postfix static func ... (_: UnboundedRange_) ; typealias UnboundedRange... slices and (...).relative(to:) / named unbounded relative(to:) lower to startIndex..<endIndex; contains/hash smoke paths are verified.static func ... (minimum: Self, maximum: Self) -> ClosedRange<Self> (Comparable)static func ..< (minimum: Self, maximum: Self) -> Range<Self> (Comparable)prefix static func ..< (maximum: Self) -> PartialRangeUpTo<Self>prefix static func ... (maximum: Self) -> PartialRangeThrough<Self>postfix static func ... (minimum: Self) -> PartialRangeFrom<Self>static func ~= (pattern: Self, value: Bound) -> Boolprotocol RangeExpression<Bound>; func relative(to:); func contains(_:)protocol Strideable<Stride>: Comparable; associatedtype Stride: Comparable & SignedNumericfunc distance(to other: Self) -> Self.Stridefunc advanced(by n: Self.Stride) -> Selfstatic func < / == (x: Self, y: Self) -> Boolstatic func +,-,+=,-= where Self: _PointerUnsafePointer/UnsafeMutablePointer +/- and mutable +=/-= lower through the existing pointer GEP path; unannotated inference and raw/buffer pointer families remain shallow.func stride<T>(from: T, to: T, by: T.Stride) -> StrideTo<T> where T: StrideableStrideTo<Int> values carry range/step metadata for for-in, underestimatedCount, typed iterator annotations, and manual next() optional payload/nil paths.func stride<T>(from: T, through: T, by: T.Stride) -> StrideThrough<T> where T: StrideableStrideThrough<Int> values carry range/step metadata for for-in, underestimatedCount, typed iterator annotations, and manual next() optional payload/nil paths.@frozen struct StrideTo<Element: Strideable>: SequenceStrideTo<Int> values carry range/step metadata for printing, for-in, typed annotations, underestimatedCount, and iterator smoke paths.func makeIterator() -> StrideToIterator; var underestimatedCount: IntmakeIterator() materializes a metadata-backed cursor for stored integer strides and underestimatedCount matches positive/negative exclusive integer strides; typed StrideToIterator<Int> is verified.mutating func next() -> Element?StrideTo iterators return optional Int payloads and nil at end for positive/negative step smoke paths.@frozen struct StrideThrough<Element: Strideable>: SequenceStrideThrough<Int> values carry range/step metadata for for-in, typed annotations, underestimatedCount, and iterator smoke paths.func makeIterator() -> StrideThroughIterator; var underestimatedCount: IntmakeIterator() materializes a metadata-backed cursor for stored inclusive integer strides and underestimatedCount matches positive/negative inclusive integer strides; typed StrideThroughIterator<Int> is verified.mutating func next() -> Element?StrideThrough iterators return optional Int payloads and nil at end for inclusive positive/negative step smoke paths.typealias Countable* = Range/ClosedRange/PartialRangeFrom<Bound> where Bound: Strideable, Stride: SignedIntegerCollection.subscript(bounds: Range<Index>) -> SubSequencefor i in a..<b / a...b { }mutating func next() -> Element?for-in, manual while let x = it.next() custom iterators, and Array/String/Dictionary iterator smoke tests (collections/iterator 6/6).associatedtype Elementfunc makeIterator() -> Iteratorassociatedtype Element; associatedtype Iterator: IteratorProtocolvar underestimatedCount: Int { get }func withContiguousStorageIfAvailable<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R?.some(result); buffer is modeled as an Array-compatible view, not a real UnsafeBufferPointer/lifetime/ABI model.func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]func compactMap<R>(_ transform: (Element) throws -> R?) rethrows -> [R]func flatMap<S: Sequence>(_ transform: (Element) throws -> S) rethrows -> [S.Element]__array_concat and fresh array closures are verified; no real generic Sequence/lazy FlattenSequence value model yet.func flatMap<R>(_ transform: (Element) throws -> R?) rethrows -> [R]Optional.flatMap and deprecated Array optional-returning flatMap both lower through scalar optional sentinel paths and are verified (optional suite 38/38; collections/sequence/test_seq_65).func reduce<R>(_ initial: R, _ next: (R, Element) throws -> R) rethrows -> Rfunc reduce<R>(into initial: R, _ update: (inout R, Element) throws -> ()) rethrows -> Rreduce(into:0){$0+=$1}), heap-backed collection append accumulators ([Int] append), and value-type struct field writeback with explicit and shorthand inout closures.func forEach(_ body: (Element) throws -> Void) rethrowsfunc allSatisfy(_ predicate: (Element) throws -> Bool) rethrows -> Boolfunc contains(_ element: Element) -> Bool where Element: Equatablefunc contains(where: (Element) throws -> Bool) rethrows -> Boolfunc first(where: (Element) throws -> Bool) rethrows -> Element?func min() -> Element? / func max() -> Element? where Element: Comparablefunc min(by: (Element, Element) throws -> Bool) rethrows -> Element?min(by:<), min(by:>), and max(by:>) are verified in WASM.func sorted() -> [Element] where Element: Comparablefunc sorted(by: (Element, Element) throws -> Bool) rethrows -> [Element]func enumerated() -> EnumeratedSequence<Self>enumerated() materializes (offset, element) tuple records for stored values, direct for-in, for pair in stored, and enumerated().map { ... } smoke paths. Generic Sequence witnesses plus Set/String tuple-offset parity remain partial.func reversed() -> [Element]func reversed() -> ReversedCollection<Self>func shuffled() -> [Element]func joined() -> FlattenSequence<Self>func joined<S: Sequence>(separator: S) -> JoinedSequence<Self>joined(separator:) now works native + WASM; generic JoinedSequence/non-string sequence joining is still not a real value type.func joined(separator: String = "") -> StringArray<String>.joined(separator:) works native + WASM via __str_join_array_sep; empty and non-empty separators verified.func split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [SubSequence]maxSplits and omittingEmptySubsequences in native + WASM.func split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [SubSequence]maxSplits / omittingEmptySubsequences; native + WASM verified. String predicate path remains supported.func prefix(_ maxLength: Int) -> [Element] / SubSequencefunc prefix(while: (Element) throws -> Bool) rethrows -> [Element]func suffix(_ maxLength: Int) -> [Element] / SubSequenceSequence/lazy wrapper semantics remain simplified.func dropFirst(_ k: Int = 1) -> DropFirstSequence<Self> / SubSequenceDropFirstSequence is not materialized as a real wrapper type.func dropLast(_ k: Int = 1) -> [Element] / SubSequencefunc drop(while: (Element) throws -> Bool) rethrows -> DropWhileSequence<Self> / SubSequencefunc elementsEqual<S: Sequence>(_ other: S) -> Boolfunc starts<P: Sequence>(with possiblePrefix: P) -> Boolfunc lexicographicallyPrecedes<S: Sequence>(_ other: S) -> Bool where Element: Comparablevar lazy: LazySequence<Self> { get }var startIndex: Index { get }; var endIndex: Index { get }subscript(position: Index) -> Element { get }subscript(bounds: Range<Index>) -> SubSequence { get }var count: Int { get }var isEmpty: Bool { get }var first: Element? { get }var last: Element? { get }var indices: Indices { get }func index(after i: Index) -> Indexfunc index(before i: Index) -> Indexfunc index(_ i: Index, offsetBy d: Int, limitedBy: Index) -> Index?func distance(from start: Index, to end: Index) -> Intfunc randomElement() -> Element?func firstIndex(of: Element) -> Index? where Element: Equatablefunc lastIndex(of: Element) -> Index?func last(where: (Element) throws -> Bool) rethrows -> Element?func prefix(upTo end: Index) -> SubSequencesubscript(position: Index) -> Element { get set }mutating func swapAt(_ i: Index, _ j: Index)mutating func partition(by: (Element) throws -> Bool) rethrows -> Indexmutating func sort() / mutating func sort(by:)mutating func reverse()mutating func shuffle()init()init(repeating: Element, count: Int)mutating func replaceSubrange<C: Collection>(_ subrange: Range<Index>, with: C)mutating func reserveCapacity(_ n: Int)mutating func append(_ newElement: Element)mutating func append<S: Sequence>(contentsOf: S)mutating func insert(_ newElement: Element, at i: Index)mutating func remove(at i: Index) -> Elementmutating func removeFirst() -> Elementmutating func removeAll(where: (Element) throws -> Bool) rethrowsfunc zip<S1: Sequence, S2: Sequence>(_ s1: S1, _ s2: S2) -> Zip2Sequence<S1, S2>struct Zip2Sequence<S1, S2>: Sequencezip(...) materializes an array-backed tuple sequence; for-in, value storage, .underestimatedCount, .makeIterator(), and manual Iterator.next() optional tuple payload/nil paths are verified.struct EnumeratedSequence<Base>: Sequenceenumerated() materializes a tuple sequence; stored values, .underestimatedCount, .makeIterator(), manual Iterator.next() optional tuple/nil paths, and .map { $0.offset ... } are verified.func stride<T: Strideable>(from: T, to: T, by: T.Stride) -> StrideTo<T>StrideTo<Int> values support for-in, underestimatedCount, typed iterator annotations, and manual next() optional payload/nil paths.func stride<T: Strideable>(from: T, through: T, by: T.Stride) -> StrideThrough<T>StrideThrough<Int> values support underestimatedCount, typed iterator annotations, and manual next() optional payload/nil paths.struct StrideTo<Element: Strideable>: SequenceunderestimatedCount, makeIterator(), typed iterator annotations, and next() optional payload/nil smoke paths are verified.struct Repeated<Element>: RandomAccessCollectionRepeated<Int> = repeatElement(...) materializes an eager array-backed collection with count/subscript/start/end/isEmpty, for-in, makeIterator().next() optional payload/nil paths, and Array(repeatElement(...)) smoke coverage.struct CollectionOfOne<Element>; struct EmptyCollection<Element>struct IndexingIterator<Elements: Collection>: IteratorProtocolIndexingIterator<[Int]> = array.makeIterator() materializes a cursor and returns optional payloads plus nil at end; String/Dictionary iterator smoke paths are also verified.struct DefaultIndices<Elements: Collection>: Collectionstruct Slice<Base: Collection>: Collectionstruct FlattenSequence<Base>; struct JoinedSequence<Base>struct DropFirstSequence<Base>: Sequence (etc.)struct LazyMapSequence<Base, Element>: LazySequenceProtocol (etc.)struct ReversedCollection<Base: BidirectionalCollection>struct AnySequence<Element>: Sequence; struct AnyIterator<Element>struct AnyCollection<Element>: Collection (etc.)struct AnyIndex: Comparablefunc min<T: Comparable>(_ x: T, _ y: T) -> Tfunc max<T: Comparable>(_ x: T, _ y: T) -> T@frozen enum Result<Success, Failure> where Failure : Error, Success : ~Copyable, Success : ~Escapableget, map/flatMap/mapError/flatMapError, equality, hashValue, and error-default smoke paths are verified on the {tag,payload} layout. Ownership/marker caveats are tracked separately on the conditional conformance row.case success(Success)case failure(Failure)init(catching body: () throws(Failure) -> Success)Result(catching: { try f() }) lowers through the Result tag/payload layout and is regression-tested.consuming func get() throws(Failure) -> Successdo/catch, try? nil on failure, and try! on success in native/WASM.func map<NewSuccess>(_ transform: (Success) -> NewSuccess) -> Result<NewSuccess, Failure>consuming func mapError<NewFailure>(_ transform: (Failure) -> NewFailure) -> Result<Success, NewFailure>func flatMap<NewSuccess>(_ transform: (Success) -> Result<NewSuccess, Failure>) -> Result<NewSuccess, Failure>consuming func flatMapError<NewFailure>(_ transform: (Failure) -> Result<Success, NewFailure>) -> Result<Success, NewFailure>static func == (a: Result, b: Result) -> Bool where Success : Equatable, Failure : Equatable!=; regression-tested.func hash(into:) ; var hashValue: InthashValue, hash(into:), and Hasher.combine(Result) lower from Result tag/payload for simple success/failure payloads; verified native/WASM.conditional conformances~Copyable suppression is accepted in smoke tests; true ownership/conditional marker semantics remain shallow.protocol Error : Sendablevar localizedDescription: String { get }error.localizedDescription returns the MiniSwift default message; Foundation/NSError bridging and custom localized errors are not modeled.protocol LocalizedError : Error { var errorDescription/failureReason/recoverySuggestion/helpText }protocol CustomNSError : Error { static var errorDomain; var errorCode; var errorUserInfo }errorDomain/errorCode/empty errorUserInfo lower for enum conformers; NSError bridging/custom overrides remain unmodeled.protocol RecoverableError : Error { var recoveryOptions; func attemptRecovery(...) }recoveryOptions and synchronous attemptRecovery(optionIndex:) on native/WASM. Protocol witness dispatch, NSError bridging, and default async handler forwarding remain unmodeled.throw expr; try expr; do { } catch { }try? expr → Optionaltry! exprfunc f() throws ; func f() throws(E)func f(_ body: () throws -> T) rethrows -> Tfunc fatalError(_ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) -> Neverfunc precondition(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = "", file:line:)func preconditionFailure(_ message: @autoclosure () -> String = "", file:line:) -> Neverfunc assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = "", file:line:)@inlinable func assertionFailure(_ message: @autoclosure () -> String = "", file:line:)protocol Equatable { static func == (lhs: Self, rhs: Self) -> Bool }static func == (lhs: Self, rhs: Self) -> Boolstatic func != (lhs: Self, rhs: Self) -> Boolprotocol Hashable : Equatable { var hashValue: Int { get }; func hash(into:) }func hash(into hasher: inout Hasher)hash(into:) overrides and full generic witness dispatch remain shallow.var hashValue: Int { get }@frozen struct Hasherinit()mutating func combine<H>(_ value: H) where H : Hashablemutating func combine(bytes: UnsafeRawBufferPointer)func finalize() -> Intprotocol Comparable : Equatable { static func < / <= / > / >= }static func < (lhs: Self, rhs: Self) -> Boolstatic func <= / > / >= (lhs: Self, rhs: Self) -> Boolprotocol CaseIterable { static var allCases: AllCases { get } }static var allCases: Self.AllCases { get }lang_features/test_caseiterable_01_allcases).protocol RawRepresentable<RawValue> { init?(rawValue:); var rawValue }init?(rawValue: Self.RawValue)var rawValue: Self.RawValue { get }protocol Identifiable<ID> { associatedtype ID: Hashable; var id: ID { get } }var id: Self.ID { get }extension Identifiable where Self: AnyObject { var id: ObjectIdentifier }id now lower .id to an ObjectIdentifier pointer token; generic witness routing and full Swift ABI identity semantics remain shallow.protocol CustomStringConvertible { var description: String { get } }var description: String { get }protocol CustomDebugStringConvertible { var debugDescription: String { get } }var debugDescription: String { get }protocol LosslessStringConvertible : CustomStringConvertible { init?(_ description: String) }init?(_ description: String)protocol { associatedtype IntegerLiteralType; init(integerLiteral:) }protocol { associatedtype FloatLiteralType; init(floatLiteral:) }protocol { associatedtype BooleanLiteralType; init(booleanLiteral:) }protocol : ExpressibleByExtendedGraphemeClusterLiteral { init(stringLiteral:) }protocol : ExpressibleByStringLiteral { init(stringInterpolation:) }protocol : ExpressibleByUnicodeScalarLiteral { init(extendedGraphemeClusterLiteral:) }protocol { init(unicodeScalarLiteral:) }protocol { associatedtype ArrayLiteralElement; init(arrayLiteral:) }protocol { associatedtypes Key,Value; init(dictionaryLiteral:) }protocol : ~Copyable, ~Escapable { init(nilLiteral: ()) }protocol : Equatable { static var zero; +; +=; -; -= }static var zero: Self { get }static func +/-/+=/-= (...)protocol : AdditiveArithmetic, ExpressibleByIntegerLiteral { init?(exactly:); var magnitude; *; *= }init?<T>(exactly source: T) where T : BinaryIntegervar magnitude: Self.Magnitude { get }static func * / *= (lhs: Self, rhs: Self)protocol : Numeric { prefix static func -; mutating func negate() }prefix static func - (operand: Self) -> Selfmutating func negate()protocol<Stride> : Comparable { func distance(to:); func advanced(by:) }func distance(to other: Self) -> Self.Stridefunc advanced(by n: Self.Stride) -> Selfstatic func < / == (x: Self, y: Self) -> Boolprotocol Encodable { func encode(to encoder: any Encoder) throws }func encode(to encoder: any Encoder) throwsprotocol Decodable { init(from decoder: any Decoder) throws }init(from decoder: any Decoder) throwstypealias Codable = Decodable & Encodableprotocol : CustomDebug/StringConvertible, Sendable { var stringValue; init?(stringValue:); var intValue; init?(intValue:) }var stringValue: String { get }; var intValue: Int? { get }stringValue and nil intValue; enum raw-value backed CodingKeys and integer payload semantics remain shallow.init?(stringValue:); init?(intValue:)init?(stringValue:) works in native/WASM smoke tests; init?(intValue:) is accepted for conformance but non-nil integer-key payloads are not stable.protocol Encoder { ... }; protocol Decoder { ... }T: Encoder / T: Decoder constraints compile and run for custom conformer smoke tests. Container-producing requirements, userInfo, codingPath, and real Encoder/Decoder runtime dispatch remain unmodeled; JSON encode/decode still uses MiniSwift's direct JSON bridge.protocol KeyedEncodingContainerProtocol { ... } (+ decoding/single/unkeyed)struct CodingUserInfoKey : RawRepresentable, Hashable, Sendable { init?(rawValue: String) }init?(rawValue:), rawValue, equality, hashValue, force unwrap, and if let smoke paths are lowered; userInfo plumbing through Encoder/Decoder and Sendable marker semantics remain shallow.func f() async -> Tawait exprasync let x = exprawait x reads the value. No concurrent execution. Verified compiles+runs.func f() async throws; try await f()actor A { ... }nonisolated func m()await a.m()init(priority:operation:)var value: Success { get async throws }var result: Result<Success,Failure> { get async }await task.result wraps the eager MiniSwift task payload in Result.success and is regression-tested for Int payloads; throwing task failure, typed Failure propagation, cancellation, and error boxing remain missing.static func detached(priority:operation:) -> Taskstatic func sleep(nanoseconds:) async throwsstatic func sleep<C:Clock>(for:tolerance:clock:) async throwsTask.sleep(for: Duration) lowers to the existing nanosecond sleep ABI and is regression-tested. tolerance, custom Clock overloads, sleep(until:), cancellation throwing, and real async suspension semantics remain missing.static func yield() asyncfunc cancel()var isCancelled: Bool / static var isCancelledTask.isCancelled lowers to false in wasm/native; instance cancellation state is still not tracked.static func checkCancellation() throwsstatic var currentPriority: TaskPriority.medium raw-value code; real priority scheduling and instance priority remain unmodeled.struct TaskPriority: RawRepresentable (.high/.medium/.low/.background/.utility/.userInitiated).rawValue reads back; initializer/equality and scheduling effects remain simplified.func withTaskGroup<C,R>(of:returning:body:) async -> RwithTaskGroup(of:){ group in } → __swift_taskgroup_create/body/await_all/free; addTask/addTaskUnlessCancelled/waitForAll and for await v in group smoke paths run. Throwing/cancellation/scheduler semantics remain shallow.func withThrowingTaskGroup<C,R>(...) async throws -> Rfunc withDiscardingTaskGroup<R>(...) async -> Rmutating func addTask(priority:operation:)mutating func next() async -> ChildTaskResult?for await value in group drains MiniSwift taskgroup child results through __swift_taskgroup_has_next/__swift_taskgroup_next. Direct await group.next() still does not materialize the optional result correctly, and throwing/cancellation ordering semantics remain shallow.mutating func waitForAll() async__swift_taskgroup_await_all; cancelAll is a no-op and isCancelled returns false. Real cancellation state and throwing variants remain missing.protocol AsyncSequence { associatedtype Element; func makeAsyncIterator() }T: AsyncSequence generic constraints accept AsyncStream smoke values. Arbitrary user AsyncSequence witnesses, lazy iterator identity, suspension, throwing iteration, and most generic adapters remain partial.protocol AsyncIteratorProtocol { mutating func next() async throws -> Element? }next() witness dispatch and standalone makeAsyncIterator() identity remain unmodeled.func map<T>(_ transform: @Sendable (Element) async -> T) -> AsyncMapSequenceAsyncStream<Int>.map({ ... }) lowers to a new array-backed stream token and is smoke-tested through for await. Generic AsyncSequence adapters, lazy iterator identity, async suspension, throwing transforms, and non-scalar fidelity remain missing.func filter(_ isIncluded: @Sendable (Element) async -> Bool) -> AsyncFilterSequenceAsyncStream<Int>.filter({ ... }) lowers to an array-backed stream token. General AsyncSequence filters, throwing predicates, lazy behavior, and true async scheduling remain missing.func compactMap<T>(...) -> AsyncCompactMapSequenceAsyncStream<Int>.compactMap/flatMap({ ... }) smoke paths reuse the map-style array-backed adapter. Optional nil-dropping, sequence flattening, throwing/async transforms, and generic AsyncSequence support remain missing.func reduce<R>(_:_:) async rethrows -> RAsyncStream<Int>.reduce(seed,{ acc,value in ... }) lowers to a synchronous accumulator loop. reduce(into:), throwing reducers, cancellation, suspension, and generic AsyncSequence reducers remain missing.func contains(_:) async rethrows -> Bool, etc.AsyncStream<Int>.contains(_:) lowers to array-backed token membership and is smoke-tested. Predicate contains, first(where:), min, max, generic AsyncSequence terminal algorithms, and real async suspension remain missing.func prefix(_:) -> AsyncPrefixSequenceAsyncStream<Int>.prefix(_:) lowers to an array-backed count adapter and is smoke-tested. dropFirst, prefix(while:), lazy iterator identity, and generic AsyncSequence adapters remain missing.for await x in asyncSeq { }TaskGroup and array-backed AsyncStream values. General AsyncSequence/AsyncIteratorProtocol lowering remains missing.struct AsyncStream<Element>AsyncStream<Int>({ continuation in ... }) creates an array-backed stream token that for await can drain synchronously. Generic-constructor trailing closure parsing (AsyncStream<Int> { ... }), buffering policy, real suspension, backpressure, and iterator identity remain missing.init(_:bufferingPolicy:_ build:(Continuation)->Void)bufferingPolicy, escaped continuations, asynchronous producer timing, and throwing/cancellation behavior remain missing.static func makeStream(...) -> (stream, continuation)AsyncStream<Int>.makeStream(of:) returns a labeled tuple whose stream and continuation share the same array-backed token; yielded Int values are visible through for await. Buffering policy, generic element fidelity beyond simple scalars, escaped lifetime, and real suspension remain missing.func yield(_:) -> YieldResult; func finish()yield(_:) appends to the stream token and finish() is a no-op for synchronous smoke tests. YieldResult, onTermination, escaped continuation lifetime, and backpressure are not modeled.struct AsyncThrowingStream<Element,Failure:Error>AsyncThrowingStream({ continuation in ... }) shares the array-backed stream/continuation lowering and for await drain path. Explicit two-argument generic constructor parsing/type propagation, thrown errors, failure typing, and termination semantics remain missing.func withCheckedContinuation<T>(isolation:_ body:(CheckedContinuation<T,Never>)->Void) async -> Tresume(returning:); isolation, checked misuse diagnostics, cancellation, and suspension semantics remain missing.func withCheckedThrowingContinuation<T>(...) async throws -> Tresume(returning:); real thrown-error propagation and resume(throwing:) behavior are not modeled.func withUnsafeContinuation<T>(_ fn:(UnsafeContinuation<T,Never>)->Void) async -> Tresume(returning:) writes the result; throwing/error, multi-resume, lifetime, and real suspension semantics remain missing.struct CheckedContinuation<T,E>: Sendable { func resume(returning:)/resume(throwing:) }resume(returning:) stores into the slot. resume(throwing:), resume(with:), Sendable/runtime validation, and diagnostics are not implemented.@globalActor final actor MainActor { static var shared }static func run<T>(resultType:_ body:@MainActor ()throws->T) async rethrows -> T@MainActor func/var/classprotocol GlobalActor { associatedtype ActorType; static var shared }@globalActor declarations and annotations compile and run as marker isolation in smoke tests; protocol witness metadata, executor routing, cross-actor hops, and strict isolation diagnostics remain missing.protocol Sendable@Sendable () -> Voidclass C: @unchecked Sendableprotocol Actor: AnyObject, Sendable { var unownedExecutor }final class TaskLocal<Value>: Sendable { init(wrappedValue:); func withValue(_:operation:) }TaskLocal(wrappedValue:), .wrappedValue, and withValue(_:){} returning the operation result. Real task-local propagation, nested override stacks, property-wrapper syntax, inheritance across tasks, and concurrency isolation remain missing.protocol Clock<Duration>: Sendable { var now; func sleep(until:tolerance:) }.now and sleep(until:) smoke lowering; generic Clock existentials/witnesses, tolerance, cancellation, and real scheduler time remain missing.struct ContinuousClock: Sendable { var now: Instant }ContinuousClock() constructs a shallow token and .now returns deterministic Clock.Instant nanoseconds token 0; no monotonic real-time source or platform clock integration.struct SuspendingClock: Sendable { var now: Instant }.now smoke path works, but suspend/resume semantics and real time source are not modeled.protocol InstantProtocol<Duration>: Comparable,Hashable,Sendable { func advanced(by:); func duration(to:) }advanced(by:) and duration(to:) lower to integer add/sub and are regression-tested. Protocol witnesses, hashing, real clock identity, and precision semantics remain missing.struct Duration: Sendable { static func seconds/milliseconds/microseconds/nanoseconds(_:) }static func + / - / * ; var components: (seconds,attoseconds)+, -, *, and comparisons over nanosecond tokens are lowered and regression-tested. components/attoseconds tuple, division, overflow behavior, and DurationProtocol exactness remain missing.struct CancellationError: Errorfunc withUnsafeCurrentTask<T>(body:(UnsafeCurrentTask?)->T) -> TUnsafeCurrentTask? token; real current-task introspection and task handle metadata are not modeled.protocol Executor: AnyObject, Sendable { func enqueue(_:) }DispatchQueue.main.asUnownedTaskExecutor(), DispatchSerialQueue.asUnownedSerialExecutor(), enqueue(_:), and token equality compile/run. There is still no real Swift executor scheduler, ExecutorJob execution model, custom executor isolation, or task preference scheduling.public class AnyKeyPath : _AppendKeyPathlet kp: AnyKeyPath = \Root.field preserves MiniSwift's key-path slot token, and equality/hash/debug smoke paths are verified. It is still an integer token, not a heap key-path object with Objective-C/Swift metadata identity.static var rootType: any Any.Type { get }KeyPath<Root, Value> values expose MiniSwift root type-name metadata. Type-erased AnyKeyPath values still fall back to Any, and runtime key-path metadata identity is still missing.static var valueType: any Any.Type { get }KeyPath<Root, Value> values expose MiniSwift value type-name metadata. Type-erased AnyKeyPath values still fall back to Any, and runtime key-path metadata identity is still missing.var hashValue: Int; func hash(into:)hashValue returns the MiniSwift slot token and is stable for repeated literals. hash(into:), real identity hashing, composed paths, and metadata-backed hashing remain missing.static func == (AnyKeyPath, AnyKeyPath) -> Boolvar debugDescription: String { get }public class PartialKeyPath<Root> : AnyKeyPathPartialKeyPath<Root> annotations preserve the same MiniSwift key-path token used by stored-property subscripts; equality and hashValue smoke paths are verified. Type-erased value projection, metadata identity, and composed paths remain missing.public class KeyPath<Root, Value> : PartialKeyPath<Root>public class WritableKeyPath<Root, Value> : KeyPath<Root, Value>public class ReferenceWritableKeyPath<Root, Value> : WritableKeyPath<Root, Value>ReferenceWritableKeyPath annotations lower through the MiniSwift slot token and support object[keyPath:] get/set smoke paths. Class-only validation, reference-writeability metadata, inheritance covariance, and heap key-path identity remain missing.\Root.property / \.propertysubscript(keyPath: KeyPath<Self, V>) -> V { get }subscript(keyPath: WritableKeyPath<Self, V>) -> V { get set }func appending(path:) -> KeyPath<Root, AppendedValue>? (and overload family)kp.appending(path:) name-resolves and returns nil for unsupported composed paths in smoke tests. Real composed key-path object construction, metadata, optional return identity, and nested projection lowering remain missing.public init(reflecting subject: Any)init<Subject,C>(_:children:displayStyle:ancestorRepresentation:)init<Subject,C>(_:unlabeledChildren:displayStyle:...)init<Subject>(_:children: KeyValuePairs<String,Any>,...)let subjectType: any Any.TypeMirror(reflecting:) smoke paths (Int verified), matching the existing type(of:) string-metatype compromise. True Any.Type metadata is still missing.let children: Mirror.ChildrenMirror(reflecting: [Int]).children materializes an array-backed child tuple collection; count/subscript/for-in and child.value are verified. Non-array subjects, optional labels, Any value boxing, custom mirror children, and true AnyCollection<Child> identity remain missing.let displayStyle: Mirror.DisplayStyle?var superclassMirror: Mirror? { get }Mirror(reflecting:) value model and is regression-tested. Class hierarchy reflection remains missing.func descendant(_ first: MirrorPath, _ rest: MirrorPath...) -> Any?Mirror(reflecting: [Int/Bool]).descendant(index) lowers through the array-backed Mirror token and returns Element? for in-bounds numeric paths, with nil for negative/out-of-range indexes. String-label paths, variadic rest paths, non-array subjects, Any? boxing, custom children, and true MirrorPath semantics remain missing.var description: String { get }Int description/debugDescription are verified. Full Swift Mirror for T rendering and child-backed formatting remain missing.var customMirror: Mirror { get }customMirror.displayStyle smoke paths work. Full CustomReflectable integration and child metadata remain missing.enum DisplayStyle { case struct/class/enum/tuple/optional/collection/dictionary/set/foreignReference }Mirror.DisplayStyle values and equality/inequality smoke paths are verified. Real enum metadata, hashing, keyword-case coverage, and foreignReference fidelity remain shallow.enum AncestorRepresentation { case generated / customized(()->Mirror) / suppressed }generated and suppressed lower as string-backed case tokens with equality smoke coverage. The associated-value customized case and constructor-driven ancestor behavior are missing.typealias Child=(label:String?,value:Any); typealias Children=AnyCollection<Child>label/value fields and array collection behavior. Labels are plain strings, values keep the concrete element type instead of Any, and AnyCollection identity is not modeled.func type<T,Metatype>(of value: T) -> Metatypefunc print(_ items: Any..., separator: String = " ", terminator: String = "\n")func print<Target>(..., to output: inout Target) where Target: TextOutputStreamto: is separated from variadic items and appends joined output + terminator to String sinks or nominal sinks with a String stored field; generic witness dispatch and arbitrary custom storage remain unmodeled.func debugPrint(_ items: Any..., separator: String = " ", terminator: String = "\n")func debugPrint<Target>(..., to output: inout Target) where Target: TextOutputStreamfunc dump<T>(_ value: T, name:..., indent:..., maxDepth:..., maxItems:...) -> Tfunc dump<T,TargetStream>(_ value: T, to target: inout TargetStream, ...) -> Tdump(..., to:) appends minimal dump text to String sinks or nominal sinks with a String stored field for scalar and array-literal smoke paths; full Mirror formatting, options, and witness-routed storage remain unmodeled.func assert(_ condition:@autoclosure ()->Bool, _ message:@autoclosure ()->String = "", file:..., line:...)func assertionFailure(_ message:@autoclosure ()->String = "", file:..., line:...)func precondition(_ condition:@autoclosure ()->Bool, _ message:@autoclosure ()->String = "", file:..., line:...)func preconditionFailure(_ message:@autoclosure ()->String = "", file:..., line:...) -> Neverfunc fatalError(_ message:@autoclosure ()->String = "", file:..., line:...) -> Neverinit(_ x: AnyObject) / init(_ x: Any.Type)AnyObject/class instance init lowers to a stable MiniSwift pointer-identity token; Any.Type identity is not yet modeled.Equatable, Comparable, Hashable, CustomDebugStringConvertiblehashValue, hash(into:), Hasher.combine, debugDescription, Int(bitPattern:), and Identifiable class default id use the MiniSwift pointer-identity token and are verified.static var size: Int { get }MemoryLayout<Int>.size == 8 verified in wasm/native. Full ABI layout remains partial.static var stride: Int { get }static var alignment: Int { get }static func size/stride/alignment(ofValue value: T) -> IntofValue primitive layout constants now lower; full generic ABI layout remains partial.static func offset(of key: PartialKeyPath<T>) -> Int?slot * 8) for flat stored properties; optional return identity, inferred-root contexts, nested/computed/subscript paths, and full ABI layout remain partial.func withoutActuallyEscaping<C,R,F>(_ closure: C, do body: (C) throws(F) -> R) throws(F) -> Rbody(closure) calls for non-throwing closure values and preserves MiniSwift's fat/thin closure ABI; body closures that capture additional function values, true escapability diagnostics, throwing propagation, and ownership semantics remain unmodeled.func autoreleasepool<Result>(invoking body: () throws -> Result) rethrows -> Result@frozen struct UnsafePointer<Pointee>var pointee: Pointee { get }subscript(i: Int) -> Pointee { get }func deallocate()func withMemoryRebound<T,E,Result>(to: T.Type, capacity: Int, _ body: (UnsafePointer<T>) throws(E) -> Result) throws(E) -> Resultfunc pointer<Property>(to: KeyPath<Pointee,Property>) -> UnsafePointer<Property>?func advanced(by: Int) -> Self; func distance(to: Self) -> Intextension UnsafePointer : ...hashValue, hash(into:), and debugDescription now lower over pointer identity tokens and are verified for UnsafePointer<Int>/UnsafeMutablePointer<Int> smoke paths; CVarArg varargs, raw/buffer families, and full witness-table routing remain shallow.@frozen struct UnsafeMutablePointer<Pointee>static func allocate(capacity: Int) -> UnsafeMutablePointer<Pointee>func deallocate()var pointee: Pointee { get nonmutating set }subscript(i: Int) -> Pointee { get nonmutating set }init(mutating: UnsafePointer<Pointee>); init(_: UnsafeMutablePointer<Pointee>) (+ optional variants)func initialize(to: consuming Pointee)func initialize(repeating: Pointee, count: Int)UnsafeMutablePointer<Int>; object lifetime and typed layout semantics remain shallow.func initialize(from: UnsafePointer<Pointee>, count: Int)memcpy(dst, src, count * 8) under the word-pointer model and is verified for Int pointers; non-word pointee layout/lifetime semantics remain shallow.func update(repeating:count:); func update(from:count:)func move() -> Pointeefunc moveInitialize(from:count:); func moveUpdate(from:count:)memcpy(dst, src, count * 8) and is verified for Int pointers; source invalidation, move-only semantics, and deprecated moveAssign aliases remain shallow.@discardableResult func deinitialize(count: Int) -> UnsafeMutableRawPointerUnsafeMutableRawPointer and performs no destroy work; count/lifetime semantics remain shallow.func withMemoryRebound<T,E,Result>(to:capacity:_:) ...func pointer<Property>(to: KeyPath/WritableKeyPath<Pointee,Property>) -> Unsafe(Mutable)Pointer<Property>?@frozen struct UnsafeRawPointerinit<T>(_: UnsafePointer<T>); init?(bitPattern: Int/UInt) (+ typed/optional family)func load<T>(fromByteOffset: Int = 0, as: T.Type) -> Tfunc loadUnaligned<T>(fromByteOffset: Int = 0, as: T.Type) -> T (BitwiseCopyable + generic overloads)func bindMemory<T>(to:capacity:) -> UnsafePointer<T>; func assumingMemoryBound<T>(to:) -> UnsafePointer<T>func withMemoryRebound<T,E,Result>(to:capacity:_:) ...func deallocate()free; verified after raw allocation/conversion.func advanced(by: Int) -> UnsafeRawPointerfunc alignedUp/alignedDown(for: T.Type / toMultipleOf: Int) -> UnsafeRawPointer@frozen struct UnsafeMutableRawPointerstatic func allocate(byteCount: Int, alignment: Int) -> UnsafeMutableRawPointermalloc(byteCount); alignment parameter is accepted but not separately enforced.func deallocate()free; verified through mutable raw pointer aliases.init<T>(_: UnsafeMutablePointer<T>); init(mutating: UnsafeRawPointer) (+ optional/typed family)func load<T>(fromByteOffset:as:) -> T; func loadUnaligned<T>(fromByteOffset:as:) -> Tfunc storeBytes<T>(of: T, toByteOffset: Int = 0, as: T.Type)func copyMemory(from: UnsafeRawPointer, byteCount: Int)memcpy(dst, src, byteCount) and is verified with raw loads after copy.func bindMemory<T>(to:capacity:) -> UnsafeMutablePointer<T>; func assumingMemoryBound<T>(to:)func initializeMemory<T>(as:to:); (as:repeating:count:); (as:from:count:) -> UnsafeMutablePointer<T>Int; binding, lifetime, and non-word layout semantics remain shallow.func moveInitializeMemory<T>(as:from:count:) -> UnsafeMutablePointer<T>memcpy(dst, src, count * 8); source invalidation and move-only/lifetime semantics are not modeled.func withMemoryRebound(...); func advanced(by:); func alignedUp/alignedDown(...)withMemoryRebound calls the body with a mutable typed pointer view, and advanced(by:)/alignedUp/alignedDown lower as byte-offset pointer arithmetic; full binding/lifetime/layout semantics remain shallow.@frozen struct UnsafeBufferPointer<Element>{base,count} record for pointer-created buffers; withMemoryRebound can pass a typed buffer view to a closure, while lifetime, iterator identity, rebasing slices, and full Collection conformance remain partial.init(start: UnsafePointer<Element>?, count: Int); init(_: UnsafeMutableBufferPointer<Element>); init(rebasing: Slice<...>)start:count: creates a {base,count} record and init(_:) can carry an existing buffer token; rebasing/slice lifetime semantics are not modeled.var baseAddress: UnsafePointer<Element>? { get }; var count/isEmptycount, isEmpty, startIndex, endIndex, and baseAddress == nil are verified for pointer-backed records; optional pointer force/use and lifetime semantics remain partial.subscript(i: Int) -> Element; startIndex/endIndex/indices/index(after:)/distance(...)func makeIterator() -> UnsafeBufferPointer<Element>.IteratormakeIterator() clones the MiniSwift {base,count} buffer record and next() advances base/count in place; verified for nonzero and zero Int payloads with heap Optional tag/nil semantics. Wider lifetime/ABI caveats stay tracked on the UnsafeBufferPointer family rows.func withMemoryRebound<T,E,Result>(to:_:) ...func extracting(_: Range<Int>) -> UnsafeBufferPointer<Element>; var span: Span<Element>extracting(_:) over Range<Int> creates a rebased MiniSwift {base,count} record and is verified for Int buffers. span, bounds traps, closed/partial ranges, ownership, and lifetime semantics remain missing.func deallocate()@frozen struct UnsafeMutableBufferPointer<Element>{base,count} record as immutable buffers; metadata, subscript get/set, and common initialization smoke paths work, but full lifetime and sequence conformance remain partial.static func allocate(capacity: Int) -> UnsafeMutableBufferPointer<Element>init(start:count:); subscript(i: Int) -> Element { get nonmutating set }init(start:count:) plus integer subscript get/set are verified over typed pointer storage; bounds and full MutableCollection semantics remain shallow.func initialize(repeating:); initialize(from:); update(repeating:); moveInitialize(fromContentsOf:); deinitialize()initialize(repeating:), update(repeating:), moveInitialize(fromContentsOf:), subscript writes, and no-op deinitialize() are verified for Int buffers; generic layout, large dynamic counts, and lifetime semantics remain partial.var baseAddress; func withMemoryRebound(...); func extracting(_:); var spanbaseAddress is exposed from the buffer record and nil checks are verified; withMemoryRebound passes a mutable typed buffer view to the body, while extracting, span, and full binding rules remain missing.@frozen struct UnsafeRawBufferPointer{base,count} record for raw-buffer views; ownership, iterator identity, rebasing slices, and full Collection/lifetime semantics remain partial.init(start: UnsafeRawPointer?, count: Int); init(UnsafeMutableRawBufferPointer); init(rebasing:)start:count: creates a raw {base,count} record and init(_:) can carry an existing mutable raw buffer token; rebasing/slice semantics are not modeled.var baseAddress: UnsafeRawPointer?; var count; subscript(i: Int) -> UInt8 { get }baseAddress, count, isEmpty, startIndex, endIndex, and integer subscript are verified for pointer-backed records; subscript uses MiniSwift's slot load/store model, so true byte-precise iteration/bounds remain partial.func load<T>(fromByteOffset:as:) -> T; func loadUnaligned<T>(fromByteOffset:as:) -> TInt offsets; unaligned/non-word layouts are still shallow.func bindMemory<T>(to:) -> UnsafeBufferPointer<T>; func withMemoryRebound(...)bindMemory(to:) and withMemoryRebound create typed buffer records with count / 8 elements over the same base; real binding/lifetime rules, throwing propagation, and non-word layout remain shallow.func deallocate()@frozen struct UnsafeMutableRawBufferPointer{base,count} record; metadata, subscript get/set, and common load/store/copy smoke paths work, but full MutableCollection/lifetime semantics remain partial.static func allocate(byteCount: Int, alignment: Int) -> UnsafeMutableRawBufferPointerfunc storeBytes<T>(of:toByteOffset:as:); func copyMemory(from:); func copyBytes(from:)storeBytes, copyMemory(from:), and copyBytes(from:) lower over raw base pointers and byte counts; verified for aligned Int slots, with generic byte/layout semantics still partial.func initializeMemory<T>(as:repeating:); func bindMemory<T>(to:)initializeMemory(as:repeating:) fills the word-sized typed view and bindMemory(to:) returns a typed buffer record; source/lifetime binding and non-word element layouts remain partial.func load<T>(...); subscript(i: Int) -> UInt8 { get nonmutating set }; func deallocate()load, subscript get/set, and deallocate are verified for MiniSwift-created raw buffer records; byte-precise subscript semantics and ownership safety remain partial.func withUnsafePointer<T,E,Result>(to: borrowing/inout T, _: (UnsafePointer<T>) throws(E) -> Result) throws(E) -> Resultfunc withUnsafeMutablePointer<T,E,Result>(to: inout T, _: (UnsafeMutablePointer<T>) throws(E) -> Result) throws(E) -> Resultpointee for local Int smoke tests; lifetime/exclusivity/rethrowing and non-local address semantics remain partial.func withUnsafeBytes<T,E,Result>(of: borrowing/inout T, _: (UnsafeRawBufferPointer) throws(E) -> Result) throws(E) -> Resultfunc withUnsafeMutableBytes<T,E,Result>(of: inout T, _: (UnsafeMutableRawBufferPointer) throws(E) -> Result) throws(E) -> Resultfunc withUnsafeTemporaryAllocation<R,E>(byteCount:alignment:_:); (of:capacity:_:)func unsafeBitCast<T,U>(_: T, to: U.Type) -> Ufunc unsafeDowncast<T>(_: AnyObject, to: T.Type) -> Tfunc swap<T>(_: inout T, _: inout T)func withExtendedLifetime<T,E,Result>(_: borrowing T, _: () throws(E) -> Result) throws(E) -> Result (+ borrowing-arg overload)@frozen enum MemoryLayout<T>static var size/stride/alignment: Int { get }MemoryLayout<Int> returns 8/8/8); complex layouts remain partial.static func size/stride/alignment(ofValue: borrowing T) -> IntofValue constants verified; complete generic layout remains partial.static func offset(of key: PartialKeyPath<T>) -> Int?slot * 8) for flat stored properties; optional return identity, inferred-root contexts, nested/computed/subscript paths, and full ABI layout remain partial.open class ManagedBuffer<Header, Element>{header, capacity, elements} token with word-sized element storage. Swift's tail allocation, subclassing hooks, ARC/retain/release behavior, and CoreFoundation bridging remain unsupported.static func create(minimumCapacity: Int, makingHeaderWith: ...) -> ManagedBuffer<Header,Element>var header; var capacity; func withUnsafeMutablePointerToHeader/Elements/Pointers(_:)@frozen struct ManagedBufferPointer<Header, Element>init(bufferClass:minimumCapacity:makingHeaderWith:); init(unsafeBufferObject:); var header/buffer/capacity; func withUnsafeMutablePointers...init(unsafeBufferObject:), header, capacity, buffer, and mutable header/elements pointer closures are wired. bufferClass: construction, subclass-aware allocation, lifetime rules, and tail storage invariants remain shallow.@frozen struct Unmanaged<Instance: AnyObject>static func fromOpaque(_: UnsafeRawPointer) -> Unmanaged<Instance>; func toOpaque() -> UnsafeMutableRawPointerstatic func passRetained/passUnretained(_: Instance) -> Unmanaged<Instance>Unmanaged<Instance> identity token for class objects; no retain count change is performed.func takeRetainedValue() -> Instance; func takeUnretainedValue() -> Instancefunc retain() -> Unmanaged<Instance>; func release(); func autorelease() -> Unmanaged<Instance>retain/autorelease return the same token and release is a no-op; manual refcount/autorelease-pool behavior remains missing.@frozen struct OpaquePointerhashValue, hash(into:), Hasher.combine, debugDescription, casts, and optional constructors are verified over MiniSwift pointer identity tokens.init?(bitPattern: Int/UInt); init<T>(_: UnsafePointer<T>) (+ raw/mutable/optional family)@frozen struct AutoreleasingUnsafeMutablePointer<Pointee>var pointee: Pointee; subscript(i: Int) -> Pointee; init(_: UnsafeMutablePointer<Pointee>)protocol CVarArgwithVaList smoke tests; true C varargs ABI encoding is not modeled.@frozen struct CVaListPointerwithVaList closures; no readable va_list storage or platform ABI layout.func withVaList<R>(_: [any CVarArg], _: (CVaListPointer) -> R) -> RCVaListPointer token; real C varargs marshalling remains missing.typealias CInt = Int32; CChar = Int8; CLong = Int; CShort = Int16; CLongLong = Int64; CSignedChar = Int8typealias CUnsignedInt = UInt32; CUnsignedChar = UInt8; CUnsignedLong = UInt; CUnsignedShort = UInt16; CUnsignedLongLong = UInt64typealias CFloat = Float; CDouble = Double; CLongDouble = Double; CBool = Bool; CChar16 = UInt16; CChar32/CWideChar = Unicode.Scalarprotocol SIMD<Scalar> : SIMDStorage, Hashable, Codable, ExpressibleByArrayLiteral, CustomStringConvertibleT: SIMD generic constraints now specialize for MiniSwift's array-backed SIMD2/3/4 value tokens in smoke paths. True vector ABI/lowering, associated-type fidelity, Codable/Hashable completeness, and wide/non-Int vector behavior remain partial.protocol SIMDScalar : BitwiseCopyable; protocol SIMDStorageT: SIMDScalar generic constraints accept scalar Int smoke paths, and T: SIMD vector-generic calls can pass MiniSwift SIMD tokens. Associated vector storage, real SIMDStorage layout, and full vector protocol witness behavior remain partial.@frozen struct SIMDn<Scalar: SIMDScalar> : SIMDSIMD2/3/4<Int> now lower to an array-backed MiniSwift value token with lane storage. Wider vectors, non-Int scalar fidelity, ABI layout, protocol conformances, and real vector lowering are still missing.init(); init(_ v0:_ v1:...); init(repeating: Scalar); init(arrayLiteral: Scalar...)repeating: initializers for SIMD2/3/4<Int> materialize lane storage. Sequence initializers, wider vectors, scalar-specific layout, and validation remain missing.var scalarCount: Int; subscript(index: Int) -> Scalar; var x/y/z/w: ScalarscalarCount, x/y/z/w, integer subscript reads, subscript writes, and lane property writes use the array-backed lane storage for SIMD2/3/4<Int>. Swizzles, wider vectors, non-Int lane fidelity, and vector ABI layout are still missing.static func +/-/*//(a: Self, b: Self) -> Self; &+/&-/&* wrapping; addingProduct; squareRoot; rounded+, -, *, /, &+, &-, and &* lower lane-wise for array-backed SIMD2/3/4<Int>; vector-vector addingProduct(_:_:) is also covered. squareRoot, rounded, wider vectors, non-Int scalar fidelity, and true vector ABI lowering remain missing.static func &/^/|/&<</&>>(a: Self, b: Self) -> Self (+ scalar-mixed overloads)&, `static func .==/.!=/.</.<=/.>/.>=(a: Self, b: Self/Scalar) -> SIMDMask<Self.MaskStorage>.==, .!=, .<, .<=, .>, and .>= lower lane-wise for array-backed SIMD2/3/4<Int> and return a [Bool] mask token. True SIMDMask<Storage> ABI/type identity, wider vectors, and non-Int scalar fidelity remain missing.subscript<Index: FixedWidthInteger & SIMDScalar>(index: SIMDn<Index>) -> SIMDn<Scalar>SIMD2/3/4<Int> index-vector subscripts reorder array-backed lanes, including repeated indices. Cross-width swizzles, non-Int index/scalar fidelity, mutation, bounds diagnostics, and true vector ABI lowering remain missing.func min() -> Scalar; func max() -> Scalar; func sum() -> Scalar; func wrappedSum() -> Scalarsum, wrappedSum, min, and max lower over array-backed lanes for SIMD2/3/4<Int>. Wider vectors, non-Int scalar fidelity, true vector reductions, and distinct wrapping overflow semantics remain missing.func replacing(with: Self/Scalar, where: SIMDMask) -> Self; func clamped(lowerBound:upperBound:) -> Selfclamped(lowerBound:upperBound:) and replacing(with:where:) lower lane-wise for array-backed SIMD2/3/4<Int> using Bool mask tokens. Scalar bounds/replacements, true SIMDMask, wider vectors, non-Int scalar fidelity, and true vector ABI lowering remain missing.static var zero/one: Self; static func random(in: Range/ClosedRange<Scalar>[, using:]) -> Selfzero and one materialize array-backed lane storage for SIMD2/3/4<Int>. random(in:), wider vectors, scalar-specific layout, and true vector constants remain missing.@frozen struct SIMDMask<Storage: SIMD> : SIMDSIMDMask<SIMD3<Int>> annotations accept comparison masks and expose array-backed Bool subscript reads. True SIMDMask ABI/type identity, generic storage fidelity, mutations, and boolean-vector lowering remain missing.static func .&/.| /.^(a: Self, b: Self) -> Self; prefix .!; func any()/all() via reductions.&, `.func print(_ items: Any..., separator: String = " ", terminator: String = "\n")func print<Target>(_ items: Any..., separator: String, terminator: String, to output: inout Target) where Target : TextOutputStreamto: appends joined output + terminator to String sinks or nominal sinks with a String stored field; generic TextOutputStream witness dispatch and arbitrary custom storage remain unmodeled.func debugPrint(_ items: Any..., separator: String = " ", terminator: String = "\n")func debugPrint<Target>(_ items: Any..., to output: inout Target) where Target : TextOutputStreamfunc dump<T>(_ value: T, name: String? = nil, indent: Int = 0, maxDepth: Int = .max, maxItems: Int = .max) -> T- 0: 1 lines, diverging from Swift's - 1 element rows; uses minimal Mirror.func dump<T, TargetStream>(_ value: T, to target: inout TargetStream, ...) -> T where TargetStream : TextOutputStreamdump(..., to:) appends minimal dump text to String sinks or nominal sinks with a String stored field for scalar and array-literal smoke paths; full Mirror formatting, options, and witness-routed storage remain unmodeled.func type<T, Metatype>(of value: borrowing T) -> Metatypetype(of: 42) prints Int matching swift.func swap<T>(_ a: inout T, _ b: inout T) where T : ~Copyableswap(&a,&b) works.func min<T>(_ x: T, _ y: T) -> T where T : Comparablemin(3,1)=1.func max<T>(_ x: T, _ y: T) -> T where T : Comparablemax(3,7)=7.func min<T>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T where T : Comparablefunc abs<T>(_ x: T) -> T where T : Comparable, T : SignedNumericabs(-9)=9.func numericCast<T, U>(_ x: T) -> U where T : BinaryInteger, U : BinaryIntegernumericCast(UInt8(200)) as Int == 200.func zip<S1, S2>(_ s1: S1, _ s2: S2) -> Zip2Sequence<S1, S2> where S1 : Sequence, S2 : Sequencefunc stride<T>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> where T : StrideableStrideTo<Int> lower to range/step metadata; for-in, underestimatedCount, typed iterator annotations, and manual next() optional payload/nil paths are regression-tested.func stride<T>(from start: T, through end: T, by stride: T.Stride) -> StrideThrough<T> where T : StrideableStrideThrough<Int> lower to range/step metadata; for-in, underestimatedCount, typed iterator annotations, and manual next() optional payload/nil paths are regression-tested.func sequence<T>(first: T, next: @escaping (T) -> T?) -> UnfoldFirstSequence<T>next() consumption work on native and WASM via eager array materialization; generic element types, valid 0 elements, and lazy identity remain unmodeled.func sequence<T, State>(state: State, next: @escaping (inout State) -> T?) -> UnfoldSequence<T, State>next() consumption work on native and WASM via eager array materialization; generic state/element types, valid 0 elements, and lazy identity remain unmodeled.func repeatElement<T>(_ element: T, count n: Int) -> Repeated<T>Array(repeatElement(...)) on native and WASM.func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line)func assertionFailure(_ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line)func precondition(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line)func preconditionFailure(_ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line) -> Neverfunc fatalError(_ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line) -> Neverfunc withExtendedLifetime<T, E, R>(_ x: borrowing T, _ body: () throws(E) -> R) throws(E) -> Rfunc withExtendedLifetime<T, E, R>(_ x: borrowing T, _ body: (borrowing T) throws(E) -> R) throws(E) -> Rfunc readLine(strippingNewline: Bool = true) -> String?@frozen struct DefaultStringInterpolation : StringInterpolationProtocol, Sendableinit(literalCapacity: Int, interpolationCount: Int)mutating func appendLiteral(_ literal: String)mutating func appendInterpolation<T>(_ value: T) [+ CustomStringConvertible / TextOutputStreamable constrained family]\(value) segments lowered to description/concat at compile time; constrained overload family collapses to one path.mutating func appendInterpolation<T>(_ value: T?, default: @autoclosure () -> some StringProtocol)\(optionalIdentifier, default: fallbackString) lowers for primitive/String optional payloads; nil uses fallback and some prints the payload.protocol StringInterpolationProtocol { init(literalCapacity:interpolationCount:); mutating func appendLiteral(_:) }mutating func appendLiteral(_ literal: Self.StringLiteralType)protocol ExpressibleByStringInterpolation : ExpressibleByStringLiteralprotocol TextOutputStream { mutating func write(_ string: String) }protocol TextOutputStreamable { func write<Target>(to target: inout Target) where Target : TextOutputStream }write(to:) appends to String sinks or nominal sinks with a String stored field; arbitrary conforming values and generic witness dispatch remain unmodeled.@frozen struct StaticString : Sendable, ExpressibleByStringLiteralinit()var utf8Start: UnsafePointer<UInt8> { get }var utf8CodeUnitCount: Int { get }var hasPointerRepresentation: Bool { get }; var isASCII: Bool { get }; var unicodeScalar: Unicode.Scalar { get }func withUTF8Buffer<R>(_ body: (UnsafeBufferPointer<UInt8>) -> R) -> R[UInt8] buffer with count/subscript support and returns the closure result (test_sstr_31_with_utf8_buffer). True UnsafeBufferPointer ABI/lifetime semantics and full non-ASCII byte iteration remain unmodeled.var description: String { get }; var debugDescription: String { get }@frozen struct KeyValuePairs<Key, Value> : ExpressibleByDictionaryLiteral, RandomAccessCollectioninit(dictionaryLiteral elements: (Key, Value)...)subscript(position: Int) -> (key: Key, value: Value) { get }; var startIndex/endIndex: Intvar description: String { get }; var debugDescription: String { get }var span: Span<Element> { get }KeyValuePairs.span.count works over MiniSwift's existing backing token for annotated KeyValuePairs smoke paths. Element subscript/projection, true Span ownership, duplicate-preserving typed KVP storage, and lifetime semantics remain partial.@frozen struct ContiguousArray<Element>init(); init(_ s: S); mutating func append(_:); subscript(_ i: Int) -> Element; var count: Intfunc encode(to:) throws where Element : Encodable; init(from:) throws where Element : Decodable@frozen struct CollectionOfOne<Element> : RandomAccessCollection, MutableCollectioninit(_ element: Element)var startIndex: Int {0}; var endIndex: Int {1}; subscript(_:) -> Element@frozen struct EmptyCollection<Element> : RandomAccessCollection, MutableCollectionEmptyCollection<Int>().count == 0.init(); func makeIterator() -> Iterator; var startIndex/endIndex: Int {0}mutating func next() -> Element?@frozen struct Repeated<Element> : RandomAccessCollectionRepeated<Int> typed values are eager array-backed and verified for count/start/end/isEmpty, subscript, for-in, and manual iterator optional payload/nil paths.let count: Int; let repeatedValue: Element; subscript(position: Int) -> Element { get }repeatElement(...).repeatedValue lowering preserve the source value, including zero-count Repeated values, with native/WASM regression coverage.@frozen struct UnfoldSequence<Element, State> : Sequence, IteratorProtocolsequence(first:) and sequence(state:) can materialize stored nil-terminating Int streams as eager arrays for for-in and manual next() consumption; lazy identity, generic element/state, valid 0 elements, and iterator identity are not modeled.mutating func next() -> Element?some(0) and nil semantics; true lazy state-machine and generic element/state caveats stay tracked on the UnfoldSequence wrapper row.typealias UnfoldFirstSequence<T> = UnfoldSequence<T, (T?, Bool)>sequence(first:) can materialize stored nil-terminating Int streams as eager arrays for for-in; true alias/value identity and iterator state are not modeled.@frozen struct Zip2Sequence<S1, S2> : Sequence where S1 : Sequence, S2 : Sequencefunc makeIterator() -> Iterator; var underestimatedCount: Int { get }zip(...) materializes an array-backed tuple sequence; .underestimatedCount and .makeIterator() identity are verified by collections/others/test_others_06_zip_iterator.swift.mutating func next() -> (S1.Element, S2.Element)?var it = zip(...).makeIterator(); it.next() returns optional tuple payloads and nil at end for the array-backed iterator model.@frozen struct StrideTo<Element : Strideable> : Sequence; struct StrideToIterator<Element>StrideTo<Int> assignment, for-in, underestimatedCount, typed iterator annotation, and manual makeIterator().next() optional payload/nil smoke paths are verified.@frozen struct StrideThrough<Element : Strideable> : Sequence; struct StrideThroughIterator<Element>StrideThrough<Int> assignment, for-in, underestimatedCount, typed iterator annotation, and manual makeIterator().next() optional payload/nil smoke paths are verified.static func > (lhs: Self, rhs: Self) -> Bool<; comparison lowered to native instructions (coverage Comparable ✅).static func <= (lhs: Self, rhs: Self) -> Bool<; native compare.static func >= (lhs: Self, rhs: Self) -> Bool<; native compare.static func ... (minimum: Self, maximum: Self) -> ClosedRange<Self>static func ..< (minimum: Self, maximum: Self) -> Range<Self>static func != (lhs: Self, rhs: Self) -> Bool==; Equatable synthesis/witness paths exist (coverage ✅).