Binary Moduleswift 6.1.2Swift
Swift
import SwiftModule information
- Declarations
- 6459
- Symbols
- 13578
import Swiftfunc abs<T>(_ x: T) -> T where T : Comparable, T : SignedNumeric Returns the absolute value of the given number.
func all<Storage>(_ mask: SIMDMask<Storage>) -> Bool where Storage : SIMD, Storage.Scalar : FixedWidthInteger, Storage.Scalar : SignedInteger True if every lane of mask is true.
func any<Storage>(_ mask: SIMDMask<Storage>) -> Bool where Storage : SIMD, Storage.Scalar : FixedWidthInteger, Storage.Scalar : SignedInteger True if any lane of mask is true.
func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line) Performs a traditional C-style assert with an optional message.
func assertionFailure(_ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line) Indicates that an internal consistency check failed.
func debugPrint(_ items: Any..., separator: String = " ", terminator: String = "\n") Writes the textual representations of the given items most suitable for debugging into the standard output.
func debugPrint<Target>(_ items: Any..., separator: String = " ", terminator: String = "\n", to output: inout Target) where Target : TextOutputStream Writes the textual representations of the given items most suitable for debugging into the given output stream.
@discardableResult func dump<T>(_ value: T, name: String? = nil, indent: Int = 0, maxDepth: Int = .max, maxItems: Int = .max) -> T Dumps the given object’s contents using its mirror to standard output.
@discardableResult 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 Dumps the given object’s contents using its mirror to the specified output stream.
func exchange<T>(_ item: inout T, with newValue: consuming T) -> T where T : ~Copyable Replaces the value of a mutable value with the supplied new value, returning the original.
func fatalError(_ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line) -> Never Unconditionally prints a given message and stops execution.
func isKnownUniquelyReferenced<T>(_ object: inout T?) -> Bool where T : AnyObject Returns a Boolean value indicating whether the given object is known to have a single strong reference.
func isKnownUniquelyReferenced<T>(_ object: inout T) -> Bool where T : AnyObject Returns a Boolean value indicating whether the given object is known to have a single strong reference.
func max<T>(_ x: T, _ y: T) -> T where T : Comparable Returns the greater of two comparable values.
func max<T>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T where T : Comparable Returns the greatest argument passed.
func min<T>(_ x: T, _ y: T) -> T where T : Comparable Returns the lesser of two comparable values.
func min<T>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T where T : Comparable Returns the least argument passed.
func numericCast<T, U>(_ x: T) -> U where T : BinaryInteger, U : BinaryInteger Returns the given integer as the equivalent value in a different integer type.
func pointwiseMax<T>(_ a: T, _ b: T) -> T where T : SIMD, T.Scalar : FloatingPoint The lanewise maximum of two vectors.
func pointwiseMax<T>(_ a: T, _ b: T) -> T where T : SIMD, T.Scalar : Comparable The lanewise maximum of two vectors.
func pointwiseMin<T>(_ a: T, _ b: T) -> T where T : SIMD, T.Scalar : FloatingPoint The lanewise minimum of two vectors.
func pointwiseMin<T>(_ a: T, _ b: T) -> T where T : SIMD, T.Scalar : Comparable The lanewise minimum of two vectors.
func precondition(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line) Checks a necessary condition for making forward progress.
func preconditionFailure(_ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line) -> Never Indicates that a precondition was violated.
func print(_ items: Any..., separator: String = " ", terminator: String = "\n") Writes the textual representations of the given items into the standard output.
func print<Target>(_ items: Any..., separator: String = " ", terminator: String = "\n", to output: inout Target) where Target : TextOutputStream Writes the textual representations of the given items into the given output stream.
func readLine(strippingNewline: Bool = true) -> String? Returns a string read from standard input through the end of the current line or until EOF is reached.
func repeatElement<T>(_ element: T, count n: Int) -> Repeated<T> Creates a collection containing the specified number of the given element.
func sequence<T>(first: T, next: @escaping (T) -> T?) -> UnfoldFirstSequence<T> Returns a sequence formed from first and repeated lazy applications of next.
func sequence<T, State>(state: State, next: @escaping (inout State) -> T?) -> UnfoldSequence<T, State> Returns a sequence formed from repeated lazy applications of next to a mutable state.
func stride<T>(from start: T, through end: T, by stride: T.Stride) -> StrideThrough<T> where T : Strideable Returns a sequence from a starting value toward, and possibly including, an end value, stepping by the specified amount.
func stride<T>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> where T : Strideable Returns a sequence from a starting value to, but not including, an end value, stepping by the specified amount.
func swap<T>(_ a: inout T, _ b: inout T) where T : ~Copyable Exchanges the values of the two arguments.
func swift_unboxFromSwiftValueWithType<T>(_ source: inout AnyObject, _ result: UnsafeMutablePointer<T>) -> Bool 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 Translates the given input from one Unicode encoding to another by calling the given closure.
func type<T, Metatype>(of value: T) -> Metatype Returns the dynamic type of a value.
func unsafeBitCast<T, U>(_ x: T, to type: U.Type) -> U Returns the bits of the given instance, interpreted as having the specified type.
func unsafeDowncast<T>(_ x: AnyObject, to type: T.Type) -> T where T : AnyObject Returns the given instance cast unconditionally to the specified type.
func withExtendedLifetime<T, E, Result>(_ x: borrowing T, _ body: (borrowing T) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable Evaluates a closure while ensuring that the given instance is not destroyed before the closure returns.
func withExtendedLifetime<T, E, Result>(_ x: borrowing T, _ body: () throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable Evaluates a closure while ensuring that the given instance is not destroyed before the closure returns.
func withUnsafeBytes<T, E, Result>(of value: borrowing T, _ body: (UnsafeRawBufferPointer) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable Invokes the given closure with a buffer pointer covering the raw bytes of the given argument.
func withUnsafeBytes<T, E, Result>(of value: inout T, _ body: (UnsafeRawBufferPointer) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable Invokes the given closure with a buffer pointer covering the raw bytes of the given argument.
func withUnsafeMutableBytes<T, E, Result>(of value: inout T, _ body: (UnsafeMutableRawBufferPointer) throws(E) -> Result) throws(E) -> Result where E : Error, T : ~Copyable, Result : ~Copyable Invokes the given closure with a mutable buffer pointer covering the raw bytes of the given argument.
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 Calls the given closure with a mutable pointer to the given argument.
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 Invokes the given closure with a pointer to the given argument.
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 Invokes the given closure with a pointer to the given argument.
func withUnsafeTemporaryAllocation<R>(byteCount: Int, alignment: Int, _ body: (UnsafeMutableRawBufferPointer) throws -> R) rethrows -> R where R : ~Copyable Provides scoped access to a raw buffer pointer with the specified byte count and alignment.
func withUnsafeTemporaryAllocation<T, R>(of type: T.Type, capacity: Int, _ body: (UnsafeMutableBufferPointer<T>) throws -> R) rethrows -> R where T : ~Copyable, R : ~Copyable Provides scoped access to a buffer pointer to memory of the specified type and with the specified capacity.
func withVaList<R>(_ args: [any CVarArg], _ body: (CVaListPointer) -> R) -> R Invokes the given closure with a C va_list argument derived from the given array of arguments.
func withoutActuallyEscaping<ClosureType, ResultType, Failure>(_ closure: ClosureType, do body: (ClosureType) throws(Failure) -> ResultType) throws(Failure) -> ResultType where Failure : Error Allows a nonescaping closure to temporarily be used as if it were allowed to escape.
func zip<Sequence1, Sequence2>(_ sequence1: Sequence1, _ sequence2: Sequence2) -> Zip2Sequence<Sequence1, Sequence2> where Sequence1 : Sequence, Sequence2 : Sequence Creates a sequence of pairs built out of two underlying sequences.
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 Returns a Boolean value indicating whether any corresponding components of the two tuples are not equal.
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 Returns a Boolean value indicating whether any corresponding components of the two tuples are not equal.
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 Returns a Boolean value indicating whether any corresponding components of the two tuples are not equal.
func != <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Equatable, B : Equatable, C : Equatable Returns a Boolean value indicating whether any corresponding components of the two tuples are not equal.
func != <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Equatable, B : Equatable Returns a Boolean value indicating whether any corresponding components of the two tuples are not equal.
func != <T>(lhs: T, rhs: T) -> Bool where T : Equatable, T : RawRepresentable, T.RawValue : Equatable Returns a Boolean value indicating whether the two arguments are not equal.
func != <T>(lhs: T, rhs: T) -> Bool where T : RawRepresentable, T.RawValue : Equatable Returns a Boolean value indicating whether the two arguments are not equal.
func != (t0: (any Any.Type)?, t1: (any Any.Type)?) -> Bool Returns a Boolean value indicating whether two types are not identical.
func != (lhs: (), rhs: ()) -> Bool Returns a Boolean value indicating whether any corresponding components of the two tuples are not equal.
func !== (lhs: AnyObject?, rhs: AnyObject?) -> Bool 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 Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.
func < <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Comparable, B : Comparable, C : Comparable Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.
func < <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Comparable, B : Comparable Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.
func < (lhs: (), rhs: ()) -> Bool Returns a Boolean value indicating whether the first tuple is ordered before the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the first tuple is ordered before or the same as the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the first tuple is ordered before or the same as the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the first tuple is ordered before or the same as the second in a lexicographical ordering.
func <= <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Comparable, B : Comparable, C : Comparable Returns a Boolean value indicating whether the first tuple is ordered before or the same as the second in a lexicographical ordering.
func <= <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Comparable, B : Comparable Returns a Boolean value indicating whether the first tuple is ordered before or the same as the second in a lexicographical ordering.
func <= (lhs: (), rhs: ()) -> Bool Returns a Boolean value indicating whether the first tuple is ordered before or the same as the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the corresponding components of two tuples are equal.
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 Returns a Boolean value indicating whether the corresponding components of two tuples are equal.
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 Returns a Boolean value indicating whether the corresponding components of two tuples are equal.
func == <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Equatable, B : Equatable, C : Equatable Returns a Boolean value indicating whether the corresponding components of two tuples are equal.
func == <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Equatable, B : Equatable Returns a Boolean value indicating whether the corresponding components of two tuples are equal.
func == <T>(lhs: T, rhs: T) -> Bool where T : RawRepresentable, T.RawValue : Equatable Returns a Boolean value indicating whether the two arguments are equal.
func == (t0: (any Any.Type)?, t1: (any Any.Type)?) -> Bool Returns a Boolean value indicating whether two types are identical.
func == (lhs: (), rhs: ()) -> Bool Returns a Boolean value indicating whether the corresponding components of two tuples are equal.
func === (lhs: AnyObject?, rhs: AnyObject?) -> Bool 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 Returns a Boolean value indicating whether the first tuple is ordered after the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the first tuple is ordered after the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the first tuple is ordered after the second in a lexicographical ordering.
func > <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Comparable, B : Comparable, C : Comparable Returns a Boolean value indicating whether the first tuple is ordered after the second in a lexicographical ordering.
func > <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Comparable, B : Comparable Returns a Boolean value indicating whether the first tuple is ordered after the second in a lexicographical ordering.
func > (lhs: (), rhs: ()) -> Bool Returns a Boolean value indicating whether the first tuple is ordered after the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the first tuple is ordered after or the same as the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the first tuple is ordered after or the same as the second in a lexicographical ordering.
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 Returns a Boolean value indicating whether the first tuple is ordered after or the same as the second in a lexicographical ordering.
func >= <A, B, C>(lhs: (A, B, C), rhs: (A, B, C)) -> Bool where A : Comparable, B : Comparable, C : Comparable Returns a Boolean value indicating whether the first tuple is ordered after or the same as the second in a lexicographical ordering.
func >= <A, B>(lhs: (A, B), rhs: (A, B)) -> Bool where A : Comparable, B : Comparable Returns a Boolean value indicating whether the first tuple is ordered after or the same as the second in a lexicographical ordering.
func >= (lhs: (), rhs: ()) -> Bool Returns a Boolean value indicating whether the first tuple is ordered after or the same as the second in a lexicographical ordering.
func ?? <T>(optional: consuming T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T? where T : ~Copyable Performs a nil-coalescing operation, returning the wrapped value of an Optional instance or a default Optional value.
func ?? <T>(optional: consuming T?, defaultValue: @autoclosure () throws -> T) rethrows -> T where T : ~Copyable Performs a nil-coalescing operation, returning the wrapped value of an Optional instance or a default value.
func ~= <T>(a: T, b: T) -> Bool where T : Equatable Returns a Boolean value indicating whether two arguments match by value equality.
protocol AdditiveArithmetic : EquatableA type with values that support addition and subtraction.
protocol BidirectionalCollection<Element> : Collection where Self.Indices : BidirectionalCollection, Self.SubSequence : BidirectionalCollectionA collection that supports backward as well as forward traversal.
protocol BinaryFloatingPoint : ExpressibleByFloatLiteral, FloatingPointA radix-2 (binary) floating-point type.
protocol BinaryInteger : CustomStringConvertible, Hashable, Numeric, Strideable where Self.Magnitude : BinaryInteger, Self.Magnitude == Self.Magnitude.MagnitudeAn integer type with a binary representation.
protocol BitwiseCopyable : ~Escapableprotocol CVarArgA type whose instances can be encoded, and appropriately passed, as elements of a C va_list.
protocol CaseIterableA type that provides a collection of all of its values.
protocol CodingKey : CustomDebugStringConvertible, CustomStringConvertible, SendableA type that can be used as a key for encoding and decoding.
protocol CodingKeyRepresentableA type that can be converted to and from a coding key.
protocol Collection<Element> : SequenceA sequence whose elements can be traversed multiple times, nondestructively, and accessed by an indexed subscript.
protocol Comparable : EquatableA type that can be compared using the relational operators <, <=, >=, and >.
protocol CopyableA type whose values can be implicitly or explicitly copied.
protocol CustomDebugStringConvertibleA type with a customized textual representation suitable for debugging purposes.
protocol CustomLeafReflectable : CustomReflectableA type that explicitly supplies its own mirror, but whose descendant classes are not represented in the mirror unless they also override customMirror.
protocol CustomPlaygroundDisplayConvertibleA type that supplies a custom description for playground logging.
protocol CustomReflectableA type that explicitly supplies its own mirror.
protocol CustomStringConvertibleA type with a customized textual representation.
protocol DecodableA type that can decode itself from an external representation.
protocol DecoderA type that can decode values from a native format into in-memory representations.
protocol DurationProtocol : AdditiveArithmetic, Comparable, SendableA type that defines a duration for a given InstantProtocol type.
protocol EncodableA type that can encode itself to an external representation.
protocol EncoderA type that can encode values into a native format for external representation.
protocol EquatableA type that can be compared for value equality.
protocol Error : SendableA type representing an error value that can be thrown.
protocol Escapableprotocol ExpressibleByArrayLiteralA type that can be initialized using an array literal.
protocol ExpressibleByBooleanLiteralA type that can be initialized with the Boolean literals true and false.
protocol ExpressibleByDictionaryLiteralA type that can be initialized using a dictionary literal.
protocol ExpressibleByExtendedGraphemeClusterLiteral : ExpressibleByUnicodeScalarLiteralA type that can be initialized with a string literal containing a single extended grapheme cluster.
protocol ExpressibleByFloatLiteralA type that can be initialized with a floating-point literal.
protocol ExpressibleByIntegerLiteralA type that can be initialized with an integer literal.
protocol ExpressibleByNilLiteral : ~CopyableA type that can be initialized using the nil literal, nil.
protocol ExpressibleByStringInterpolation : ExpressibleByStringLiteralA type that can be initialized by string interpolation with a string literal that includes expressions.
protocol ExpressibleByStringLiteral : ExpressibleByExtendedGraphemeClusterLiteralA type that can be initialized with a string literal.
protocol ExpressibleByUnicodeScalarLiteralA type that can be initialized with a string literal containing a single Unicode scalar value.
protocol FixedWidthInteger : BinaryInteger, LosslessStringConvertible where Self.Magnitude : FixedWidthInteger, Self.Magnitude : UnsignedInteger, Self.Stride : FixedWidthInteger, Self.Stride : SignedIntegerAn integer type that uses a fixed size for every instance.
protocol FloatingPoint : Hashable, SignedNumeric, Strideable where Self == Self.MagnitudeA floating-point numeric type.
protocol Hashable : EquatableA type that can be hashed into a Hasher to produce an integer hash value.
protocol Identifiable<ID>A class of types whose instances hold the value of an entity with stable identity.
protocol InstantProtocol<Duration> : Comparable, Hashable, Sendableprotocol IteratorProtocol<Element>A type that supplies the values of a sequence one at a time.
protocol KeyedDecodingContainerProtocolA type that provides a view into a decoder’s storage and is used to hold the encoded properties of a decodable type in a keyed manner.
protocol KeyedEncodingContainerProtocolA type that provides a view into an encoder’s storage and is used to hold the encoded properties of an encodable type in a keyed manner.
protocol LazyCollectionProtocol : Collection, LazySequenceProtocol where Self.Elements : Collectionprotocol LazySequenceProtocol : SequenceA sequence on which normally-eager sequence operations are implemented lazily.
protocol LosslessStringConvertible : CustomStringConvertibleA type that can be represented as a string in a lossless, unambiguous way.
protocol MirrorPathA protocol for legitimate arguments to Mirror’s descendant method.
protocol MutableCollection<Element> : Collection where Self.SubSequence : MutableCollectionA collection that supports subscript assignment.
protocol Numeric : AdditiveArithmetic, ExpressibleByIntegerLiteralA type with values that support multiplication.
protocol OptionSet : RawRepresentable, SetAlgebraA type that presents a mathematical set interface to a bit set.
protocol RandomAccessCollection<Element> : BidirectionalCollection where Self.Indices : RandomAccessCollection, Self.SubSequence : RandomAccessCollectionA collection that supports efficient random-access index traversal.
protocol RandomNumberGeneratorA type that provides uniformly distributed random data.
protocol RangeExpression<Bound>A type that can be used to slice a collection.
protocol RangeReplaceableCollection<Element> : Collection where Self.SubSequence : RangeReplaceableCollectionA collection that supports replacement of an arbitrary subrange of elements with the elements of another collection.
protocol RawRepresentable<RawValue>A type that can be converted to and from an associated raw value.
protocol SIMD<Scalar> : CustomStringConvertible, Decodable, Encodable, ExpressibleByArrayLiteral, Hashable, SIMDStorageA SIMD vector of a fixed number of elements.
protocol SIMDScalar : BitwiseCopyableA type that can be used as an element in a SIMD vector.
protocol SIMDStorageA type that can function as storage for a SIMD vector type.
protocol SendableA thread-safe type whose values can be shared across arbitrary concurrent contexts without introducing a risk of data races. Values of the type may have no shared mutable state, or they may protect that state with a lock or by forcing it to only be accessed from a specific actor.
protocol Sequence<Element>A type that provides sequential, iterated access to its elements.
protocol SetAlgebra<Element> : Equatable, ExpressibleByArrayLiteralA type that provides mathematical set operations.
protocol SignedInteger : BinaryInteger, SignedNumericAn integer type that can represent both positive and negative values.
protocol SignedNumeric : NumericA numeric type with a negation operation.
protocol SingleValueDecodingContainerA container that can support the storage and direct decoding of a single nonkeyed value.
protocol SingleValueEncodingContainerA container that can support the storage and direct encoding of a single non-keyed value.
protocol Strideable<Stride> : ComparableA type representing continuous, one-dimensional values that can be offset and measured.
protocol StringInterpolationProtocolRepresents the contents of a string literal with interpolations while it’s being built up.
protocol StringProtocol : BidirectionalCollection, Comparable, ExpressibleByStringInterpolation, Hashable, LosslessStringConvertible, TextOutputStream, TextOutputStreamable where Self.Element == Character, Self.Index == String.Index, Self.StringInterpolation == DefaultStringInterpolation, Self.SubSequence : StringProtocolA type that can represent a string as a collection of characters.
protocol TextOutputStreamA type that can be the target of text-streaming operations.
protocol TextOutputStreamableA source of text-streaming operations.
protocol UnicodeCodec : _UnicodeEncodingA Unicode encoding form that translates between Unicode scalar values and form-specific code units.
protocol UnkeyedDecodingContainerA type that provides a view into a decoder’s storage and is used to hold the encoded properties of a decodable type sequentially, without keys.
protocol UnkeyedEncodingContainerA type that provides a view into an encoder’s storage and is used to hold the encoded properties of an encodable type sequentially, without keys.
protocol UnsignedInteger : BinaryIntegerAn integer type that can represent only nonnegative values.
protocol _AppendKeyPathAn implementation detail of key path expressions; do not use this protocol directly.
@frozen struct AnyBidirectionalCollection<Element>A type-erased wrapper over any collection with indices that support bidirectional traversal.
@frozen struct AnyCollection<Element>A type-erased wrapper over any collection with indices that support forward traversal.
@frozen struct AnyHashableA type-erased hashable value.
@frozen struct AnyIndexA wrapper over an underlying index that hides the specific underlying type.
@frozen struct AnyIterator<Element>A type-erased iterator of Element.
class AnyKeyPathA type-erased key path, from any root type to any resulting value type.
@frozen struct AnyRandomAccessCollection<Element>A type-erased wrapper over any collection with indices that support random access traversal.
@frozen struct AnySequence<Element>A type-erased sequence.
@frozen struct Array<Element>An ordered, random-access collection.
@frozen struct ArraySlice<Element>A slice of an Array, ContiguousArray, or ArraySlice instance.
@frozen struct BoolA value type whose instances are either true or false.
@frozen struct CVaListPointer@frozen struct CharacterA single extended grapheme cluster that approximates a user-perceived character.
@frozen struct ClosedRange<Bound> where Bound : ComparableAn interval from a lower bound up to, and including, an upper bound.
struct CodingUserInfoKeyA user-defined key for providing context during encoding and decoding.
struct CollectionDifference<ChangeElement>A collection of insertions and removals that describe the difference between two ordered collection states.
@frozen struct CollectionOfOne<Element>A collection containing a single element.
@frozen enum CommandLineCommand-line arguments for the current process.
@frozen struct ContiguousArray<Element>A contiguously stored array.
enum DecodingErrorAn error that occurs during the decoding of a value.
@frozen struct DefaultIndices<Elements> where Elements : CollectionA collection of indices for an arbitrary collection
@frozen struct DefaultStringInterpolationRepresents a string literal with interpolations while it is being built up.
@frozen struct Dictionary<Key, Value> where Key : HashableA collection whose elements are key-value pairs.
struct DiscontiguousSlice<Base> where Base : CollectionA collection wrapper that provides access to the elements of a collection, indexed by a set of indices.
@frozen struct DoubleA double-precision, floating-point value type.
@frozen struct DropFirstSequence<Base> where Base : SequenceA sequence that lazily consumes and drops n elements from an underlying Base iterator before possibly returning the first available element.
@frozen struct DropWhileSequence<Base> where Base : SequenceA sequence that lazily consumes and drops n elements from an underlying Base iterator before possibly returning the first available element.
@frozen struct DurationA representation of high precision time.
@frozen struct EmptyCollection<Element>A collection whose element type is Element but that is always empty.
enum EncodingErrorAn error that occurs during the encoding of a value.
@frozen struct EnumeratedSequence<Base> where Base : SequenceAn enumeration of the elements of a sequence or collection.
@frozen struct FlattenSequence<Base> where Base : Sequence, Base.Element : SequenceA sequence consisting of all the elements contained in each segment contained in some Base sequence.
@frozen struct FloatA single-precision, floating-point value type.
@frozen struct Float16A half-precision (16b), floating-point value type.
@frozen enum FloatingPointClassificationThe IEEE 754 floating-point classes.
enum FloatingPointRoundingRuleA rule for rounding a floating-point number.
@frozen enum FloatingPointSignThe sign of a floating-point value.
@frozen struct HasherThe universal hash function used by Set and Dictionary.
@frozen struct IndexingIterator<Elements> where Elements : CollectionA type that iterates over a collection using its indices.
@frozen struct IntA signed integer value type.
@frozen struct Int128A 128-bit signed integer value type.
@frozen struct Int16A 16-bit signed integer value type.
@frozen struct Int32A 32-bit signed integer value type.
@frozen struct Int64A 64-bit signed integer value type.
@frozen struct Int8An 8-bit signed integer value type.
@frozen struct IteratorSequence<Base> where Base : IteratorProtocolA sequence built around an iterator of type Base.
@frozen struct JoinedSequence<Base> where Base : Sequence, Base.Element : SequenceA sequence that presents the elements of a base sequence of sequences concatenated using a given separator.
class KeyPath<Root, Value>A key path from a specific root type to a specific resulting value type.
@frozen struct KeyValuePairs<Key, Value>A lightweight collection of key-value pairs.
struct KeyedDecodingContainer<K> where K : CodingKeyA concrete container that provides a view into a decoder’s storage, making the encoded properties of a decodable type accessible by keys.
struct KeyedEncodingContainer<K> where K : CodingKeyA concrete container that provides a view into an encoder’s storage, making the encoded properties of an encodable type accessible by keys.
@frozen struct LazyDropWhileSequence<Base> where Base : SequenceA sequence whose elements consist of the elements that follow the initial consecutive elements of some base sequence that satisfy a given predicate.
@frozen struct LazyFilterSequence<Base> where Base : SequenceA sequence whose elements consist of the elements of some base sequence that also satisfy a given predicate.
@frozen struct LazyMapSequence<Base, Element> where Base : SequenceA Sequence whose elements consist of those in a Base Sequence passed through a transform function returning Element. These elements are computed lazily, each time they’re read, by calling the transform function on a base element.
@frozen struct LazyPrefixWhileSequence<Base> where Base : SequenceA sequence whose elements consist of the initial consecutive elements of some base sequence that satisfy a given predicate.
@frozen struct LazySequence<Base> where Base : SequenceA sequence containing the same elements as a Base sequence, but on which some operations such as map and filter are implemented lazily.
class ManagedBuffer<Header, Element> where Element : ~CopyableA class whose instances contain a property of type Header and raw storage for an array of Element, whose size is determined at instance creation.
@frozen struct ManagedBufferPointer<Header, Element> where Element : ~CopyableContains a buffer object, and provides access to an instance of Header and contiguous storage for an arbitrary number of Element instances stored in that buffer.
@frozen enum MemoryLayout<T> where T : ~CopyableThe memory layout of a type, describing its size, stride, and alignment.
struct MirrorA representation of the substructure and display style of an instance of any type.
@frozen enum NeverA type that has no values and can’t be constructed.
@frozen struct ObjectIdentifierA unique identifier for a class instance or metatype.
@frozen struct OpaquePointerA wrapper around an opaque C pointer.
@frozen enum Optional<Wrapped> where Wrapped : ~CopyableA type that represents either a wrapped value or the absence of a value.
class PartialKeyPath<Root>A partially type-erased key path, from a concrete root type to any resulting value type.
@frozen struct PartialRangeFrom<Bound> where Bound : ComparableA partial interval extending upward from a lower bound.
@frozen struct PartialRangeThrough<Bound> where Bound : ComparableA partial interval up to, and including, an upper bound.
@frozen struct PartialRangeUpTo<Bound> where Bound : ComparableA partial half-open interval up to, but not including, an upper bound.
@frozen struct PrefixSequence<Base> where Base : SequenceA sequence that only consumes up to n elements from an underlying Base iterator.
@frozen struct Range<Bound> where Bound : ComparableA half-open interval from a lower bound up to, but not including, an upper bound.
struct RangeSet<Bound> where Bound : ComparableA set of values of any comparable type, represented by ranges.
class ReferenceWritableKeyPath<Root, Value>A key path that supports reading from and writing to the resulting value with reference semantics.
@frozen struct Repeated<Element>A collection whose elements are all identical.
@frozen enum Result<Success, Failure> where Failure : Error, Success : ~CopyableA value that represents either a success or a failure, including an associated value in each case.
@frozen struct ReversedCollection<Base> where Base : BidirectionalCollectionA collection that presents the elements of its base collection in reverse order.
@frozen struct SIMD16<Scalar> where Scalar : SIMDScalarA vector of 16 scalar values.
@frozen struct SIMD2<Scalar> where Scalar : SIMDScalarA vector of two scalar values.
@frozen struct SIMD3<Scalar> where Scalar : SIMDScalarA vector of three scalar values.
@frozen struct SIMD32<Scalar> where Scalar : SIMDScalarA vector of 32 scalar values.
@frozen struct SIMD4<Scalar> where Scalar : SIMDScalarA vector of four scalar values.
@frozen struct SIMD64<Scalar> where Scalar : SIMDScalarA vector of 64 scalar values.
@frozen struct SIMD8<Scalar> where Scalar : SIMDScalarA vector of eight scalar values.
@frozen struct SIMDMask<Storage> where Storage : SIMD, Storage.Scalar : FixedWidthInteger, Storage.Scalar : SignedInteger@frozen struct Set<Element> where Element : HashableAn unordered collection of unique elements.
@frozen struct Slice<Base> where Base : CollectionA view into a subsequence of elements of another collection.
@frozen struct StaticBigIntAn immutable arbitrary-precision signed integer.
@frozen struct StaticStringA string type designed to represent text that is known at compile time.
@frozen struct StrideThrough<Element> where Element : StrideableA sequence of values formed by striding over a closed interval.
@frozen struct StrideThroughIterator<Element> where Element : StrideableAn iterator for a StrideThrough instance.
@frozen struct StrideTo<Element> where Element : StrideableA sequence of values formed by striding over a half-open interval.
@frozen struct StrideToIterator<Element> where Element : StrideableAn iterator for a StrideTo instance.
@frozen struct StringA Unicode string value that is a collection of characters.
@frozen struct SubstringA slice of a string.
@frozen struct SystemRandomNumberGeneratorThe system’s default source of random data.
@frozen struct UIntAn unsigned integer value type.
@frozen struct UInt128A 128-bit unsigned integer value type.
@frozen struct UInt16A 16-bit unsigned integer value type.
@frozen struct UInt32A 32-bit unsigned integer value type.
@frozen struct UInt64A 64-bit unsigned integer value type.
@frozen struct UInt8An 8-bit unsigned integer value type.
@frozen enum UnboundedRange_A range expression that represents the entire range of a collection.
@frozen struct UnfoldSequence<Element, State>A sequence whose elements are produced via repeated applications of a closure to some mutable state.
@frozen enum UnicodeA namespace for Unicode utilities.
@frozen enum UnicodeDecodingResultThe result of one Unicode decoding step.
@frozen struct Unmanaged<Instance> where Instance : AnyObjectA type for propagating an unmanaged object reference.
@frozen struct UnsafeBufferPointer<Element> where Element : ~CopyableA nonowning collection interface to a buffer of elements stored contiguously in memory.
@frozen struct UnsafeMutableBufferPointer<Element> where Element : ~CopyableA nonowning collection interface to a buffer of mutable elements stored contiguously in memory.
@frozen struct UnsafeMutablePointer<Pointee> where Pointee : ~CopyableA pointer for accessing and manipulating data of a specific type.
@frozen struct UnsafeMutableRawBufferPointerA mutable nonowning collection interface to the bytes in a region of memory.
@frozen struct UnsafeMutableRawPointerA raw pointer for accessing and manipulating untyped data.
@frozen struct UnsafePointer<Pointee> where Pointee : ~CopyableA pointer for accessing data of a specific type.
@frozen struct UnsafeRawBufferPointerA nonowning collection interface to the bytes in a region of memory.
@frozen struct UnsafeRawPointerA raw pointer for accessing untyped data.
class WritableKeyPath<Root, Value>A key path that supports reading from and writing to the resulting value.
@frozen struct Zip2Sequence<Sequence1, Sequence2> where Sequence1 : Sequence, Sequence2 : SequenceA sequence of pairs built out of two underlying sequences.
typealias AnyClass = any AnyObject.TypeThe protocol to which all class types implicitly conform.
typealias AnyObjectThe protocol to which all classes implicitly conform.
typealias BooleanLiteralType = BoolThe default type for an otherwise-unconstrained Boolean literal.
typealias CBool = BoolThe C ‘_Bool’ and C++ ‘bool’ type.
typealias CChar = Int8The C ‘char’ type.
typealias CChar16 = UInt16The C++11 ‘char16_t’ type, which has UTF-16 encoding.
typealias CChar32 = Unicode.ScalarThe C++11 ‘char32_t’ type, which has UTF-32 encoding.
typealias CChar8 = UInt8The C++20 ‘char8_t’ type, which has UTF-8 encoding.
typealias CDouble = DoubleThe C ‘double’ type.
typealias CFloat = FloatThe C ‘float’ type.
typealias CFloat16 = Float16The C ‘_Float16’ type.
typealias CInt = Int32typealias CLong = Inttypealias CLongLong = Int64The C ‘long long’ type.
typealias CShort = Int16The C ‘short’ type.
typealias CSignedChar = Int8The C ‘signed char’ type.
typealias CUnsignedChar = UInt8The C ‘unsigned char’ type.
typealias CUnsignedInt = UInt32typealias CUnsignedLong = UInttypealias CUnsignedLongLong = UInt64The C ‘unsigned long long’ type.
typealias CUnsignedShort = UInt16The C ‘unsigned short’ type.
typealias CWideChar = Unicode.Scalartypealias Codable = Decodable & EncodableA type that can convert itself into and out of an external representation.
typealias CountableClosedRange<Bound> = ClosedRange<Bound> where Bound : Strideable, Bound.Stride : SignedIntegertypealias CountablePartialRangeFrom<Bound> = PartialRangeFrom<Bound> where Bound : Strideable, Bound.Stride : SignedIntegertypealias CountableRange<Bound> = Range<Bound> where Bound : Strideable, Bound.Stride : SignedIntegertypealias DictionaryIndex<Key, Value> = Dictionary<Key, Value>.Index where Key : Hashabletypealias DictionaryIterator<Key, Value> = Dictionary<Key, Value>.Iterator where Key : Hashabletypealias ExtendedGraphemeClusterType = StringThe default type for an otherwise-unconstrained Unicode extended grapheme cluster literal.
typealias FlattenCollection<T> = FlattenSequence<T> where T : Collection, T.Element : Collectiontypealias Float32 = FloatA 32-bit floating point type.
typealias Float64 = DoubleA 64-bit floating point type.
typealias FloatLiteralType = DoubleThe default type for an otherwise-unconstrained floating-point literal.
typealias IntegerLiteralType = IntThe default type for an otherwise-unconstrained integer literal.
typealias LazyCollection<T> = LazySequence<T> where T : CollectionA collection containing the same elements as a Base collection, but on which some operations such as map and filter are implemented lazily.
typealias LazyDropWhileCollection<T> = LazyDropWhileSequence<T> where T : CollectionA lazy wrapper that includes the elements of an underlying collection after any initial consecutive elements that satisfy a predicate.
typealias LazyFilterCollection<T> = LazyFilterSequence<T> where T : CollectionA lazy Collection wrapper that includes the elements of an underlying collection that satisfy a predicate.
typealias LazyMapCollection<T, U> = LazyMapSequence<T, U> where T : CollectionA Collection whose elements consist of those in a Base Collection passed through a transform function returning Element. These elements are computed lazily, each time they’re read, by calling the transform function on a base element.
typealias LazyPrefixWhileCollection<T> = LazyPrefixWhileSequence<T> where T : CollectionA lazy collection wrapper that includes the initial consecutive elements of an underlying collection that satisfy a predicate.
typealias SetIndex<Element> = Set<Element>.Index where Element : Hashabletypealias SetIterator<Element> = Set<Element>.Iterator where Element : Hashabletypealias StringLiteralType = StringThe default type for an otherwise-unconstrained string literal.
typealias UTF16 = Unicode.UTF16typealias UTF32 = Unicode.UTF32typealias UTF8 = Unicode.UTF8typealias UnboundedRange = (UnboundedRange_) -> ()The type of an unbounded range operator.
typealias UnfoldFirstSequence<T> = UnfoldSequence<T, (T?, Bool)>The return type of sequence(first:next:).
typealias UnicodeScalar = Unicode.Scalartypealias UnicodeScalarType = StringThe default type for an otherwise-unconstrained unicode scalar literal.
typealias Void = ()The return type of functions that don’t explicitly specify a return type, that is, an empty tuple ().
@attached(member) @attached(memberAttribute) macro DebugDescription() Converts description definitions to a debugger Type Summary.
@freestanding(expression) macro column<T>() -> T where T : ExpressibleByIntegerLiteral Produces the column number at which the macro is expanded.
@freestanding(expression) macro dsohandle() -> UnsafeRawPointer Produces the shared object handle for the macro expansion location.
@freestanding(declaration) macro error(_ message: String) Produce the given error message during compilation.
@freestanding(expression) macro externalMacro<T>(module: String, type: String) -> T Specifies the module and type name for an externally-defined macro, which must conform to the appropriate set of Macro protocols.
@freestanding(expression) macro file<T>() -> T where T : ExpressibleByStringLiteral Produces either the result of #filePath or #file, depending on whether concise file paths (SE-0274) are enabled.
@freestanding(expression) macro fileID<T>() -> T where T : ExpressibleByStringLiteral Produces a unique identifier for the given source file, comprised of the module and file name.
@freestanding(expression) macro filePath<T>() -> T where T : ExpressibleByStringLiteral Produces the complete path for the given source file.
@freestanding(expression) macro function<T>() -> T where T : ExpressibleByStringLiteral Produces a string representation of the current function name.
@freestanding(expression) macro line<T>() -> T where T : ExpressibleByIntegerLiteral Produces the line number at which the macro is expanded.
@freestanding(declaration) macro warning(_ message: String) Produce the given warning message during compilation.
protocol UnsafeSendable : SendableA type whose values can safely be passed across concurrency domains by copying, but which disables some safety checking at the conformance site.
typealias ArrayLiteralConvertible = ExpressibleByArrayLiteraltypealias BidirectionalIndexable = BidirectionalCollectiontypealias BidirectionalSlice<T> = Slice<T> where T : BidirectionalCollectiontypealias BooleanLiteralConvertible = ExpressibleByBooleanLiteraltypealias ClosedRangeIndex<T> = ClosedRange<T>.Index where T : Strideable, T.Stride : SignedIntegertypealias ConcurrentValue = Sendabletypealias CustomPlaygroundQuickLookable = _CustomPlaygroundQuickLookableA type that explicitly supplies its own playground Quick Look.
typealias DefaultBidirectionalIndices<T> = DefaultIndices<T> where T : BidirectionalCollectiontypealias DefaultRandomAccessIndices<T> = DefaultIndices<T> where T : RandomAccessCollectiontypealias DictionaryLiteral<Key, Value> = KeyValuePairs<Key, Value>typealias DictionaryLiteralConvertible = ExpressibleByDictionaryLiteraltypealias EmptyIterator<T> = EmptyCollection<T>.Iteratortypealias EnumeratedIterator<T> = EnumeratedSequence<T>.Iterator where T : Sequencetypealias ExtendedGraphemeClusterLiteralConvertible = ExpressibleByExtendedGraphemeClusterLiteraltypealias FlattenBidirectionalCollection<T> = FlattenCollection<T> where T : BidirectionalCollection, T.Element : BidirectionalCollectiontypealias FlattenBidirectionalCollectionIndex<T> = FlattenCollection<T>.Index where T : BidirectionalCollection, T.Element : BidirectionalCollectiontypealias FlattenCollectionIndex<T> = FlattenCollection<T>.Index where T : Collection, T.Element : Collectiontypealias FloatLiteralConvertible = ExpressibleByFloatLiteraltypealias Indexable = Collectiontypealias IndexableBase = Collectiontypealias IntegerLiteralConvertible = ExpressibleByIntegerLiteraltypealias IteratorOverOne<T> = CollectionOfOne<T>.Iteratortypealias JoinedIterator<T> = JoinedSequence<T>.Iterator where T : Sequence, T.Element : Sequencetypealias LazyBidirectionalCollection<T> = LazyCollection<T> where T : BidirectionalCollectiontypealias LazyDropWhileBidirectionalCollection<T> = LazyDropWhileCollection<T> where T : BidirectionalCollectiontypealias LazyDropWhileIndex<T> = LazyDropWhileCollection<T>.Index where T : Collectiontypealias LazyDropWhileIterator<T> = LazyDropWhileSequence<T>.Iterator where T : Sequencetypealias LazyFilterBidirectionalCollection<T> = LazyFilterCollection<T> where T : BidirectionalCollectiontypealias LazyFilterIndex<Base> = Base.Index where Base : Collectiontypealias LazyFilterIterator<T> = LazyFilterSequence<T>.Iterator where T : Sequencetypealias LazyMapBidirectionalCollection<T, E> = LazyMapCollection<T, E> where T : BidirectionalCollectiontypealias LazyMapIterator<T, E> = LazyMapSequence<T, E>.Iterator where T : Sequencetypealias LazyMapRandomAccessCollection<T, E> = LazyMapCollection<T, E> where T : RandomAccessCollectiontypealias LazyPrefixWhileBidirectionalCollection<T> = LazyPrefixWhileCollection<T> where T : BidirectionalCollectiontypealias LazyPrefixWhileIndex<T> = LazyPrefixWhileCollection<T>.Index where T : Collectiontypealias LazyPrefixWhileIterator<T> = LazyPrefixWhileSequence<T>.Iterator where T : Sequencetypealias LazyRandomAccessCollection<T> = LazyCollection<T> where T : RandomAccessCollectiontypealias MutableBidirectionalSlice<T> = Slice<T> where T : BidirectionalCollection, T : MutableCollectiontypealias MutableIndexable = MutableCollectiontypealias MutableRandomAccessSlice<T> = Slice<T> where T : MutableCollection, T : RandomAccessCollectiontypealias MutableRangeReplaceableBidirectionalSlice<T> = Slice<T> where T : BidirectionalCollection, T : MutableCollection, T : RangeReplaceableCollectiontypealias MutableRangeReplaceableRandomAccessSlice<T> = Slice<T> where T : MutableCollection, T : RandomAccessCollection, T : RangeReplaceableCollectiontypealias MutableRangeReplaceableSlice<T> = Slice<T> where T : MutableCollection, T : RangeReplaceableCollectiontypealias MutableSlice<T> = Slice<T> where T : MutableCollectiontypealias NilLiteralConvertible = ExpressibleByNilLiteraltypealias PlaygroundQuickLookThe sum of types that can be used as a Quick Look representation.
typealias RandomAccessIndexable = RandomAccessCollectiontypealias RandomAccessSlice<T> = Slice<T> where T : RandomAccessCollectiontypealias RangeReplaceableBidirectionalSlice<T> = Slice<T> where T : BidirectionalCollection, T : RangeReplaceableCollectiontypealias RangeReplaceableIndexable = RangeReplaceableCollectiontypealias RangeReplaceableRandomAccessSlice<T> = Slice<T> where T : RandomAccessCollection, T : RangeReplaceableCollectiontypealias RangeReplaceableSlice<T> = Slice<T> where T : RangeReplaceableCollectiontypealias ReversedIndex<T> = ReversedCollection<T>.Index where T : BidirectionalCollectiontypealias ReversedRandomAccessCollection<T> = ReversedCollection<T> where T : RandomAccessCollectiontypealias StringInterpolationConvertible = ExpressibleByStringInterpolationtypealias StringLiteralConvertible = ExpressibleByStringLiteraltypealias UnicodeScalarLiteralConvertible = ExpressibleByUnicodeScalarLiteraltypealias UnsafeBufferPointerIterator<T> = UnsafeBufferPointer<T>.Iteratortypealias UnsafeConcurrentValue = UnsafeSendabletypealias UnsafeMutableRawBufferPointerIterator<T> = UnsafeBufferPointer<T>.Iteratortypealias UnsafeRawBufferPointerIterator<T> = UnsafeBufferPointer<T>.Iteratortypealias Zip2Iterator<T, U> = Zip2Sequence<T, U>.Iterator where T : Sequence, U : Sequenceimport Cxximport Dispatchimport DispatchIntrospectionimport Distributedimport Foundationimport FoundationNetworkingimport FoundationXMLimport RegexBuilderimport XCTestimport _Concurrencyimport _Differentiationimport _RegexParserimport _StringProcessing