The Swift standard library, end to end

public let globalConcurrentExecutor: any TaskExecutor { get }

public let globalConcurrentExecutor: any TaskExecutor { get }

public var globalConcurrentExecutor: any TaskExecutor { get }

public var globalConcurrentExecutor: any TaskExecutor { get }

public func != (t0: (any (~Copyable & ~Escapable).Type)?, t1: (any (~Copyable & ~Escapable).Type)?) -> Bool

@inlinable public func != <T>(lhs: T, rhs: T) -> Bool where T : RawRepresentable, T.RawValue : Equatable

@inlinable public func != <T>(lhs: T, rhs: T) -> Bool where T : Equatable, T : RawRepresentable, T.RawValue : Equatable

@inlinable public func != (lhs: (), rhs: ()) -> Bool

@inlinable public func != <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Equatable, B : Equatable

@inlinable public func != <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Equatable, B : Equatable, C : Equatable

@inlinable public func != <A, B, C, D>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable

@inlinable public func != <A, B, C, D, E>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable

@inlinable public func != <A, B, C, D, E, F>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable

@inlinable public func !== (lhs: AnyObject?, rhs: AnyObject?) -> Bool

@inlinable public func < (lhs: (), rhs: ()) -> Bool

@inlinable public func < <A, B, C, D, E, F>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable

@inlinable public func < <A, B, C, D, E>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable

@inlinable public func < <A, B, C, D>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable

@inlinable public func < <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Comparable, B : Comparable, C : Comparable

@inlinable public func < <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Comparable, B : Comparable

@inlinable public func <= (lhs: (), rhs: ()) -> Bool

@inlinable public func <= <A, B, C, D, E, F>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable

@inlinable public func <= <A, B, C, D, E>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable

@inlinable public func <= <A, B, C, D>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable

@inlinable public func <= <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Comparable, B : Comparable, C : Comparable

@inlinable public func <= <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Comparable, B : Comparable

public func == (t0: (any (~Copyable & ~Escapable).Type)?, t1: (any (~Copyable & ~Escapable).Type)?) -> Bool

@inlinable public func == <T>(lhs: T, rhs: T) -> Bool where T : RawRepresentable, T.RawValue : Equatable

@inlinable public func == (lhs: (), rhs: ()) -> Bool

@inlinable public func == <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Equatable, B : Equatable

@inlinable public func == <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Equatable, B : Equatable, C : Equatable

@inlinable public func == <A, B, C, D>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable

@inlinable public func == <A, B, C, D, E>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable

@inlinable public func == <A, B, C, D, E, F>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable

@inlinable public func === (lhs: AnyObject?, rhs: AnyObject?) -> Bool

@inlinable public func > (lhs: (), rhs: ()) -> Bool

@inlinable public func > <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Comparable, B : Comparable

@inlinable public func > <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Comparable, B : Comparable, C : Comparable

@inlinable public func > <A, B, C, D>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable

@inlinable public func > <A, B, C, D, E>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable

@inlinable public func > <A, B, C, D, E, F>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable

@inlinable public func >= (lhs: (), rhs: ()) -> Bool

@inlinable public func >= <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Comparable, B : Comparable

@inlinable public func >= <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Comparable, B : Comparable, C : Comparable

@inlinable public func >= <A, B, C, D>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable

@inlinable public func >= <A, B, C, D, E>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable

@inlinable public func >= <A, B, C, D, E, F>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool where A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable

public func ?? <T>(optional: consuming T?, defaultValue: @autoclosure () throws -> T) rethrows -> T where T : ~Copyable

public func ?? <T>(optional: consuming T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T? where T : ~Copyable

@inlinable public func abs<T>(_ x: T) -> T where T : Comparable, T : SignedNumeric

public func all<Storage>(_ mask: SIMDMask<Storage>) -> Bool where Storage : SIMD, Storage.Scalar : FixedWidthInteger, Storage.Scalar : SignedInteger

public func any<Storage>(_ mask: SIMDMask<Storage>) -> Bool where Storage : SIMD, Storage.Scalar : FixedWidthInteger, Storage.Scalar : SignedInteger

public func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line)

