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; fully generic/existential RNG witness dispatch remains limited.static func random() -> Boolinit(from: any Decoder) throws ; func encode(to: any Encoder) throwsJSONEncoder/JSONDecoder Bool true/false smoke paths work on WASM/native; full Encoder/Decoder container model is still unmodeled.var customMirror: Mirror { get }customMirror.displayStyle == nil smoke path works through the scalar Mirror sentinel; full children/reflection printing remains shallow.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. True half-precision storage/rounding and non-finite Float16 exactness remain limited.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) and nil for invalid/Int.max + 1; narrow Int8/UInt8 range smoke paths are verified. UInt64-above-Int64, Int.min, and generic StringProtocol corners remain limited.init?(_ description: String)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; broader fixed-width edge coverage remains limited.func remainderReportingOverflow(dividingBy rhs: Self) -> (partialValue: Self, overflow: Bool)(self, true) and Int.min % -1 returns (0, true) without trapping; broader fixed-width edge coverage remains limited.func multipliedFullWidth(by other: Self) -> (high: Self, low: Self.Magnitude)(high, low) in wasm (3*4 -> 0,12 verified); true signed/unsigned 128-bit edge semantics remain partial.func dividingFullWidth(_ dividend: (high: Self, low: Self.Magnitude)) -> (quotient: Self, remainder: Self)high == 0 (34 / 17 -> 2 r0 verified); nonzero high word is not true 128-bit division yet.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 }42.words.count == 1, subscript 0 verified); not a full Words collection type.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 ranges on WASM/native; fully generic/existential RNG witness dispatch remains limited.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, 2^53+1 is nil); UInt64/extreme generic corners remain partial.public init(_ other: Float)/(_ other: Double)/(_ other: Float16)public init?(exactly other: Float)/(_:Double).some; Float/Double NaN returns nil. Float16/edge payload semantics remain partial.public init(sign: FloatingPointSign, exponent: Int, significand: Double).minus, 2, 1.5 -> -6.0 verified); Float/generic and edge semantics remain partial.public init(signOf: Double, magnitudeOf: Double)-1.0, 2.5 -> -2.5 verified); NaN/signed-zero edge fidelity remains partial.public init(bitPattern: UInt64)Double(bitPattern: 4611686018427387904) == 2.0 verified); UInt64 edge printing/sign-bit fidelity remains partial.public var bitPattern: UInt64 { get }1.0 verified); full UInt64/NaN payload display semantics remain partial.public init(nan payload: Double.RawSignificand, signaling: Bool)isNaN verified); payload/signaling distinction is not preserved.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 }.plus/.minus ((-5.5).sign verified); signed-zero/NaN edge semantics are shallow.var exponent: Self.Exponent { get }8.0.exponent == 3 verified); zero/subnormal/NaN/infinity edge semantics remain partial.var significand: Self { get }x / binade; zero/NaN/infinity edge semantics are not fully modeled.var ulp: Self { get }ulpOfOne; infinity/NaN edge semantics are incomplete.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 }Double.signalingNaN also reports false.var isCanonical: Bool { get }var floatingPointClass: FloatingPointClassification { get }func isEqual(to:)/isLess(than:)/isLessThanOrEqualTo(_:) -> Boolfunc isTotallyOrdered(belowOrEqualTo other: Self) -> Bool<=; full IEEE totalOrder NaN/sign-bit ordering is not implemented.static 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 }isNaN verifies.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); IEEE edge cases remain partial.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 ranges on WASM/native; fully generic/existential RNG witness dispatch remains limited.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; fully generic/existential RNG witness dispatch remains limited.init<Source>(_ value: Source) where Source : BinaryFloatingPointinit?<Source>(exactly value: Source) where Source : BinaryFloatingPointDouble(exactly:) handles finite values, infinity, and NaN nil; generic Float/Float16 exactness remains shallow.init(sign:exponentBitPattern:significandBitPattern:)+ 1023/0 -> 1.0, - 1024/0 -> -2.0 verified); Float/generic and payload edge semantics remain partial.static var exponentBitCount/significandBitCount: Int { get }var exponentBitPattern: RawExponent / significandBitPattern: RawSignificand { get }var binade: Self { get }6.0.binade == 4.0 verified); zero/subnormal/NaN/infinity edge semantics incomplete.var significandWidth: Int { get }func distance(to other: Double) -> Double; func advanced(by amount: Double) -> Doublevar description: String { get }public init?(_ text: String)var hashValue: Int; func hash(into:)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 == Characterinit(_ unicodeScalars: String.UnicodeScalarView)init<C,Enc>(decoding: C, as: Enc.Type)init?<Enc>(validating: Sequence, as: Enc.Type)init(cString: UnsafePointer<CChar>)init?(validatingCString: UnsafePointer<CChar>)init(unsafeUninitializedCapacity: Int, initializingUTF8With: (UnsafeMutableBufferPointer<UInt8>) throws -> Int) rethrowsinit(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?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>?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]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) -> Boolfunc 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.UTF8Viewvar utf16: String.UTF16Viewvar utf8CString: ContiguousArray<CChar> { get }func makeIterator() -> String.Iterator; mutating func next() -> Character?var isContiguousUTF8: Bool; mutating func makeContiguousUTF8(); withUTF8(_:)func withCString<R>(_ body: (UnsafePointer<Int8>) throws -> R) rethrows -> Rfunc 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/Hashableinit(_ 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/...var utf8: Unicode.Scalar.UTF8View; var utf16: Unicode.Scalar.UTF16Viewenum Unicode.UTF8: UnicodeCodec; encode/decode/width/...enum Unicode.ASCII: Unicode.Encodingenum 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) -> Boolvar 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)init<E>(capacity: Int, initializingWith: (inout OutputSpan<Element>) throws(E) -> Void)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?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:)func shuffled() -> [Element]; func shuffled<T>(using:) -> [Element]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?func withUnsafeBufferPointer<R,E>(_ body: (UnsafeBufferPointer<Element>) throws(E) -> R) throws(E) -> Rfunc withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> Rvar span: Span<Element> { get }; var mutableSpan: MutableSpan<Element> { mutating get }e.g. func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]func makeIterator() -> IndexingIterator<[Element]>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 accessorsEncodable/Decodable conformanceinit(); init<S: Sequence>(_:); init(repeating:count:); init(arrayLiteral:)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 accessorsEncodable/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 for tuple-result/index expressions; invalid-index traps and opaque index identity remain shallow.@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; invalid-index trapping and opaque index identity are shallow.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, Equatablestruct Values : MutableCollectionstruct Index : Comparable, HashableDictionary<Key,Value>.Index annotations, comparisons, and hashValue work through MiniSwift's Int-backed surrogate; opaque identity, invalid-index validation, and full view integration remain shallow.struct Iterator : IteratorProtocolfunc makeIterator() -> Iteratorfunc index(forKey key: Key) -> Index?Dictionary.Index and index-based subscript remain shallow.func index(after i: Index) -> Indexfunc formIndex(after i: inout Index)var startIndex: Index / var endIndex: Index { get }0 and count); enough for smoke iteration, but not a real opaque Dictionary.Index.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) rethrowsmutating 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; 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) -> Boolvar 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)func hash(into:) ; var hashValue: Intfunc sorted() -> [Element]func min() -> Element? ; func max() -> Element?func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> Set<Element>Set<Int>.filter is verified native + WASM; broader element types / throwing closures are not exhaustively checked.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 native/WASM; broader method chains, mutation through chains, 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?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)/nil in wasm/native. Pointer/string payloads and broader reflection-backed debug output remain shallow.String(describing: opt) / "\(opt)"String(describing:) works for primitive Optional payloads (Optional(5)/nil verified); interpolation and pointer/string Optional payloads remain 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?) 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>.self, from:) into an explicit Int? supports numeric/null top-level JSON; full Decoder/container semantics 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:)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) }var startIndex/endIndex: ClosedRange.Index { get }func index(after/before:)/(_:offsetBy:) -> Indexfunc distance(from: Index, to: Index) -> Intsubscript(position: Index) -> Bound { get }static func ==; hash(into:); hashValuevar 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?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 UnboundedRangestatic 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: _Pointerfunc stride<T>(from: T, to: T, by: T.Stride) -> StrideTo<T> where T: Strideablefunc stride<T>(from: T, through: T, by: T.Stride) -> StrideThrough<T> where T: Strideable@frozen struct StrideTo<Element: Strideable>: Sequencefunc makeIterator() -> StrideToIterator; var underestimatedCount: Intmutating func next() -> Element?@frozen struct StrideThrough<Element: Strideable>: Sequencefunc makeIterator() -> StrideThroughIterator; var underestimatedCount: Intmutating func next() -> Element?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?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]func flatMap<R>(_ transform: (Element) throws -> R?) rethrows -> [R]func reduce<R>(_ initial: R, _ next: (R, Element) throws -> R) rethrows -> Rfunc reduce<R>(into initial: R, _ update: (inout R, Element) throws -> ()) rethrows -> Rfunc 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?func sorted() -> [Element] where Element: Comparablefunc sorted(by: (Element, Element) throws -> Bool) rethrows -> [Element]func enumerated() -> EnumeratedSequence<Self>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>: Sequencestruct EnumeratedSequence<Base>: Sequencefunc stride<T: Strideable>(from: T, to: T, by: T.Stride) -> StrideTo<T>func stride<T: Strideable>(from: T, through: T, by: T.Stride) -> StrideThrough<T>struct StrideTo<Element: Strideable>: Sequencestruct Repeated<Element>: RandomAccessCollectionrepeatElement materializes an eager array-backed collection with count/subscript/iteration support; a distinct stdlib Repeated value type is not modeled.struct CollectionOfOne<Element>; struct EmptyCollection<Element>struct IndexingIterator<Elements: Collection>: IteratorProtocolstruct 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 : ~Escapablecase success(Success)case failure(Failure)init(catching body: () throws(Failure) -> Success)if case .success = Result(catching:) fails type-check.consuming func get() throws(Failure) -> Successdo/catch and try? nil on failure in native/WASM; richer typed-throws payload semantics remain pragmatic.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!=; richer generic Equatable witness routing remains shallow.func hash(into:) ; var hashValue: InthashValue lowers from Result tag/payload for simple payloads (stable and differentiates .success(5)/.success(6)); hash(into:) and full Hashable semantics remain shallow.conditional conformancesprotocol 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)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 }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 }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 { ... }protocol KeyedEncodingContainerProtocol { ... } (+ decoding/single/unkeyed)struct CodingUserInfoKey : RawRepresentable, Hashable, Sendable { init?(rawValue: String) }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 }static func detached(priority:operation:) -> Taskstatic func sleep(nanoseconds:) async throwsstatic func sleep<C:Clock>(for:tolerance:clock:) async throwsstatic 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/await_all/free. But group.addTask + for await v in group does NOT lower → undefined symbol _withTaskGroup at link. Verified link failure for the practical pattern.func withThrowingTaskGroup<C,R>(...) async throws -> Rfunc withDiscardingTaskGroup<R>(...) async -> Rmutating func addTask(priority:operation:)mutating func next() async -> ChildTaskResult?mutating func waitForAll() asyncprotocol AsyncSequence { associatedtype Element; func makeAsyncIterator() }protocol AsyncIteratorProtocol { mutating func next() async throws -> Element? }for await over a custom async iterator not lowered.func map<T>(_ transform: @Sendable (Element) async -> T) -> AsyncMapSequencefunc filter(_ isIncluded: @Sendable (Element) async -> Bool) -> AsyncFilterSequencefunc compactMap<T>(...) -> AsyncCompactMapSequencefunc reduce<R>(_:_:) async rethrows -> Rfunc contains(_:) async rethrows -> Bool, etc.func prefix(_:) -> AsyncPrefixSequencefor await x in asyncSeq { }struct AsyncStream<Element>init(_:bufferingPolicy:_ build:(Continuation)->Void)static func makeStream(...) -> (stream, continuation)func yield(_:) -> YieldResult; func finish()struct AsyncThrowingStream<Element,Failure:Error>func withCheckedContinuation<T>(isolation:_ body:(CheckedContinuation<T,Never>)->Void) async -> Tfunc withCheckedThrowingContinuation<T>(...) async throws -> Tfunc withUnsafeContinuation<T>(_ fn:(UnsafeContinuation<T,Never>)->Void) async -> Tstruct CheckedContinuation<T,E>: Sendable { func resume(returning:)/resume(throwing:) }@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 }protocol Sendable@Sendable () -> Voidclass C: @unchecked Sendableprotocol Actor: AnyObject, Sendable { var unownedExecutor }final class TaskLocal<Value>: Sendable { init(wrappedValue:); func withValue(_:operation:) }protocol Clock<Duration>: Sendable { var now; func sleep(until:tolerance:) }struct ContinuousClock: Sendable { var now: Instant }struct SuspendingClock: Sendable { var now: Instant }protocol InstantProtocol<Duration>: Comparable,Hashable,Sendable { func advanced(by:); func duration(to:) }struct Duration: Sendable { static func seconds/milliseconds/microseconds/nanoseconds(_:) }static func + / - / * ; var components: (seconds,attoseconds)struct CancellationError: Errorfunc withUnsafeCurrentTask<T>(body:(UnsafeCurrentTask?)->T) -> Tprotocol Executor: AnyObject, Sendable { func enqueue(_:) }public class AnyKeyPath : _AppendKeyPathstatic var rootType: any Any.Type { get }static var valueType: any Any.Type { get }var hashValue: Int; func hash(into:)static func == (AnyKeyPath, AnyKeyPath) -> Boolvar debugDescription: String { get }public class PartialKeyPath<Root> : AnyKeyPathpublic class KeyPath<Root, Value> : PartialKeyPath<Root>public class WritableKeyPath<Root, Value> : KeyPath<Root, Value>public class ReferenceWritableKeyPath<Root, Value> : WritableKeyPath<Root, Value>\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)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.Typelet children: Mirror.Childrenlet displayStyle: Mirror.DisplayStyle?var superclassMirror: Mirror? { get }func descendant(_ first: MirrorPath, _ rest: MirrorPath...) -> Any?var description: String { get }var customMirror: Mirror { get }enum DisplayStyle { case struct/class/enum/tuple/optional/collection/dictionary/set/foreignReference }enum AncestorRepresentation { case generated / customized(()->Mirror) / suppressed }typealias Child=(label:String?,value:Any); typealias Children=AnyCollection<Child>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)Equatable, Comparable, Hashable, CustomDebugStringConvertiblestatic 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?func withoutActuallyEscaping<C,R,F>(_ closure: C, do body: (C) throws(F) -> R) throws(F) -> Rfunc 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 : ...@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)func initialize(from: UnsafePointer<Pointee>, count: Int)func update(repeating:count:); func update(from:count:)func move() -> Pointeefunc moveInitialize(from:count:); func moveUpdate(from:count:)@discardableResult func deinitialize(count: Int) -> UnsafeMutableRawPointerfunc 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>func moveInitializeMemory<T>(as:from:count:) -> UnsafeMutablePointer<T>func withMemoryRebound(...); func advanced(by:); func alignedUp/alignedDown(...)advanced(by:) lowers as byte-offset pointer arithmetic; withMemoryRebound and alignedUp/Down remain missing.@frozen struct UnsafeBufferPointer<Element>init(start: UnsafePointer<Element>?, count: Int); init(_: UnsafeMutableBufferPointer<Element>); init(rebasing: Slice<...>)var baseAddress: UnsafePointer<Element>? { get }; var count/isEmptysubscript(i: Int) -> Element; startIndex/endIndex/indices/index(after:)/distance(...)func makeIterator() -> UnsafeBufferPointer<Element>.Iteratorfunc withMemoryRebound<T,E,Result>(to:_:) ...func extracting(_: Range<Int>) -> UnsafeBufferPointer<Element>; var span: Span<Element>func deallocate()@frozen struct UnsafeMutableBufferPointer<Element>static func allocate(capacity: Int) -> UnsafeMutableBufferPointer<Element>init(start:count:); subscript(i: Int) -> Element { get nonmutating set }func initialize(repeating:); initialize(from:); update(repeating:); moveInitialize(fromContentsOf:); deinitialize()var baseAddress; func withMemoryRebound(...); func extracting(_:); var span@frozen struct UnsafeRawBufferPointerinit(start: UnsafeRawPointer?, count: Int); init(UnsafeMutableRawBufferPointer); init(rebasing:)var baseAddress: UnsafeRawPointer?; var count; subscript(i: Int) -> UInt8 { get }func load<T>(fromByteOffset:as:) -> T; func loadUnaligned<T>(fromByteOffset:as:) -> Tfunc bindMemory<T>(to:) -> UnsafeBufferPointer<T>; func withMemoryRebound(...)func deallocate()@frozen struct UnsafeMutableRawBufferPointerstatic func allocate(byteCount: Int, alignment: Int) -> UnsafeMutableRawBufferPointerfunc storeBytes<T>(of:toByteOffset:as:); func copyMemory(from:); func copyBytes(from:)func initializeMemory<T>(as:repeating:); func bindMemory<T>(to:)func load<T>(...); subscript(i: Int) -> UInt8 { get nonmutating set }; func deallocate()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) -> Resultfunc 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?open class ManagedBuffer<Header, Element>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...@frozen struct Unmanaged<Instance: AnyObject>static func fromOpaque(_: UnsafeRawPointer) -> Unmanaged<Instance>; func toOpaque() -> UnsafeMutableRawPointerstatic func passRetained/passUnretained(_: Instance) -> Unmanaged<Instance>func takeRetainedValue() -> Instance; func takeUnretainedValue() -> Instancefunc retain() -> Unmanaged<Instance>; func release(); func autorelease() -> Unmanaged<Instance>@frozen struct OpaquePointerhashValue, debugDescription, casts, and optional constructors are verified; hash(into:) remains partial.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 CVarArg@frozen struct CVaListPointerfunc withVaList<R>(_: [any CVarArg], _: (CVaListPointer) -> R) -> Rtypealias 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, CustomStringConvertibleprotocol SIMDScalar : BitwiseCopyable; protocol SIMDStorage@frozen struct SIMDn<Scalar: SIMDScalar> : SIMDinit(); init(_ v0:_ v1:...); init(repeating: Scalar); init(arrayLiteral: Scalar...)var scalarCount: Int; subscript(index: Int) -> Scalar; var x/y/z/w: Scalarstatic func +/-/*//(a: Self, b: Self) -> Self; &+/&-/&* wrapping; addingProduct; squareRoot; roundedstatic func &/^/|/&<</&>>(a: Self, b: Self) -> Self (+ scalar-mixed overloads)static func .==/.!=/.</.<=/.>/.>=(a: Self, b: Self/Scalar) -> SIMDMask<Self.MaskStorage>subscript<Index: FixedWidthInteger & SIMDScalar>(index: SIMDn<Index>) -> SIMDn<Scalar>func min() -> Scalar; func max() -> Scalar; func sum() -> Scalar; func wrappedSum() -> Scalarfunc replacing(with: Self/Scalar, where: SIMDMask) -> Self; func clamped(lowerBound:upperBound:) -> Selfstatic var zero/one: Self; static func random(in: Range/ClosedRange<Scalar>[, using:]) -> Self@frozen struct SIMDMask<Storage: SIMD> : SIMDstatic func .&/.| /.^(a: Self, b: Self) -> Self; prefix .!; func any()/all() via reductionsfunc 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 : Strideable_stride symbol (no real StrideTo type).func stride<T>(from start: T, through end: T, by stride: T.Stride) -> StrideThrough<T> where T : Strideablefunc 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)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) -> Rvar 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 }@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 type identity or lazy wrapper is modeled.let count: Int; let repeatedValue: Element; subscript(position: Int) -> Element { get }repeatedValue is backed by the first stored element, so the zero-count source-value semantic is not represented.@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?0 payload semantics remain unmodeled.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 }mutating func next() -> (S1.Element, S2.Element)?@frozen struct StrideTo<Element : Strideable> : Sequence; struct StrideToIterator<Element>_stride symbol when assigned).@frozen struct StrideThrough<Element : Strideable> : Sequence; struct StrideThroughIterator<Element>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 ✅).