public func assertionFailure(_ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line)

public func async<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async throws -> Success) -> Task<Success, any Error> where Success : Sendable

public func async<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async -> Success) -> Task<Success, Never> where Success : Sendable

public func async<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async -> Success) -> Task<Success, Never> where Success : Sendable

public func async<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async throws -> Success) -> Task<Success, any Error> where Success : Sendable

public func asyncDetached<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async -> Success) -> Task<Success, Never> where Success : Sendable

public func asyncDetached<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async throws -> Success) -> Task<Success, any Error> where Success : Sendable

public func asyncDetached<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async -> Success) -> Task<Success, Never> where Success : Sendable

public func asyncDetached<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async throws -> Success) -> Task<Success, any Error> where Success : Sendable

public func debugPrint(_ items: Any..., separator: String = " ", terminator: String = "\n")

public func debugPrint<Target>(_ items: Any..., separator: String = " ", terminator: String = "\n", to output: inout Target) where Target : TextOutputStream

public func detach<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async -> Success) -> Task<Success, Never> where Success : Sendable

public func detach<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async throws -> Success) -> Task<Success, any Error> where Success : Sendable

public func detach<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async -> Success) -> Task<Success, Never> where Success : Sendable

public func detach<Success>(priority: TaskPriority? = nil, operation: @escaping @isolated(any) @Sendable () async throws -> Success) -> Task<Success, any Error> where Success : Sendable

public func dump<T, TargetStream>(_ value: T, to target: inout TargetStream, name: String? = nil, indent: Int = 0, maxDepth: Int = .max, maxItems: Int = .max) -> T where TargetStream : TextOutputStream

public func dump<T>(_ value: T, name: String? = nil, indent: Int = 0, maxDepth: Int = .max, maxItems: Int = .max) -> T

public func exchange<T>(_ item: inout T, with newValue: consuming T) -> T where T : ~Copyable

public func extendLifetime<T>(_ x: borrowing T) where T : ~Copyable, T : ~Escapable

public func extractIsolation<each Arg, Result>(_ fn: @escaping @isolated(any) (repeat each Arg) async throws -> Result) -> (any Actor)?

public func extractIsolation<each Arg, Result>(_ fn: @escaping @isolated(any) (repeat each Arg) async throws -> Result) -> (any Actor)?

public func fatalError(_ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line) -> Never

@inlinable public func getVaList(_ args: [any CVarArg]) -> CVaListPointer

@inlinable public func isKnownUniquelyReferenced<T>(_ object: inout T) -> Bool where T : AnyObject

@inlinable public func isKnownUniquelyReferenced<T>(_ object: inout T?) -> Bool where T : AnyObject

@inlinable public func max<T>(_ x: T, _ y: T) -> T where T : Comparable

@inlinable public func max<T>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T where T : Comparable

@inlinable public func min<T>(_ x: T, _ y: T) -> T where T : Comparable

@inlinable public func min<T>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T where T : Comparable

@inlinable public func numericCast<T, U>(_ x: T) -> U where T : BinaryInteger, U : BinaryInteger

public func pointwiseMax<T>(_ a: T, _ b: T) -> T where T : SIMD, T.Scalar : Comparable

public func pointwiseMax<T>(_ a: T, _ b: T) -> T where T : SIMD, T.Scalar : FloatingPoint

public func pointwiseMin<T>(_ a: T, _ b: T) -> T where T : SIMD, T.Scalar : Comparable

public func pointwiseMin<T>(_ a: T, _ b: T) -> T where T : SIMD, T.Scalar : FloatingPoint

public func precondition(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line)

public func preconditionFailure(_ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line) -> Never

public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")

public func print<Target>(_ items: Any..., separator: String = " ", terminator: String = "\n", to output: inout Target) where Target : TextOutputStream

public func readLine(strippingNewline: Bool = true) -> String?

@inlinable public func repeatElement<T>(_ element: T, count n: Int) -> Repeated<T>

@inlinable public func sequence<T>(first: T, next: @escaping (T) -> T?) -> UnfoldFirstSequence<T>

@inlinable public func sequence<T, State>(state: State, next: @escaping (inout State) -> T?) -> UnfoldSequence<T, State>

@inlinable public func stride<T>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> where T : Strideable

@inlinable public func stride<T>(from start: T, through end: T, by stride: T.Stride) -> StrideThrough<T> where T : Strideable

@inlinable public func swap<T>(_ a: inout T, _ b: inout T) where T : ~Copyable

@inlinable public func transcode<Input, InputEncoding, OutputEncoding>(_ input: Input, from inputEncoding: InputEncoding.Type, to outputEncoding: OutputEncoding.Type, stoppingOnError stopOnError: Bool, into processCodeUnit: (OutputEncoding.CodeUnit) -> Void) -> Bool where Input : IteratorProtocol, InputEncoding : _UnicodeEncoding, OutputEncoding : _UnicodeEncoding, Input.Element == InputEncoding.CodeUnit

public func type<T, Metatype>(of value: borrowing T) -> Metatype where T : ~Copyable, T : ~Escapable

@inlinable public func unsafeBitCast<T, U>(_ x: T, to type: U.Type) -> U

public func unsafeDowncast<T>(_ x: AnyObject, to type: T.Type) -> T where T : AnyObject

@inlinable public func withCheckedContinuation<T>(isolation: isolated (any Actor)?, function: String = #function, _ body: (CheckedContinuation<T, Never>) -> Void) async -> sending T

@inlinable public func withCheckedContinuation<T>(isolation: isolated (any Actor)? = #isolation, function: String = #function, _ body: (CheckedContinuation<T, Never>) -> Void) async -> sending T

@inlinable public func withCheckedThrowingContinuation<T>(isolation: isolated (any Actor)?, function: String = #function, _ body: (CheckedContinuation<T, any Error>) -> Void) async throws -> sending T

@inlinable public func withCheckedThrowingContinuation<T>(isolation: isolated (any Actor)? = #isolation, function: String = #function, _ body: (CheckedContinuation<T, any Error>) -> Void) async throws -> sending T

@inlinable public func withDiscardingTaskGroup<GroupResult>(returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any Actor)? = #isolation, body: (inout DiscardingTaskGroup) async -> GroupResult) async -> GroupResult

@inlinable public func withDiscardingTaskGroup<GroupResult>(returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any Actor)? = #isolation, body: (inout DiscardingTaskGroup) async -> GroupResult) async -> GroupResult

public func withExtendedLifetime<T, E, Result>(_ x: borrowing T, _ body: () throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, T : ~Escapable, Result : ~Copyable

public func withExtendedLifetime<T, E, Result>(_ x: borrowing T, _ body: (borrowing T) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, T : ~Escapable, Result : ~Copyable

public func withTaskCancellationHandler<T>(handler: @Sendable () -> Void, operation: () async throws -> T) async rethrows -> T

public func withTaskCancellationHandler<T>(operation: () async throws -> T, onCancel handler: @Sendable () -> Void, isolation: isolated (any Actor)?) async rethrows -> T

public func withTaskCancellationHandler<T>(handler: @Sendable () -> Void, operation: () async throws -> T) async rethrows -> T

public func withTaskCancellationHandler<T>(operation: () async throws -> T, onCancel handler: @Sendable () -> Void, isolation: isolated (any Actor)? = #isolation) async rethrows -> T

public func withTaskCancellationShield<Value, Failure>(operation: () throws(Failure) -> Value) throws(Failure) -> Value where Failure : Error

public func withTaskExecutorPreference<T, Failure>(_ taskExecutor: (any TaskExecutor)?, isolation: isolated (any Actor)? = #isolation, operation: () async throws(Failure) -> T) async throws(Failure) -> T where Failure : Error

public func withTaskExecutorPreference<T, Failure>(_ taskExecutor: (any TaskExecutor)?, isolation: isolated (any Actor)? = #isolation, operation: () async throws(Failure) -> T) async throws(Failure) -> T where Failure : Error

@inlinable public func withTaskGroup<ChildTaskResult, GroupResult>(of childTaskResultType: ChildTaskResult.Type = ChildTaskResult.self, returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any Actor)? = #isolation, body: (inout TaskGroup<ChildTaskResult>) async -> GroupResult) async -> GroupResult where ChildTaskResult : Sendable

@inlinable public func withTaskGroup<ChildTaskResult, GroupResult>(of childTaskResultType: ChildTaskResult.Type = ChildTaskResult.self, returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any Actor)? = #isolation, body: (inout TaskGroup<ChildTaskResult>) async -> GroupResult) async -> GroupResult where ChildTaskResult : Sendable

@inlinable public func withThrowingDiscardingTaskGroup<GroupResult>(returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any Actor)? = #isolation, body: (inout ThrowingDiscardingTaskGroup<any Error>) async throws -> GroupResult) async throws -> GroupResult

@inlinable public func withThrowingDiscardingTaskGroup<GroupResult>(returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any Actor)? = #isolation, body: (inout ThrowingDiscardingTaskGroup<any Error>) async throws -> GroupResult) async throws -> GroupResult

@inlinable public func withThrowingTaskGroup<ChildTaskResult, GroupResult>(of childTaskResultType: ChildTaskResult.Type = ChildTaskResult.self, returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any Actor)? = #isolation, body: (inout ThrowingTaskGroup<ChildTaskResult, any Error>) async throws -> GroupResult) async rethrows -> GroupResult where ChildTaskResult : Sendable

@inlinable public func withThrowingTaskGroup<ChildTaskResult, GroupResult>(of childTaskResultType: ChildTaskResult.Type = ChildTaskResult.self, returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any Actor)? = #isolation, body: (inout ThrowingTaskGroup<ChildTaskResult, any Error>) async throws -> GroupResult) async rethrows -> GroupResult where ChildTaskResult : Sendable

public func withUnsafeBytes<T, E, Result>(of value: inout T, _ body: (UnsafeRawBufferPointer) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable

public func withUnsafeBytes<T, E, Result>(of value: borrowing T, _ body: (UnsafeRawBufferPointer) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable

public func withUnsafeContinuation<T>(isolation: isolated (any Actor)?, _ fn: (UnsafeContinuation<T, Never>) -> Void) async -> sending T

public func withUnsafeContinuation<T>(isolation: isolated (any Actor)? = #isolation, _ fn: (UnsafeContinuation<T, Never>) -> Void) async -> sending T

public func withUnsafeCurrentTask<T>(body: (UnsafeCurrentTask?) throws -> T) rethrows -> T

public func withUnsafeCurrentTask<T>(body: (UnsafeCurrentTask?) async throws -> T) async rethrows -> T

public func withUnsafeCurrentTask<T>(body: (UnsafeCurrentTask?) throws -> T) rethrows -> T

public func withUnsafeCurrentTask<T>(body: (UnsafeCurrentTask?) async throws -> T) async rethrows -> T

public func withUnsafeMutableBytes<T, E, Result>(of value: inout T, _ body: (UnsafeMutableRawBufferPointer) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable

public func withUnsafeMutablePointer<T, E, Result>(to value: inout T, _ body: (UnsafeMutablePointer<T>) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable

public func withUnsafePointer<T, E, Result>(to value: borrowing T, _ body: (UnsafePointer<T>) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable

public func withUnsafePointer<T, E, Result>(to value: inout T, _ body: (UnsafePointer<T>) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable

public func withUnsafeTemporaryAllocation<R, E>(byteCount: Int, alignment: Int, _ body: (UnsafeMutableRawBufferPointer) throws(E) -> R) throws(E) -> R where E : Error, R : ~Copyable

public func withUnsafeTemporaryAllocation<T, R, E>(of type: T.Type, capacity: Int, _ body: (UnsafeMutableBufferPointer<T>) throws(E) -> R) throws(E) -> R where E : Error, T : ~Copyable, R : ~Copyable

public func withUnsafeThrowingContinuation<T>(isolation: isolated (any Actor)?, _ fn: (UnsafeContinuation<T, any Error>) -> Void) async throws -> sending T

public func withUnsafeThrowingContinuation<T>(isolation: isolated (any Actor)? = #isolation, _ fn: (UnsafeContinuation<T, any Error>) -> Void) async throws -> sending T

@inlinable public func withVaList<R>(_ args: [any CVarArg], _ body: (CVaListPointer) -> R) -> R

public func withoutActuallyEscaping<ClosureType, ResultType, Failure>(_ closure: ClosureType, do body: (_ escapingClosure: ClosureType) throws(Failure) -> ResultType) throws(Failure) -> ResultType where Failure : Error

@inlinable public func zip<Sequence1, Sequence2>(_ sequence1: Sequence1, _ sequence2: Sequence2) -> Zip2Sequence<Sequence1, Sequence2> where Sequence1 : Sequence, Sequence2 : Sequence

public func ~= <T>(a: T, b: T) -> Bool where T : Equatable

public typealias AnyActor = AnyObject & Sendable

public typealias AnyActor = AnyObject & Sendable

public typealias AnyClass = any AnyObject.Type

public typealias AnyObject

public typealias BooleanLiteralType = Bool

public typealias CBool = Bool

public typealias CChar = Int8

public typealias CChar16 = UInt16

public typealias CChar32 = Unicode.Scalar

public typealias CChar8 = UInt8

public typealias CDouble = Double

public typealias CFloat = Float

public typealias CFloat16 = Float16

public typealias CInt = Int32

public typealias CLong = Int

public typealias CLongDouble = Double

public typealias CLongLong = Int64

public typealias CShort = Int16

public typealias CSignedChar = Int8

public typealias CUnsignedChar = UInt8

public typealias CUnsignedInt = UInt32

public typealias CUnsignedLong = UInt

public typealias CUnsignedLongLong = UInt64

public typealias CUnsignedShort = UInt16

public typealias CWideChar = Unicode.Scalar

public typealias Codable = Decodable & Encodable

public typealias ConcurrentValue = Sendable

public typealias CountableClosedRange<Bound> = ClosedRange<Bound> where Bound : Strideable, Bound.Stride : SignedInteger

public typealias CountablePartialRangeFrom<Bound> = PartialRangeFrom<Bound> where Bound : Strideable, Bound.Stride : SignedInteger

public typealias CountableRange<Bound> = Range<Bound> where Bound : Strideable, Bound.Stride : SignedInteger

public typealias DictionaryIndex<Key, Value> = Dictionary<Key, Value>.Index where Key : Hashable

public typealias DictionaryIterator<Key, Value> = Dictionary<Key, Value>.Iterator where Key : Hashable

public typealias DictionaryLiteral<Key, Value> = KeyValuePairs<Key, Value>

public typealias EnumeratedIterator<T> = EnumeratedSequence<T>.Iterator where T : Sequence

public typealias ExtendedGraphemeClusterType = String

public typealias FlattenCollection<T> = FlattenSequence<T> where T : Collection, T.Element : Collection

public typealias Float32 = Float

public typealias Float64 = Double

public typealias FloatLiteralType = Double

public typealias IntegerLiteralType = Int

public typealias LazyCollection<T> = LazySequence<T> where T : Collection

public typealias LazyDropWhileCollection<T> = LazyDropWhileSequence<T> where T : Collection

public typealias LazyFilterCollection<T> = LazyFilterSequence<T> where T : Collection

public typealias LazyMapCollection<T, U> = LazyMapSequence<T, U> where T : Collection

public typealias LazyPrefixWhileCollection<T> = LazyPrefixWhileSequence<T> where T : Collection

public typealias PartialAsyncTask = UnownedJob

public typealias PartialAsyncTask = UnownedJob

public typealias PlaygroundQuickLook

public typealias SetIndex<Element> = Set<Element>.Index where Element : Hashable

public typealias SetIterator<Element> = Set<Element>.Iterator where Element : Hashable

public typealias StringLiteralType = String

public typealias UTF16 = Unicode.UTF16

public typealias UTF32 = Unicode.UTF32

public typealias UTF8 = Unicode.UTF8

public typealias UnboundedRange = (UnboundedRange_) -> ()

public typealias UnfoldFirstSequence<T> = UnfoldSequence<T, (T?, Bool)>

public typealias UnicodeScalar = Unicode.Scalar

public typealias UnicodeScalarType = String

public typealias UnsafeConcurrentValue = UnsafeSendable

public typealias UnsafeThrowingContinuation<T> = UnsafeContinuation<T, any Error>

public typealias UnsafeThrowingContinuation<T> = UnsafeContinuation<T, any Error>

public typealias Void = ()

prefix operator !

infix operator != : ComparisonPrecedence

infix operator !== : ComparisonPrecedence

infix operator % : MultiplicationPrecedence

infix operator %= : AssignmentPrecedence

infix operator & : MultiplicationPrecedence

infix operator && : LogicalConjunctionPrecedence

infix operator &* : MultiplicationPrecedence

infix operator &*= : AssignmentPrecedence

infix operator &+ : AdditionPrecedence

infix operator &+= : AssignmentPrecedence

infix operator &- : AdditionPrecedence

infix operator &-= : AssignmentPrecedence

infix operator &<< : BitwiseShiftPrecedence

infix operator &<<= : AssignmentPrecedence

infix operator &= : AssignmentPrecedence

infix operator &>> : BitwiseShiftPrecedence

infix operator &>>= : AssignmentPrecedence

infix operator * : MultiplicationPrecedence

infix operator *= : AssignmentPrecedence

prefix operator +

infix operator + : AdditionPrecedence

prefix operator ++

postfix operator ++

infix operator += : AssignmentPrecedence

prefix operator -

infix operator - : AdditionPrecedence

prefix operator --

postfix operator --

infix operator -= : AssignmentPrecedence

prefix operator .!

infix operator .!= : ComparisonPrecedence

infix operator .& : LogicalConjunctionPrecedence

infix operator .&= : AssignmentPrecedence

prefix operator ...

postfix operator ...

infix operator ... : RangeFormationPrecedence

prefix operator ..<

infix operator ..< : RangeFormationPrecedence

infix operator .< : ComparisonPrecedence

infix operator .<= : ComparisonPrecedence

infix operator .== : ComparisonPrecedence

infix operator .> : ComparisonPrecedence

infix operator .>= : ComparisonPrecedence

infix operator .^ : LogicalDisjunctionPrecedence

infix operator .^= : AssignmentPrecedence

infix operator .| : LogicalDisjunctionPrecedence

infix operator .|= : AssignmentPrecedence

infix operator / : MultiplicationPrecedence

infix operator /= : AssignmentPrecedence

infix operator < : ComparisonPrecedence

infix operator << : BitwiseShiftPrecedence

infix operator <<= : AssignmentPrecedence

infix operator <= : ComparisonPrecedence

infix operator == : ComparisonPrecedence

infix operator === : ComparisonPrecedence

infix operator > : ComparisonPrecedence

infix operator >= : ComparisonPrecedence

infix operator >> : BitwiseShiftPrecedence

infix operator >>= : AssignmentPrecedence

infix operator ?? : NilCoalescingPrecedence

infix operator ^ : AdditionPrecedence

infix operator ^= : AssignmentPrecedence

infix operator | : AdditionPrecedence

infix operator |= : AssignmentPrecedence

infix operator || : LogicalDisjunctionPrecedence

prefix operator ~

infix operator ~= : ComparisonPrecedence

infix operator ~> : DefaultPrecedence

precedencegroup AdditionPrecedence

precedencegroup AssignmentPrecedence

precedencegroup BitwiseShiftPrecedence

precedencegroup CastingPrecedence

precedencegroup ComparisonPrecedence

precedencegroup DefaultPrecedence

precedencegroup FunctionArrowPrecedence

precedencegroup LogicalConjunctionPrecedence

precedencegroup LogicalDisjunctionPrecedence

precedencegroup MultiplicationPrecedence

precedencegroup NilCoalescingPrecedence

precedencegroup RangeFormationPrecedence

precedencegroup TernaryPrecedence