Documentation Archive Developer
Search

Swift Changes for Swift

Swift

Removed _Incrementable.successor() -> Self
Removed AnyBidirectionalCollection.generate() -> AnyGenerator<Element>
Removed AnyBidirectionalCollection.init(_: AnyForwardCollection<Element>)
Removed AnyBidirectionalCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
Removed AnyBidirectionalCollection.init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_: C)
Removed AnyBidirectionalCollection.subscript(_: AnyBidirectionalIndex) -> Element
Removed AnyBidirectionalCollection.underestimateCount() -> Int
Removed AnyBidirectionalIndex [struct]
Removed AnyBidirectionalIndex.init<BaseIndex : BidirectionalIndexType>(_: BaseIndex)
Removed AnyBidirectionalIndex.predecessor() -> AnyBidirectionalIndex
Removed AnyBidirectionalIndex.successor() -> AnyBidirectionalIndex
Removed AnyCollectionType
Removed AnyForwardCollection [struct]
Removed AnyForwardCollection.count
Removed AnyForwardCollection.endIndex
Removed AnyForwardCollection.generate() -> AnyGenerator<Element>
Removed AnyForwardCollection.init(_: AnyRandomAccessCollection<Element>)
Removed AnyForwardCollection.init(_: AnyForwardCollection<Element>)
Removed AnyForwardCollection.init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_: C)
Removed AnyForwardCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
Removed AnyForwardCollection.init<C : CollectionType where C.Index : ForwardIndexType, C.Generator.Element == Element>(_: C)
Removed AnyForwardCollection.init(_: AnyBidirectionalCollection<Element>)
Removed AnyForwardCollection.startIndex
Removed AnyForwardCollection.subscript(_: AnyForwardIndex) -> Element
Removed AnyForwardCollection.underestimateCount() -> Int
Removed AnyForwardIndex [struct]
Removed AnyForwardIndex.init<BaseIndex : ForwardIndexType>(_: BaseIndex)
Removed AnyForwardIndex.successor() -> AnyForwardIndex
Removed AnyGenerator [struct]
Removed AnyGenerator.init<G : GeneratorType where G.Element == Element>(_: G)
Removed AnyGenerator.init(body: () -> Element?)
Removed AnyGenerator.next() -> Element?
Removed AnyRandomAccessCollection.generate() -> AnyGenerator<Element>
Removed AnyRandomAccessCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
Removed AnyRandomAccessCollection.init(_: AnyForwardCollection<Element>)
Removed AnyRandomAccessCollection.subscript(_: AnyRandomAccessIndex) -> Element
Removed AnyRandomAccessCollection.underestimateCount() -> Int
Removed AnyRandomAccessIndex [struct]
Removed AnyRandomAccessIndex.advancedBy(_: Distance) -> AnyRandomAccessIndex
Removed AnyRandomAccessIndex.advancedBy(_: Distance, limit: AnyRandomAccessIndex) -> AnyRandomAccessIndex
Removed AnyRandomAccessIndex.distanceTo(_: AnyRandomAccessIndex) -> Distance
Removed AnyRandomAccessIndex.init<BaseIndex : RandomAccessIndexType>(_: BaseIndex)
Removed AnyRandomAccessIndex.predecessor() -> AnyRandomAccessIndex
Removed AnyRandomAccessIndex.successor() -> AnyRandomAccessIndex
Removed AnySequence.generate() -> AnyGenerator<Element>
Removed AnySequence.init<G : GeneratorType where G.Element == Element>(_: () -> G)
Removed AnySequence.init<S : SequenceType where S.Generator.Element == Element, S.SubSequence : SequenceType, S.SubSequence.Generator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_: S)
Removed AnySequence.underestimateCount() -> Int
Removed Array.appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_: C)
Removed Array.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed Array.init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_: S)
Removed Array.init(count: Int, repeatedValue: Element)
Removed Array.insert(_: Element, atIndex: Int)
Removed Array.removeAll(keepCapacity: Bool)
Removed Array.removeAtIndex(_: Int) -> Element
Removed Array.removeLast() -> Element
Removed Array.replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Removed ArrayLiteralConvertible
Removed ArrayLiteralConvertible.init(arrayLiteral: Self.Element)
Removed ArraySlice.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed ArraySlice.appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_: C)
Removed ArraySlice.init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_: S)
Removed ArraySlice.init(count: Int, repeatedValue: Element)
Removed ArraySlice.insert(_: Element, atIndex: Int)
Removed ArraySlice.removeAll(keepCapacity: Bool)
Removed ArraySlice.removeAtIndex(_: Int) -> Element
Removed ArraySlice.removeLast() -> Element
Removed ArraySlice.replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Removed AutoreleasingUnsafeMutablePointer.init()
Removed AutoreleasingUnsafeMutablePointer.init(nilLiteral: ())
Removed AutoreleasingUnsafeMutablePointer.memory
Removed BidirectionalIndexType
Removed BidirectionalIndexType.advancedBy(_: Self.Distance) -> Self
Removed BidirectionalIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed BidirectionalIndexType.predecessor() -> Self
Removed BidirectionalIndexType.predecessor() -> Self
Removed BidirectionalIndexType.successor() -> Self
Removed Bit [enum]
Removed Bit.addWithOverflow(_: Bit, _: Bit) -> (Bit, overflow: Bool) [static]
Removed Bit.advancedBy(_: Distance) -> Bit
Removed Bit.distanceTo(_: Bit) -> Int
Removed Bit.divideWithOverflow(_: Bit, _: Bit) -> (Bit, overflow: Bool) [static]
Removed Bit.multiplyWithOverflow(_: Bit, _: Bit) -> (Bit, overflow: Bool) [static]
Removed Bit.One
Removed Bit.predecessor() -> Bit
Removed Bit.remainderWithOverflow(_: Bit, _: Bit) -> (Bit, overflow: Bool) [static]
Removed Bit.subtractWithOverflow(_: Bit, _: Bit) -> (Bit, overflow: Bool) [static]
Removed Bit.successor() -> Bit
Removed Bit.toIntMax() -> IntMax
Removed Bit.Zero
Removed BitwiseOperationsType
Removed BitwiseOperationsType.&(_: Self, _: Self) -> Self
Removed BitwiseOperationsType.^(_: Self, _: Self) -> Self
Removed BitwiseOperationsType.allZeros
Removed BitwiseOperationsType.|(_: Self, _: Self) -> Self
Removed BitwiseOperationsType.~(_: Self) -> Self
Removed Bool.boolValue
Removed Bool.init(_builtinBooleanLiteral: Builtin.Int1)
Removed BooleanLiteralConvertible
Removed BooleanLiteralConvertible.init(booleanLiteral: Self.BooleanLiteralType)
Removed BooleanType
Removed BooleanType.boolValue
Removed Character.init(_builtinExtendedGraphemeClusterLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)
Removed Character.init(_builtinUnicodeScalarLiteral: Builtin.Int32)
Removed Character.writeTo<Target : OutputStreamType>(_: Target)
Removed ClosedInterval [struct]
Removed ClosedInterval.clamp(_: ClosedInterval<Bound>) -> ClosedInterval<Bound>
Removed ClosedInterval.contains(_: Bound) -> Bool
Removed ClosedInterval.debugDescription
Removed ClosedInterval.description
Removed ClosedInterval.end
Removed ClosedInterval.init(_: ClosedInterval<Bound>)
Removed ClosedInterval.init(_: Bound, _: Bound)
Removed ClosedInterval.isEmpty
Removed ClosedInterval.start
Removed CollectionOfOne.generate() -> GeneratorOfOne<Element>
Removed CollectionType
Removed CollectionType.count
Removed CollectionType.count
Removed CollectionType.dropFirst(_: Int) -> Self.SubSequence
Removed CollectionType.dropLast(_: Int) -> Self.SubSequence
Removed CollectionType.dropLast(_: Int) -> Self.SubSequence
Removed CollectionType.endIndex
Removed CollectionType.filter(_: (Self.Base.Generator.Element) -> Bool) -> [Self.Base.Generator.Element]
Removed CollectionType.first
Removed CollectionType.first
Removed CollectionType.flatten() -> FlattenCollection<Self>
Removed CollectionType.flatten() -> FlattenBidirectionalCollection<Self>
Removed CollectionType.generate() -> Self.Generator
Removed CollectionType.generate() -> IndexingGenerator<Self>
Removed CollectionType.indexOf(_: (Self.Generator.Element) throws -> Bool) rethrows -> Self.Index?
Removed CollectionType.indexOf(_: Self.Generator.Element) -> Self.Index?
Removed CollectionType.indices
Removed CollectionType.isEmpty
Removed CollectionType.isEmpty
Removed CollectionType.last
Removed CollectionType.lazy
Removed CollectionType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed CollectionType.map<T>(_: (Self.Base.Generator.Element) -> T) -> [T]
Removed CollectionType.popFirst() -> Self.Generator.Element?
Removed CollectionType.popLast() -> Self.Generator.Element?
Removed CollectionType.popLast() -> Self.Generator.Element?
Removed CollectionType.prefix(_: Int) -> Self.SubSequence
Removed CollectionType.prefixThrough(_: Self.Index) -> Self.SubSequence
Removed CollectionType.prefixThrough(_: Self.Index) -> Self.SubSequence
Removed CollectionType.prefixUpTo(_: Self.Index) -> Self.SubSequence
Removed CollectionType.prefixUpTo(_: Self.Index) -> Self.SubSequence
Removed CollectionType.removeFirst() -> Self.Generator.Element
Removed CollectionType.removeFirst(_: Int)
Removed CollectionType.removeLast() -> Self.Generator.Element
Removed CollectionType.removeLast(_: Int)
Removed CollectionType.reverse() -> ReverseRandomAccessCollection<Self>
Removed CollectionType.reverse() -> ReverseCollection<Self>
Removed CollectionType.split(_: Int, allowEmptySlices: Bool, isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Removed CollectionType.split(_: Self.Generator.Element, maxSplit: Int, allowEmptySlices: Bool) -> [Self.SubSequence]
Removed CollectionType.startIndex
Removed CollectionType.startIndex
Removed CollectionType.subscript(_: Range<Self.Index>) -> Self.SubSequence
Removed CollectionType.subscript(_: Self.Index) -> Self.Generator.Element
Removed CollectionType.subscript(_: Self.Index) -> Self.Base.Generator.Element
Removed CollectionType.subscript(_: Range<Self.Index>) -> Slice<Self>
Removed CollectionType.suffix(_: Int) -> Self.SubSequence
Removed CollectionType.suffix(_: Int) -> Self.SubSequence
Removed CollectionType.suffixFrom(_: Self.Index) -> Self.SubSequence
Removed CollectionType.suffixFrom(_: Self.Index) -> Self.SubSequence
Removed CollectionType.underestimateCount() -> Int
Removed ContiguousArray.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed ContiguousArray.appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_: C)
Removed ContiguousArray.init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_: S)
Removed ContiguousArray.init(count: Int, repeatedValue: Element)
Removed ContiguousArray.insert(_: Element, atIndex: Int)
Removed ContiguousArray.removeAll(keepCapacity: Bool)
Removed ContiguousArray.removeAtIndex(_: Int) -> Element
Removed ContiguousArray.removeLast() -> Element
Removed ContiguousArray.replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Removed COpaquePointer [struct]
Removed COpaquePointer.debugDescription
Removed COpaquePointer.hashValue
Removed COpaquePointer.init()
Removed COpaquePointer.init<T>(_: UnsafeMutablePointer<T>)
Removed COpaquePointer.init<T>(_: UnsafePointer<T>)
Removed COpaquePointer.init(bitPattern: Int)
Removed COpaquePointer.init(bitPattern: UInt)
Removed COpaquePointer.init(nilLiteral: ())
Removed CustomPlaygroundQuickLookable.customPlaygroundQuickLook() -> PlaygroundQuickLook
Removed CustomReflectable.customMirror() -> Mirror
Removed CVaListPointer.init(_fromUnsafeMutablePointer: UnsafeMutablePointer<Void>)
Removed CVarArgType
Removed Dictionary.generate() -> DictionaryGenerator<Key, Value>
Removed Dictionary.indexForKey(_: Key) -> DictionaryIndex<Key, Value>?
Removed Dictionary.removeAll(keepCapacity: Bool)
Removed Dictionary.removeAtIndex(_: DictionaryIndex<Key, Value>) -> (Key, Value)
Removed Dictionary.removeValueForKey(_: Key) -> Value?
Removed Dictionary.subscript(_: DictionaryIndex<Key, Value>) -> (Key, Value)
Removed DictionaryGenerator [struct]
Removed DictionaryGenerator.next() -> (Key, Value)?
Removed DictionaryIndex.successor() -> DictionaryIndex<Key, Value>
Removed DictionaryLiteralConvertible
Removed DictionaryLiteralConvertible.init(dictionaryLiteral: (Self.Key, Self.Value))
Removed Double.advancedBy(_: Double) -> Double
Removed Double.distanceTo(_: Double) -> Double
Removed Double.floatingPointClass
Removed Double.init(_bits: Builtin.FPIEEE64)
Removed Double.init(_builtinFloatLiteral: Builtin.FPIEEE64)
Removed Double.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Double.isSignaling
Removed Double.isSignMinus
Removed Double.NaN
Removed Double.quietNaN
Removed EmptyCollection.generate() -> EmptyGenerator<Element>
Removed EmptyGenerator [struct]
Removed EmptyGenerator.init()
Removed EmptyGenerator.next() -> Element?
Removed EnumerateGenerator [struct]
Removed EnumerateGenerator.init(_: Base)
Removed EnumerateGenerator.next() -> (index: Int, element: Base.Element)?
Removed EnumerateSequence [struct]
Removed EnumerateSequence.generate() -> EnumerateGenerator<Base.Generator>
Removed EnumerateSequence.init(_: Base)
Removed ErrorType
Removed ExtendedGraphemeClusterLiteralConvertible
Removed ExtendedGraphemeClusterLiteralConvertible.init(extendedGraphemeClusterLiteral: Self.ExtendedGraphemeClusterLiteralType)
Removed FlattenBidirectionalCollection.generate() -> FlattenGenerator<Base.Generator>
Removed FlattenBidirectionalCollection.subscript(_: FlattenBidirectionalCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element
Removed FlattenBidirectionalCollection.underestimateCount() -> Int
Removed FlattenBidirectionalCollectionIndex.predecessor() -> FlattenBidirectionalCollectionIndex<BaseElements>
Removed FlattenBidirectionalCollectionIndex.successor() -> FlattenBidirectionalCollectionIndex<BaseElements>
Removed FlattenCollection.generate() -> FlattenGenerator<Base.Generator>
Removed FlattenCollection.subscript(_: FlattenCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element
Removed FlattenCollection.underestimateCount() -> Int
Removed FlattenCollectionIndex.successor() -> FlattenCollectionIndex<BaseElements>
Removed FlattenGenerator [struct]
Removed FlattenGenerator.init(_: Base)
Removed FlattenGenerator.next() -> Base.Element.Generator.Element?
Removed FlattenSequence.generate() -> FlattenGenerator<Base.Generator>
Removed FlattenSequence.init(_: Base)
Removed Float.advancedBy(_: Float) -> Float
Removed Float.distanceTo(_: Float) -> Float
Removed Float.floatingPointClass
Removed Float.init(_bits: Builtin.FPIEEE32)
Removed Float.init(_builtinFloatLiteral: Builtin.FPIEEE64)
Removed Float.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Float.isSignaling
Removed Float.isSignMinus
Removed Float.NaN
Removed Float.quietNaN
Removed FloatingPointClassification.NegativeInfinity
Removed FloatingPointClassification.NegativeNormal
Removed FloatingPointClassification.NegativeSubnormal
Removed FloatingPointClassification.NegativeZero
Removed FloatingPointClassification.PositiveInfinity
Removed FloatingPointClassification.PositiveNormal
Removed FloatingPointClassification.PositiveSubnormal
Removed FloatingPointClassification.PositiveZero
Removed FloatingPointClassification.QuietNaN
Removed FloatingPointClassification.SignalingNaN
Removed FloatingPointType
Removed FloatingPointType.floatingPointClass
Removed FloatingPointType.infinity
Removed FloatingPointType.init(_: Int)
Removed FloatingPointType.init(_: Int8)
Removed FloatingPointType.init(_: UInt8)
Removed FloatingPointType.init(_: UInt)
Removed FloatingPointType.init(_: Int16)
Removed FloatingPointType.init(_: Int32)
Removed FloatingPointType.init(_: UInt64)
Removed FloatingPointType.init(_: Int64)
Removed FloatingPointType.init(_: UInt32)
Removed FloatingPointType.init(_: UInt16)
Removed FloatingPointType.isFinite
Removed FloatingPointType.isInfinite
Removed FloatingPointType.isNaN
Removed FloatingPointType.isNormal
Removed FloatingPointType.isSignaling
Removed FloatingPointType.isSignMinus
Removed FloatingPointType.isSubnormal
Removed FloatingPointType.isZero
Removed FloatingPointType.NaN
Removed FloatingPointType.quietNaN
Removed FloatLiteralConvertible
Removed FloatLiteralConvertible.init(floatLiteral: Self.FloatLiteralType)
Removed ForwardIndexType
Removed ForwardIndexType.advancedBy(_: Self.Distance) -> Self
Removed ForwardIndexType.advancedBy(_: Self.Distance) -> Self
Removed ForwardIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed ForwardIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed ForwardIndexType.distanceTo(_: Self) -> Self.Distance
Removed ForwardIndexType.distanceTo(_: Self) -> Self.Distance
Removed GeneratorOfOne [struct]
Removed GeneratorOfOne.init(_: Element?)
Removed GeneratorOfOne.next() -> Element?
Removed GeneratorSequence [struct]
Removed GeneratorSequence.init(_: Base)
Removed GeneratorSequence.next() -> Base.Element?
Removed GeneratorType
Removed GeneratorType.next() -> Self.Element?
Removed HalfOpenInterval [struct]
Removed HalfOpenInterval.clamp(_: HalfOpenInterval<Bound>) -> HalfOpenInterval<Bound>
Removed HalfOpenInterval.contains(_: Bound) -> Bool
Removed HalfOpenInterval.debugDescription
Removed HalfOpenInterval.description
Removed HalfOpenInterval.end
Removed HalfOpenInterval.init(_: HalfOpenInterval<Bound>)
Removed HalfOpenInterval.init(_: Bound, _: Bound)
Removed HalfOpenInterval.isEmpty
Removed HalfOpenInterval.start
Removed ImplicitlyUnwrappedOptional.flatMap<U>(_: (Wrapped) throws -> U!) rethrows -> U!
Removed ImplicitlyUnwrappedOptional.init()
Removed ImplicitlyUnwrappedOptional.init(_: Wrapped?)
Removed ImplicitlyUnwrappedOptional.map<U>(_: (Wrapped) throws -> U) rethrows -> U!
Removed ImplicitlyUnwrappedOptional.None
Removed ImplicitlyUnwrappedOptional.Some
Removed Index.samePositionIn(_: String.UTF16View) -> String.UTF16View.Index
Removed Index.samePositionIn(_: String.UTF8View) -> String.UTF8View.Index
Removed Index.samePositionIn(_: String.UnicodeScalarView) -> String.UnicodeScalarView.Index
Removed Indexable.endIndex
Removed Indexable.startIndex
Removed Indexable.subscript(_: Self.Index) -> Self._Element
Removed IndexingGenerator [struct]
Removed IndexingGenerator.init(_: Elements)
Removed IndexingGenerator.next() -> Elements._Element?
Removed Int.advancedBy(_: Distance) -> Int
Removed Int.distanceTo(_: Int) -> Distance
Removed Int.init(_: Builtin.Word)
Removed Int.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Int.predecessor() -> Int
Removed Int.successor() -> Int
Removed Int16.advancedBy(_: Distance) -> Int16
Removed Int16.distanceTo(_: Int16) -> Distance
Removed Int16.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Int16.predecessor() -> Int16
Removed Int16.successor() -> Int16
Removed Int32.advancedBy(_: Distance) -> Int32
Removed Int32.distanceTo(_: Int32) -> Distance
Removed Int32.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Int32.predecessor() -> Int32
Removed Int32.successor() -> Int32
Removed Int64.advancedBy(_: Distance) -> Int64
Removed Int64.distanceTo(_: Int64) -> Distance
Removed Int64.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Int64.predecessor() -> Int64
Removed Int64.successor() -> Int64
Removed Int8.advancedBy(_: Distance) -> Int8
Removed Int8.distanceTo(_: Int8) -> Distance
Removed Int8.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Int8.predecessor() -> Int8
Removed Int8.successor() -> Int8
Removed IntegerArithmeticType
Removed IntegerArithmeticType.%(_: Self, _: Self) -> Self
Removed IntegerArithmeticType.*(_: Self, _: Self) -> Self
Removed IntegerArithmeticType.+(_: Self, _: Self) -> Self
Removed IntegerArithmeticType.-(_: Self, _: Self) -> Self
Removed IntegerArithmeticType./(_: Self, _: Self) -> Self
Removed IntegerArithmeticType.addWithOverflow(_: Self, _: Self) -> (Self, overflow: Bool) [class]
Removed IntegerArithmeticType.divideWithOverflow(_: Self, _: Self) -> (Self, overflow: Bool) [class]
Removed IntegerArithmeticType.multiplyWithOverflow(_: Self, _: Self) -> (Self, overflow: Bool) [class]
Removed IntegerArithmeticType.remainderWithOverflow(_: Self, _: Self) -> (Self, overflow: Bool) [class]
Removed IntegerArithmeticType.subtractWithOverflow(_: Self, _: Self) -> (Self, overflow: Bool) [class]
Removed IntegerArithmeticType.toIntMax() -> IntMax
Removed IntegerLiteralConvertible
Removed IntegerLiteralConvertible.init(integerLiteral: Self.IntegerLiteralType)
Removed IntegerType
Removed IntervalType
Removed IntervalType.clamp(_: Self) -> Self
Removed IntervalType.contains(_: Self.Bound) -> Bool
Removed IntervalType.end
Removed IntervalType.isEmpty
Removed IntervalType.overlaps<I : IntervalType where I.Bound == Bound>(_: I) -> Bool
Removed IntervalType.start
Removed JoinGenerator [struct]
Removed JoinGenerator.init<Separator : SequenceType where Separator.Generator.Element == Base.Element.Generator.Element>(base: Base, separator: Separator)
Removed JoinGenerator.next() -> Base.Element.Generator.Element?
Removed JoinSequence [struct]
Removed JoinSequence.generate() -> JoinGenerator<Base.Generator>
Removed JoinSequence.init<Separator : SequenceType where Separator.Generator.Element == Base.Generator.Element.Generator.Element>(base: Base, separator: Separator)
Removed LazyCollection.count
Removed LazyCollection.generate() -> Base.Generator
Removed LazyCollection.init(_: Base)
Removed LazyCollection.subscript(_: Base.Index) -> Base.Generator.Element
Removed LazyCollection.underestimateCount() -> Int
Removed LazyCollectionType
Removed LazyCollectionType.elements
Removed LazyCollectionType.filter(_: (Self.Elements.Generator.Element) -> Bool) -> LazyFilterCollection<Self.Elements>
Removed LazyCollectionType.flatMap<Intermediate : CollectionType>(_: (Self.Elements.Generator.Element) -> Intermediate) -> LazyCollection<FlattenCollection<LazyMapCollection<Self.Elements, Intermediate>>>
Removed LazyCollectionType.flatMap<Intermediate : CollectionType where Intermediate.Index : BidirectionalIndexType>(_: (Self.Elements.Generator.Element) -> Intermediate) -> LazyCollection<FlattenBidirectionalCollection<LazyMapCollection<Self.Elements, Intermediate>>>
Removed LazyCollectionType.flatten() -> LazyCollection<FlattenBidirectionalCollection<Self.Elements>>
Removed LazyCollectionType.flatten() -> LazyCollection<FlattenCollection<Self.Elements>>
Removed LazyCollectionType.lazy
Removed LazyCollectionType.map<U>(_: (Self.Elements.Generator.Element) -> U) -> LazyMapCollection<Self.Elements, U>
Removed LazyCollectionType.reverse() -> LazyCollection<ReverseCollection<Self.Elements>>
Removed LazyCollectionType.reverse() -> LazyCollection<ReverseRandomAccessCollection<Self.Elements>>
Removed LazyFilterCollection.generate() -> LazyFilterGenerator<Base.Generator>
Removed LazyFilterCollection.init(_: Base, whereElementsSatisfy: (Base.Generator.Element) -> Bool)
Removed LazyFilterCollection.subscript(_: LazyFilterIndex<Base>) -> Base.Generator.Element
Removed LazyFilterGenerator [struct]
Removed LazyFilterGenerator.base
Removed LazyFilterGenerator.init(_: Base, whereElementsSatisfy: (Base.Element) -> Bool)
Removed LazyFilterGenerator.next() -> Base.Element?
Removed LazyFilterIndex.successor() -> LazyFilterIndex<BaseElements>
Removed LazyFilterSequence.generate() -> LazyFilterGenerator<Base.Generator>
Removed LazyFilterSequence.init(_: Base, whereElementsSatisfy: (Base.Generator.Element) -> Bool)
Removed LazyMapCollection.count
Removed LazyMapCollection.generate() -> LazyMapGenerator<Base.Generator, Element>
Removed LazyMapCollection.init(_: Base, transform: (Base.Generator.Element) -> Element)
Removed LazyMapCollection.underestimateCount() -> Int
Removed LazyMapGenerator [struct]
Removed LazyMapGenerator.base
Removed LazyMapGenerator.next() -> Element?
Removed LazyMapSequence.generate() -> LazyMapGenerator<Base.Generator, Element>
Removed LazyMapSequence.init(_: Base, transform: (Base.Generator.Element) -> Element)
Removed LazyMapSequence.underestimateCount() -> Int
Removed LazySequence.init(_: Base)
Removed LazySequenceType
Removed LazySequenceType.array
Removed LazySequenceType.elements
Removed LazySequenceType.elements
Removed LazySequenceType.filter(_: (Self.Elements.Generator.Element) -> Bool) -> LazyFilterSequence<Self.Elements>
Removed LazySequenceType.flatMap<Intermediate : SequenceType>(_: (Self.Elements.Generator.Element) -> Intermediate) -> LazySequence<FlattenSequence<LazyMapSequence<Self.Elements, Intermediate>>>
Removed LazySequenceType.flatten() -> LazySequence<FlattenSequence<Self.Elements>>
Removed LazySequenceType.lazy
Removed LazySequenceType.map<U>(_: (Self.Elements.Generator.Element) -> U) -> LazyMapSequence<Self.Elements, U>
Removed ManagedBuffer.create(_: Int, initialValue: (ManagedProtoBuffer<Value, Element>) -> Value) -> ManagedBuffer<Value, Element> [class]
Removed ManagedBuffer.value
Removed ManagedBufferPointer.allocatedElementCount
Removed ManagedBufferPointer.holdsUniqueOrPinnedReference() -> Bool
Removed ManagedBufferPointer.holdsUniqueReference() -> Bool
Removed ManagedBufferPointer.init(bufferClass: AnyClass, minimumCapacity: Int, initialValue: (buffer: AnyObject, allocatedCount: (AnyObject) -> Int) -> Value)
Removed ManagedBufferPointer.value
Removed ManagedBufferPointer.withUnsafeMutablePointerToValue<R>(_: (UnsafeMutablePointer<Value>) -> R) -> R
Removed ManagedProtoBuffer
Removed ManagedProtoBuffer.allocatedElementCount
Removed ManagedProtoBuffer.withUnsafeMutablePointers<R>(_: (UnsafeMutablePointer<Value>, UnsafeMutablePointer<Element>) -> R) -> R
Removed ManagedProtoBuffer.withUnsafeMutablePointerToElements<R>(_: (UnsafeMutablePointer<Element>) -> R) -> R
Removed ManagedProtoBuffer.withUnsafeMutablePointerToValue<R>(_: (UnsafeMutablePointer<Value>) -> R) -> R
Removed Mirror.customMirror() -> Mirror
Removed Mirror.init<T, C : CollectionType where C.Generator.Element == Child>(_: T, children: C, displayStyle: Mirror.DisplayStyle?, ancestorRepresentation: Mirror.AncestorRepresentation)
Removed Mirror.init<T, C : CollectionType>(_: T, unlabeledChildren: C, displayStyle: Mirror.DisplayStyle?, ancestorRepresentation: Mirror.AncestorRepresentation)
Removed Mirror.superclassMirror() -> Mirror?
Removed Mirror.AncestorRepresentation.Customized
Removed Mirror.AncestorRepresentation.Generated
Removed Mirror.AncestorRepresentation.Suppressed
Removed Mirror.DisplayStyle.Class
Removed Mirror.DisplayStyle.Collection
Removed Mirror.DisplayStyle.Dictionary
Removed Mirror.DisplayStyle.Enum
Removed Mirror.DisplayStyle.Optional
Removed Mirror.DisplayStyle.Set
Removed Mirror.DisplayStyle.Struct
Removed Mirror.DisplayStyle.Tuple
Removed MirrorPathType
Removed MutableCollectionType
Removed MutableCollectionType.partition(_: Range<Self.Index>) -> Self.Index
Removed MutableCollectionType.partition(_: Range<Self.Index>, isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) -> Bool) -> Self.Index
Removed MutableCollectionType.sort() -> [Self.Generator.Element]
Removed MutableCollectionType.sort(_: (Self.Generator.Element, Self.Generator.Element) -> Bool) -> [Self.Generator.Element]
Removed MutableCollectionType.sortInPlace()
Removed MutableCollectionType.sortInPlace(_: (Self.Generator.Element, Self.Generator.Element) -> Bool)
Removed MutableCollectionType.subscript(_: Self.Index) -> Self.Generator.Element
Removed MutableCollectionType.subscript(_: Range<Self.Index>) -> MutableSlice<Self>
Removed MutableCollectionType.subscript(_: Range<Self.Index>) -> Self.SubSequence
Removed MutableSliceable
Removed MutableSliceable.subscript(_: Range<Self.Index>) -> Self.SubSequence
Removed NilLiteralConvertible
Removed NilLiteralConvertible.init(nilLiteral: ())
Removed NonObjectiveCBase
Removed NonObjectiveCBase.init()
Removed ObjectIdentifier.uintValue
Removed Optional.init()
Removed Optional.None
Removed Optional.Some
Removed OptionSetType
Removed OptionSetType.contains(_: Self) -> Bool
Removed OptionSetType.exclusiveOr(_: Self) -> Self
Removed OptionSetType.exclusiveOrInPlace(_: Self)
Removed OptionSetType.init()
Removed OptionSetType.init(rawValue: Self.RawValue)
Removed OptionSetType.insert(_: Self)
Removed OptionSetType.intersect(_: Self) -> Self
Removed OptionSetType.intersectInPlace(_: Self)
Removed OptionSetType.remove(_: Self) -> Self?
Removed OptionSetType.union(_: Self) -> Self
Removed OptionSetType.unionInPlace(_: Self)
Removed OutputStreamType
Removed OutputStreamType.write(_: String)
Removed PermutationGenerator [struct]
Removed PermutationGenerator.init(elements: C, indices: Indices)
Removed PermutationGenerator.next() -> C.Generator.Element?
Removed PlaygroundQuickLook.AttributedString
Removed PlaygroundQuickLook.BezierPath
Removed PlaygroundQuickLook.Color
Removed PlaygroundQuickLook.Double
Removed PlaygroundQuickLook.Float
Removed PlaygroundQuickLook.Image
Removed PlaygroundQuickLook.Int
Removed PlaygroundQuickLook.Logical
Removed PlaygroundQuickLook.Point
Removed PlaygroundQuickLook.Range
Removed PlaygroundQuickLook.Rectangle
Removed PlaygroundQuickLook.Size
Removed PlaygroundQuickLook.Sound
Removed PlaygroundQuickLook.Sprite
Removed PlaygroundQuickLook.Text
Removed PlaygroundQuickLook.UInt
Removed PlaygroundQuickLook.URL
Removed PlaygroundQuickLook.View
Removed Process [enum]
Removed Process.argc
Removed Process.arguments
Removed Process.unsafeArgv
Removed RandomAccessIndexType
Removed RandomAccessIndexType.advancedBy(_: Self.Distance) -> Self
Removed RandomAccessIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed RandomAccessIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed RandomAccessIndexType.distanceTo(_: Self) -> Self.Distance
Removed Range.endIndex
Removed Range.generate() -> RangeGenerator<Element>
Removed Range.init(start: Element, end: Element)
Removed Range.startIndex
Removed Range.subscript(_: Element) -> Element
Removed Range.subscript(_: Element._DisabledRangeIndex) -> Element
Removed RangeGenerator [struct]
Removed RangeGenerator.endIndex
Removed RangeGenerator.init(_: Range<Element>)
Removed RangeGenerator.next() -> Element?
Removed RangeGenerator.startIndex
Removed RangeReplaceableCollectionType
Removed RangeReplaceableCollectionType.append(_: Self.Generator.Element)
Removed RangeReplaceableCollectionType.append(_: Self.Generator.Element)
Removed RangeReplaceableCollectionType.appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Removed RangeReplaceableCollectionType.appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Removed RangeReplaceableCollectionType.init()
Removed RangeReplaceableCollectionType.init<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Removed RangeReplaceableCollectionType.init<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Removed RangeReplaceableCollectionType.insert(_: Self.Generator.Element, atIndex: Self.Index)
Removed RangeReplaceableCollectionType.insert(_: Self.Generator.Element, atIndex: Self.Index)
Removed RangeReplaceableCollectionType.insertContentsOf<S : CollectionType where S.Generator.Element == Generator.Element>(_: S, at: Self.Index)
Removed RangeReplaceableCollectionType.insertContentsOf<C : CollectionType where C.Generator.Element == Generator.Element>(_: C, at: Self.Index)
Removed RangeReplaceableCollectionType.removeAll(keepCapacity: Bool)
Removed RangeReplaceableCollectionType.removeAll(keepCapacity: Bool)
Removed RangeReplaceableCollectionType.removeAtIndex(_: Self.Index) -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeAtIndex(_: Self.Index) -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst(_: Int)
Removed RangeReplaceableCollectionType.removeFirst(_: Int)
Removed RangeReplaceableCollectionType.removeFirst(_: Int)
Removed RangeReplaceableCollectionType.removeLast() -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeLast(_: Int)
Removed RangeReplaceableCollectionType.removeRange(_: Range<Self.Index>)
Removed RangeReplaceableCollectionType.removeRange(_: Range<Self.Index>)
Removed RangeReplaceableCollectionType.replaceRange<C : CollectionType where C.Generator.Element == Generator.Element>(_: Range<Self.Index>, with: C)
Removed RangeReplaceableCollectionType.reserveCapacity(_: Self.Index.Distance)
Removed RangeReplaceableCollectionType.reserveCapacity(_: Self.Index.Distance)
Removed RawByte [struct]
Removed Repeat [struct]
Removed Repeat.count
Removed Repeat.endIndex
Removed Repeat.init(count: Int, repeatedValue: Element)
Removed Repeat.repeatedValue
Removed Repeat.startIndex
Removed Repeat.subscript(_: Int) -> Element
Removed ReverseCollection [struct]
Removed ReverseCollection.init(_: Base)
Removed ReverseIndex [struct]
Removed ReverseIndex.base
Removed ReverseIndex.init(_: Base)
Removed ReverseIndexType
Removed ReverseIndexType.base
Removed ReverseIndexType.init(_: Self.Base)
Removed ReverseRandomAccessCollection [struct]
Removed ReverseRandomAccessCollection.init(_: Base)
Removed ReverseRandomAccessIndex [struct]
Removed ReverseRandomAccessIndex.advancedBy(_: Base.Distance) -> ReverseRandomAccessIndex<Base>
Removed ReverseRandomAccessIndex.base
Removed ReverseRandomAccessIndex.distanceTo(_: ReverseRandomAccessIndex<Base>) -> Base.Distance
Removed ReverseRandomAccessIndex.init(_: Base)
Removed SequenceType
Removed SequenceType.contains(_: Self.Generator.Element) -> Bool
Removed SequenceType.contains(_: (Self.Generator.Element) throws -> Bool) rethrows -> Bool
Removed SequenceType.dropFirst() -> Self.SubSequence
Removed SequenceType.dropFirst(_: Int) -> Self.SubSequence
Removed SequenceType.dropFirst(_: Int) -> AnySequence<Self.Generator.Element>
Removed SequenceType.dropLast() -> Self.SubSequence
Removed SequenceType.dropLast(_: Int) -> AnySequence<Self.Generator.Element>
Removed SequenceType.dropLast(_: Int) -> Self.SubSequence
Removed SequenceType.elementsEqual<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence) -> Bool
Removed SequenceType.elementsEqual<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence, isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool
Removed SequenceType.enumerate() -> EnumerateSequence<Self>
Removed SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Removed SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Removed SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Removed SequenceType.flatMap<T>(_: (Self.Generator.Element) throws -> T?) rethrows -> [T]
Removed SequenceType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
Removed SequenceType.flatten() -> FlattenSequence<Self>
Removed SequenceType.forEach(_: (Self.Generator.Element) throws -> Void) rethrows
Removed SequenceType.forEach(_: (Self.Generator.Element) throws -> Void) rethrows
Removed SequenceType.generate() -> Self.Generator
Removed SequenceType.generate() -> Self.Generator
Removed SequenceType.generate() -> Self
Removed SequenceType.joinWithSeparator(_: String) -> String
Removed SequenceType.joinWithSeparator<Separator : SequenceType where Separator.Generator.Element == Generator.Element.Generator.Element>(_: Separator) -> JoinSequence<Self>
Removed SequenceType.lazy
Removed SequenceType.lexicographicalCompare<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence) -> Bool
Removed SequenceType.lexicographicalCompare<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence, isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool
Removed SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed SequenceType.maxElement() -> Self.Generator.Element?
Removed SequenceType.maxElement(_: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element?
Removed SequenceType.minElement() -> Self.Generator.Element?
Removed SequenceType.minElement(_: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element?
Removed SequenceType.prefix(_: Int) -> AnySequence<Self.Generator.Element>
Removed SequenceType.prefix(_: Int) -> Self.SubSequence
Removed SequenceType.reduce<T>(_: T, combine: (T, Self.Generator.Element) throws -> T) rethrows -> T
Removed SequenceType.reverse() -> [Self.Generator.Element]
Removed SequenceType.sort() -> [Self.Generator.Element]
Removed SequenceType.sort(_: (Self.Generator.Element, Self.Generator.Element) -> Bool) -> [Self.Generator.Element]
Removed SequenceType.split(_: Int, allowEmptySlices: Bool, isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [AnySequence<Self.Generator.Element>]
Removed SequenceType.split(_: Int, allowEmptySlices: Bool, isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Removed SequenceType.split(_: Self.Generator.Element, maxSplit: Int, allowEmptySlices: Bool) -> [AnySequence<Self.Generator.Element>]
Removed SequenceType.startsWith<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence) -> Bool
Removed SequenceType.startsWith<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence, isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool
Removed SequenceType.suffix(_: Int) -> AnySequence<Self.Generator.Element>
Removed SequenceType.suffix(_: Int) -> Self.SubSequence
Removed SequenceType.underestimateCount() -> Int
Removed SequenceType.underestimateCount() -> Int
Removed SequenceType.underestimateCount() -> Int
Removed Set.exclusiveOr<S : SequenceType where S.Generator.Element == Element>(_: S) -> Set<Element>
Removed Set.exclusiveOrInPlace<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed Set.generate() -> SetGenerator<Element>
Removed Set.indexOf(_: Element) -> SetIndex<Element>?
Removed Set.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed Set.intersect<S : SequenceType where S.Generator.Element == Element>(_: S) -> Set<Element>
Removed Set.intersectInPlace<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed Set.isDisjointWith<S : SequenceType where S.Generator.Element == Element>(_: S) -> Bool
Removed Set.isStrictSubsetOf<S : SequenceType where S.Generator.Element == Element>(_: S) -> Bool
Removed Set.isStrictSupersetOf<S : SequenceType where S.Generator.Element == Element>(_: S) -> Bool
Removed Set.isSubsetOf<S : SequenceType where S.Generator.Element == Element>(_: S) -> Bool
Removed Set.isSupersetOf<S : SequenceType where S.Generator.Element == Element>(_: S) -> Bool
Removed Set.removeAll(keepCapacity: Bool)
Removed Set.removeAtIndex(_: SetIndex<Element>) -> Element
Removed Set.subtract<S : SequenceType where S.Generator.Element == Element>(_: S) -> Set<Element>
Removed Set.subtractInPlace<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed Set.union<S : SequenceType where S.Generator.Element == Element>(_: S) -> Set<Element>
Removed Set.unionInPlace<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed SetAlgebraType
Removed SetAlgebraType.contains(_: Self.Element) -> Bool
Removed SetAlgebraType.element(_: Self.Element, isDisjointWith: Self.Element) -> Bool [class]
Removed SetAlgebraType.element(_: Self.Element, isDisjointWith: Self.Element) -> Bool [class]
Removed SetAlgebraType.element(_: Self.Element, subsumes: Self.Element) -> Bool [class]
Removed SetAlgebraType.element(_: Self.Element, subsumes: Self.Element) -> Bool [class]
Removed SetAlgebraType.exclusiveOr(_: Self) -> Self
Removed SetAlgebraType.exclusiveOrInPlace(_: Self)
Removed SetAlgebraType.init()
Removed SetAlgebraType.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed SetAlgebraType.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed SetAlgebraType.init(arrayLiteral: Self.Element)
Removed SetAlgebraType.insert(_: Self.Element)
Removed SetAlgebraType.intersect(_: Self) -> Self
Removed SetAlgebraType.intersectInPlace(_: Self)
Removed SetAlgebraType.isDisjointWith(_: Self) -> Bool
Removed SetAlgebraType.isDisjointWith(_: Self) -> Bool
Removed SetAlgebraType.isEmpty
Removed SetAlgebraType.isEmpty
Removed SetAlgebraType.isStrictSubsetOf(_: Self) -> Bool
Removed SetAlgebraType.isStrictSupersetOf(_: Self) -> Bool
Removed SetAlgebraType.isSubsetOf(_: Self) -> Bool
Removed SetAlgebraType.isSubsetOf(_: Self) -> Bool
Removed SetAlgebraType.isSupersetOf(_: Self) -> Bool
Removed SetAlgebraType.isSupersetOf(_: Self) -> Bool
Removed SetAlgebraType.remove(_: Self.Element) -> Self.Element?
Removed SetAlgebraType.subtract(_: Self) -> Self
Removed SetAlgebraType.subtract(_: Self) -> Self
Removed SetAlgebraType.subtractInPlace(_: Self)
Removed SetAlgebraType.subtractInPlace(_: Self)
Removed SetAlgebraType.union(_: Self) -> Self
Removed SetAlgebraType.unionInPlace(_: Self)
Removed SetGenerator [struct]
Removed SetGenerator.next() -> Element?
Removed SetIndex.successor() -> SetIndex<Element>
Removed SignedIntegerType
Removed SignedIntegerType.init(_: IntMax)
Removed SignedIntegerType.toIntMax() -> IntMax
Removed SignedNumberType
Removed SignedNumberType.-(_: Self) -> Self
Removed SignedNumberType.-(_: Self, _: Self) -> Self
Removed StaticString.byteSize
Removed StaticString.init(_builtinExtendedGraphemeClusterLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)
Removed StaticString.init(_builtinStringLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)
Removed StaticString.init(_builtinUnicodeScalarLiteral: Builtin.Int32)
Removed StaticString.stringValue
Removed Streamable
Removed Streamable.writeTo<Target : OutputStreamType>(_: Target)
Removed Strideable.advancedBy(_: Self.Stride) -> Self
Removed Strideable.distanceTo(_: Self) -> Self.Stride
Removed Strideable.stride(through: Self, by: Self.Stride) -> StrideThrough<Self>
Removed Strideable.stride(to: Self, by: Self.Stride) -> StrideTo<Self>
Removed StrideThrough.generate() -> StrideThroughGenerator<Element>
Removed StrideThroughGenerator [struct]
Removed StrideThroughGenerator.next() -> Element?
Removed StrideTo.generate() -> StrideToGenerator<Element>
Removed StrideToGenerator [struct]
Removed StrideToGenerator.next() -> Element?
Removed String.append(_: UnicodeScalar)
Removed String.appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed String.appendContentsOf(_: String)
Removed String.fromCString(_: UnsafePointer<CChar>) -> String? [static]
Removed String.fromCStringRepairingIllFormedUTF8(_: UnsafePointer<CChar>) -> (String?, hadError: Bool) [static]
Removed String.init<T : _SignedIntegerType>(_: T)
Removed String.init<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed String.init<T>(_: T)
Removed String.init<T : UnsignedIntegerType>(_: T)
Removed String.init<T : UnsignedIntegerType>(_: T, radix: Int, uppercase: Bool)
Removed String.init<T : _SignedIntegerType>(_: T, radix: Int, uppercase: Bool)
Removed String.init(_builtinExtendedGraphemeClusterLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)
Removed String.init(_builtinStringLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)
Removed String.init(_builtinUnicodeScalarLiteral: Builtin.Int32)
Removed String.init(_builtinUTF16StringLiteral: Builtin.RawPointer, numberOfCodeUnits: Builtin.Word)
Removed String.init(count: Int, repeatedValue: Character)
Removed String.init(count: Int, repeatedValue: UnicodeScalar)
Removed String.insert(_: Character, atIndex: Index)
Removed String.insertContentsOf<S : CollectionType where S.Generator.Element == Character>(_: S, at: Index)
Removed String.lowercaseString
Removed String.nulTerminatedUTF8
Removed String.removeAll(keepCapacity: Bool)
Removed String.removeAtIndex(_: Index) -> Character
Removed String.removeRange(_: Range<Index>)
Removed String.replaceRange(_: Range<Index>, with: String)
Removed String.replaceRange<C : CollectionType where C.Generator.Element == Character>(_: Range<Index>, with: C)
Removed String.uppercaseString
Removed String.writeTo<Target : OutputStreamType>(_: Target)
Removed String.CharacterView.appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed String.CharacterView.init<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed String.CharacterView.replaceRange<C : CollectionType where C.Generator.Element == Character>(_: Range<String.CharacterView.Index>, with: C)
Removed String.CharacterView.Index.predecessor() -> String.CharacterView.Index
Removed String.CharacterView.Index.successor() -> String.CharacterView.Index
Removed String.UnicodeScalarView.appendContentsOf<S : SequenceType where S.Generator.Element == UnicodeScalar>(_: S)
Removed String.UnicodeScalarView.generate() -> String.UnicodeScalarView.Generator
Removed String.UnicodeScalarView.replaceRange<C : CollectionType where C.Generator.Element == UnicodeScalar>(_: Range<String.UnicodeScalarView.Index>, with: C)
Removed String.UnicodeScalarView.Generator [struct]
Removed String.UnicodeScalarView.Generator.next() -> UnicodeScalar?
Removed String.UnicodeScalarView.Index.predecessor() -> String.UnicodeScalarView.Index
Removed String.UnicodeScalarView.Index.successor() -> String.UnicodeScalarView.Index
Removed String.UTF16View.Index.advancedBy(_: Distance) -> String.UTF16View.Index
Removed String.UTF16View.Index.advancedBy(_: Distance, limit: String.UTF16View.Index) -> String.UTF16View.Index
Removed String.UTF16View.Index.distanceTo(_: String.UTF16View.Index) -> Distance
Removed String.UTF16View.Index.predecessor() -> String.UTF16View.Index
Removed String.UTF16View.Index.samePositionIn(_: String.UnicodeScalarView) -> UnicodeScalarIndex?
Removed String.UTF16View.Index.samePositionIn(_: String.UTF8View) -> String.UTF8View.Index?
Removed String.UTF16View.Index.samePositionIn(_: String) -> Index?
Removed String.UTF16View.Index.successor() -> String.UTF16View.Index
Removed String.UTF8View.Index.samePositionIn(_: String) -> Index?
Removed String.UTF8View.Index.samePositionIn(_: String.UnicodeScalarView) -> UnicodeScalarIndex?
Removed String.UTF8View.Index.samePositionIn(_: String.UTF16View) -> String.UTF16View.Index?
Removed String.UTF8View.Index.successor() -> String.UTF8View.Index
Removed StringInterpolationConvertible
Removed StringInterpolationConvertible.init(stringInterpolation: Self)
Removed StringInterpolationConvertible.init<T>(stringInterpolationSegment: T)
Removed StringLiteralConvertible
Removed StringLiteralConvertible.init(stringLiteral: Self.StringLiteralType)
Removed UInt.advancedBy(_: Distance) -> UInt
Removed UInt.distanceTo(_: UInt) -> Distance
Removed UInt.init(_: Builtin.Word)
Removed UInt.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed UInt.predecessor() -> UInt
Removed UInt.successor() -> UInt
Removed UInt16.advancedBy(_: Distance) -> UInt16
Removed UInt16.distanceTo(_: UInt16) -> Distance
Removed UInt16.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed UInt16.predecessor() -> UInt16
Removed UInt16.successor() -> UInt16
Removed UInt32.advancedBy(_: Distance) -> UInt32
Removed UInt32.distanceTo(_: UInt32) -> Distance
Removed UInt32.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed UInt32.predecessor() -> UInt32
Removed UInt32.successor() -> UInt32
Removed UInt64.advancedBy(_: Distance) -> UInt64
Removed UInt64.distanceTo(_: UInt64) -> Distance
Removed UInt64.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed UInt64.predecessor() -> UInt64
Removed UInt64.successor() -> UInt64
Removed UInt8.advancedBy(_: Distance) -> UInt8
Removed UInt8.distanceTo(_: UInt8) -> Distance
Removed UInt8.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed UInt8.predecessor() -> UInt8
Removed UInt8.successor() -> UInt8
Removed UnicodeCodecType
Removed UnicodeCodecType.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed UnicodeCodecType.encode(_: UnicodeScalar, output: (Self.CodeUnit) -> Void) [class]
Removed UnicodeCodecType.init()
Removed UnicodeDecodingResult.EmptyInput
Removed UnicodeDecodingResult.Error
Removed UnicodeDecodingResult.isEmptyInput() -> Bool
Removed UnicodeDecodingResult.Result
Removed UnicodeScalar.escape(asASCII: Bool) -> String
Removed UnicodeScalar.init()
Removed UnicodeScalar.init(_builtinUnicodeScalarLiteral: Builtin.Int32)
Removed UnicodeScalar.isASCII() -> Bool
Removed UnicodeScalar.writeTo<Target : OutputStreamType>(_: Target)
Removed UnicodeScalarIndex.samePositionIn(_: String.UTF16View) -> String.UTF16View.Index
Removed UnicodeScalarIndex.samePositionIn(_: String.UTF8View) -> String.UTF8View.Index
Removed UnicodeScalarIndex.samePositionIn(_: String) -> Index?
Removed UnicodeScalarLiteralConvertible
Removed UnicodeScalarLiteralConvertible.init(unicodeScalarLiteral: Self.UnicodeScalarLiteralType)
Removed Unmanaged.toOpaque() -> COpaquePointer
Removed UnsafeBufferPointer.generate() -> UnsafeBufferPointerGenerator<Element>
Removed UnsafeBufferPointerGenerator [struct]
Removed UnsafeBufferPointerGenerator.next() -> Element?
Removed UnsafeMutableBufferPointer.generate() -> UnsafeBufferPointerGenerator<Element>
Removed UnsafeMutablePointer.advancedBy(_: Int) -> UnsafeMutablePointer<Memory>
Removed UnsafeMutablePointer.alloc(_: Int) -> UnsafeMutablePointer<Memory> [static]
Removed UnsafeMutablePointer.assignBackwardFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafeMutablePointer.assignFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafeMutablePointer.dealloc(_: Int)
Removed UnsafeMutablePointer.destroy()
Removed UnsafeMutablePointer.destroy(_: Int)
Removed UnsafeMutablePointer.distanceTo(_: UnsafeMutablePointer<Memory>) -> Int
Removed UnsafeMutablePointer.init()
Removed UnsafeMutablePointer.init<U>(_: UnsafeMutablePointer<U>)
Removed UnsafeMutablePointer.init<U>(_: UnsafePointer<U>)
Removed UnsafeMutablePointer.init(nilLiteral: ())
Removed UnsafeMutablePointer.initialize(_: Memory)
Removed UnsafeMutablePointer.initializeFrom<C : CollectionType where C.Generator.Element == Memory>(_: C)
Removed UnsafeMutablePointer.initializeFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafeMutablePointer.memory
Removed UnsafeMutablePointer.moveAssignFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafeMutablePointer.moveInitializeBackwardFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafeMutablePointer.moveInitializeFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafePointer.advancedBy(_: Int) -> UnsafePointer<Memory>
Removed UnsafePointer.distanceTo(_: UnsafePointer<Memory>) -> Int
Removed UnsafePointer.init()
Removed UnsafePointer.init<U>(_: UnsafeMutablePointer<U>)
Removed UnsafePointer.init<U>(_: UnsafePointer<U>)
Removed UnsafePointer.init(nilLiteral: ())
Removed UnsafePointer.memory
Removed UnsignedIntegerType
Removed UnsignedIntegerType.init(_: UIntMax)
Removed UnsignedIntegerType.toUIntMax() -> UIntMax
Removed UTF16.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed UTF16.encode(_: UnicodeScalar, output: (CodeUnit) -> Void) [static]
Removed UTF16.measure<Encoding : UnicodeCodecType, Input : GeneratorType where Encoding.CodeUnit == Input.Element>(_: Encoding.Type, input: Input, repairIllFormedSequences: Bool) -> (Int, Bool)? [static]
Removed UTF32.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed UTF32.encode(_: UnicodeScalar, output: (CodeUnit) -> Void) [static]
Removed UTF8.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed UTF8.encode(_: UnicodeScalar, output: (CodeUnit) -> Void) [static]
Removed VaListBuilder
Removed Zip2Generator [struct]
Removed Zip2Generator.init(_: Generator1, _: Generator2)
Removed Zip2Generator.next() -> (Generator1.Element, Generator2.Element)?
Removed Zip2Sequence.generate() -> Zip2Generator<Sequence1.Generator, Sequence2.Generator>
Removed Zip2Sequence.init(_: Sequence1, _: Sequence2)
Removed !(_: Bool) -> Bool
Removed !(_: T) -> Bool
Removed !=(_: Float, _: Float) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !=(_: [Key : Value], _: [Key : Value]) -> Bool
Removed !=(_: Double, _: Double) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !==(_: L, _: R) -> Bool
Removed %(_: T, _: T) -> T
Removed %(_: Double, _: Double) -> Double
Removed %(_: Float, _: Float) -> Float
Removed %=(_: T, _: T)
Removed %=(_: Double, _: Double)
Removed %=(_: Float, _: Float)
Removed &&(_: T, _: () throws -> Bool) rethrows -> Bool
Removed &&(_: T, _: () throws -> U) rethrows -> Bool
Removed &*(_: T, _: T) -> T
Removed &+(_: T, _: T) -> T
Removed &-(_: T, _: T) -> T
Removed &=(_: T, _: T)
Removed *(_: T, _: T) -> T
Removed *=(_: T, _: T)
Removed +(_: T) -> T
Removed +(_: T, _: T._DisallowMixedSignArithmetic) -> T
Removed +(_: S, _: C) -> C
Removed +(_: C, _: S) -> C
Removed +(_: T._DisallowMixedSignArithmetic, _: T) -> T
Removed +(_: T, _: T) -> T
Removed +(_: RRC1, _: RRC2) -> RRC1
Removed +(_: String, _: String) -> String
Removed +(_: C, _: S) -> C
Removed ++(_: T) -> T
Removed ++(_: Int64) -> Int64
Removed ++(_: UInt) -> UInt
Removed ++(_: UInt16) -> UInt16
Removed ++(_: Float) -> Float
Removed ++(_: Int32) -> Int32
Removed ++(_: T) -> T
Removed ++(_: Int16) -> Int16
Removed ++(_: UInt8) -> UInt8
Removed ++(_: Int64) -> Int64
Removed ++(_: UInt64) -> UInt64
Removed ++(_: UInt32) -> UInt32
Removed ++(_: Int8) -> Int8
Removed ++(_: Int32) -> Int32
Removed ++(_: UInt) -> UInt
Removed ++(_: Double) -> Double
Removed ++(_: UInt16) -> UInt16
Removed ++(_: Int) -> Int
Removed ++(_: UInt64) -> UInt64
Removed ++(_: Int) -> Int
Removed ++(_: Float) -> Float
Removed ++(_: Int16) -> Int16
Removed ++(_: Int8) -> Int8
Removed ++(_: UInt32) -> UInt32
Removed ++(_: UInt8) -> UInt8
Removed ++(_: Double) -> Double
Removed +=(_: ContiguousArray<Element>, _: S)
Removed +=(_: _ContiguousArrayBuffer<Element>, _: C)
Removed +=(_: T, _: T)
Removed +=(_: ArraySlice<Element>, _: S)
Removed +=(_: [Element], _: C)
Removed +=(_: T, _: T._DisallowMixedSignArithmetic)
Removed +=(_: ContiguousArray<Element>, _: C)
Removed +=(_: ArraySlice<Element>, _: C)
Removed +=(_: [Element], _: S)
Removed +=(_: String, _: String)
Removed -(_: T) -> T
Removed -(_: T, _: T) -> T
Removed --(_: Float) -> Float
Removed --(_: UInt32) -> UInt32
Removed --(_: Double) -> Double
Removed --(_: T) -> T
Removed --(_: Int64) -> Int64
Removed --(_: UInt64) -> UInt64
Removed --(_: UInt64) -> UInt64
Removed --(_: Int) -> Int
Removed --(_: Int64) -> Int64
Removed --(_: T) -> T
Removed --(_: UInt8) -> UInt8
Removed --(_: UInt16) -> UInt16
Removed --(_: Int16) -> Int16
Removed --(_: UInt) -> UInt
Removed --(_: Float) -> Float
Removed --(_: Int16) -> Int16
Removed --(_: UInt32) -> UInt32
Removed --(_: Int8) -> Int8
Removed --(_: Int32) -> Int32
Removed --(_: Int8) -> Int8
Removed --(_: Double) -> Double
Removed --(_: Int) -> Int
Removed --(_: UInt16) -> UInt16
Removed --(_: UInt8) -> UInt8
Removed --(_: Int32) -> Int32
Removed --(_: UInt) -> UInt
Removed -=(_: T, _: T._DisallowMixedSignArithmetic)
Removed -=(_: T, _: T)
Removed ...(_: Pos, _: Pos) -> Range<Pos>
Removed ...(_: Pos, _: Pos) -> Range<Pos>
Removed ...(_: Bound, _: Bound) -> ClosedInterval<Bound>
Removed ..<(_: Bound, _: Bound) -> HalfOpenInterval<Bound>
Removed ..<(_: Pos, _: Pos) -> Range<Pos>
Removed ..<(_: Pos, _: Pos) -> Range<Pos>
Removed /(_: T, _: T) -> T
Removed /=(_: T, _: T)
Removed <(_: T, _: T) -> Bool
Removed <(_: Float, _: Float) -> Bool
Removed <(_: ObjectIdentifier, _: ObjectIdentifier) -> Bool
Removed <(_: Double, _: Double) -> Bool
Removed <(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> Bool
Removed <(_: Character, _: Character) -> Bool
Removed <(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool
Removed <(_: Index, _: Index) -> Bool
Removed <(_: T?, _: T?) -> Bool
Removed <(_: String, _: String) -> Bool
Removed <(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool
Removed <(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool
Removed <(_: UnicodeScalar, _: UnicodeScalar) -> Bool
Removed <(_: Bit, _: Bit) -> Bool
Removed <(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool
Removed <=(_: Double, _: Double) -> Bool
Removed <=(_: Float, _: Float) -> Bool
Removed <=(_: T, _: T) -> Bool
Removed <=(_: T?, _: T?) -> Bool
Removed ==(_: String.UTF8View.Index, _: String.UTF8View.Index) -> Bool
Removed ==(_: Double, _: Double) -> Bool
Removed ==(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Removed ==(_: Bool, _: Bool) -> Bool
Removed ==(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool
Removed ==(_: AnyForwardIndex, _: AnyForwardIndex) -> Bool
Removed ==(_: Index, _: Index) -> Bool
Removed ==(_: FlattenCollectionIndex<BaseElements>, _: FlattenCollectionIndex<BaseElements>) -> Bool
Removed ==(_: ObjectIdentifier, _: ObjectIdentifier) -> Bool
Removed ==(_: ClosedInterval<Bound>, _: ClosedInterval<Bound>) -> Bool
Removed ==(_: [Key : Value], _: [Key : Value]) -> Bool
Removed ==(_: Set<Element>, _: Set<Element>) -> Bool
Removed ==(_: COpaquePointer, _: COpaquePointer) -> Bool
Removed ==(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> Bool
Removed ==(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool
Removed ==(_: FlattenBidirectionalCollectionIndex<BaseElements>, _: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool
Removed ==(_: ReverseIndex<Base>, _: ReverseIndex<Base>) -> Bool
Removed ==(_: HalfOpenInterval<Bound>, _: HalfOpenInterval<Bound>) -> Bool
Removed ==(_: String, _: String) -> Bool
Removed ==(_: Range<Element>, _: Range<Element>) -> Bool
Removed ==(_: Character, _: Character) -> Bool
Removed ==(_: AnyRandomAccessIndex, _: AnyRandomAccessIndex) -> Bool
Removed ==(_: UnicodeScalar, _: UnicodeScalar) -> Bool
Removed ==(_: ManagedBufferPointer<Value, Element>, _: ManagedBufferPointer<Value, Element>) -> Bool
Removed ==(_: T, _: T) -> Bool
Removed ==(_: Float, _: Float) -> Bool
Removed ==(_: AnyBidirectionalIndex, _: AnyBidirectionalIndex) -> Bool
Removed ==(_: Bit, _: Bit) -> Bool
Removed ==(_: T, _: T) -> Bool
Removed ==(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool
Removed ==(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool
Removed ===(_: L, _: R) -> Bool
Removed >(_: Float, _: Float) -> Bool
Removed >(_: T, _: T) -> Bool
Removed >(_: T?, _: T?) -> Bool
Removed >(_: Double, _: Double) -> Bool
Removed >=(_: T?, _: T?) -> Bool
Removed >=(_: T, _: T) -> Bool
Removed >=(_: Double, _: Double) -> Bool
Removed >=(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> Bool
Removed >=(_: Float, _: Float) -> Bool
Removed ^=(_: T, _: T)
Removed abs<T : SignedNumberType>(_: T) -> T
Removed alignof<T>(_: T.Type) -> Int
Removed alignofValue<T>(_: T) -> Int
Removed Any
Removed AnyBidirectionalIndex.Distance
Removed AnyForwardIndex.Distance
Removed anyGenerator<Element>(_: () -> Element?) -> AnyGenerator<Element>
Removed anyGenerator<G : GeneratorType>(_: G) -> AnyGenerator<G.Element>
Removed AnyRandomAccessIndex.Distance
Removed ArrayLiteralConvertible.Element
Removed Bit.Distance
Removed BooleanLiteralConvertible.BooleanLiteralType
Removed CollectionType.Generator
Removed CollectionType.SubSequence
Removed debugPrint<Target : OutputStreamType>(_: Any, separator: String, terminator: String, toStream: Target)
Removed DictionaryLiteralConvertible.Key
Removed DictionaryLiteralConvertible.Value
Removed dump<T, TargetStream : OutputStreamType>(_: T, _: TargetStream, name: String?, indent: Int, maxDepth: Int, maxItems: Int) -> T
Removed EnumerateGenerator.Element
Removed ExtendedGraphemeClusterLiteralConvertible.ExtendedGraphemeClusterLiteralType
Removed FloatLiteralConvertible.FloatLiteralType
Removed ForwardIndexType.Distance
Removed GeneratorType.Element
Removed Indexable.Index
Removed Int.Distance
Removed Int16.Distance
Removed Int32.Distance
Removed Int64.Distance
Removed Int8.Distance
Removed IntegerLiteralConvertible.IntegerLiteralType
Removed IntervalType.Bound
Removed isUniquelyReferenced<T : NonObjectiveCBase>(_: T) -> Bool
Removed isUniquelyReferencedNonObjC<T : AnyObject>(_: T) -> Bool
Removed isUniquelyReferencedNonObjC<T : AnyObject>(_: T?) -> Bool
Removed LazyCollectionType.Elements
Removed LazySequenceType.Elements
Removed MutableCollectionType.SubSequence
Removed numericCast<T : UnsignedIntegerType, U : UnsignedIntegerType>(_: T) -> U
Removed numericCast<T : _SignedIntegerType, U : _SignedIntegerType>(_: T) -> U
Removed numericCast<T : _SignedIntegerType, U : UnsignedIntegerType>(_: T) -> U
Removed numericCast<T : UnsignedIntegerType, U : _SignedIntegerType>(_: T) -> U
Removed OptionSetType.Element
Removed PermutationGenerator.Element
Removed print<Target : OutputStreamType>(_: Any, separator: String, terminator: String, toStream: Target)
Removed readLine(stripNewline: Bool) -> String?
Removed Repeat.Index
Removed ReverseCollection.Generator
Removed ReverseCollection.Index
Removed ReverseIndex.Distance
Removed ReverseIndexType.Base
Removed ReverseIndexType.Distance
Removed ReverseRandomAccessCollection.Generator
Removed ReverseRandomAccessCollection.Index
Removed ReverseRandomAccessIndex.Distance
Removed SequenceType.Generator
Removed SequenceType.SubSequence
Removed SetAlgebraType.Element
Removed sizeof<T>(_: T.Type) -> Int
Removed sizeofValue<T>(_: T) -> Int
Removed strideof<T>(_: T.Type) -> Int
Removed strideofValue<T>(_: T) -> Int
Removed String.UTF16View.Index.Distance
Removed StringLiteralConvertible.StringLiteralType
Removed transcode<Input : GeneratorType, InputEncoding : UnicodeCodecType, OutputEncoding : UnicodeCodecType where InputEncoding.CodeUnit == Input.Element>(_: InputEncoding.Type, _: OutputEncoding.Type, _: Input, _: (OutputEncoding.CodeUnit) -> Void, stopOnError: Bool) -> Bool
Removed UInt.Distance
Removed UInt16.Distance
Removed UInt32.Distance
Removed UInt64.Distance
Removed UInt8.Distance
Removed UnicodeCodecType.CodeUnit
Removed UnicodeScalarLiteralConvertible.UnicodeScalarLiteralType
Removed unsafeAddressOf(_: AnyObject) -> UnsafePointer<Void>
Removed unsafeBitCast<T, U>(_: T, _: U.Type) -> U
Removed unsafeDowncast<T : AnyObject>(_: AnyObject) -> T
Removed unsafeUnwrap<T>(_: T?) -> T
Removed withUnsafeMutablePointer<T, Result>(_: T, _: UnsafeMutablePointer<T> throws -> Result) rethrows -> Result
Removed withUnsafeMutablePointers<A0, A1, Result>(_: A0, _: A1, _: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>) throws -> Result) rethrows -> Result
Removed withUnsafeMutablePointers<A0, A1, A2, Result>(_: A0, _: A1, _: A2, _: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>, UnsafeMutablePointer<A2>) throws -> Result) rethrows -> Result
Removed withUnsafePointer<T, Result>(_: T, _: UnsafePointer<T> throws -> Result) rethrows -> Result
Removed withUnsafePointers<A0, A1, Result>(_: A0, _: A1, _: (UnsafePointer<A0>, UnsafePointer<A1>) throws -> Result) rethrows -> Result
Removed withUnsafePointers<A0, A1, A2, Result>(_: A0, _: A1, _: A2, _: (UnsafePointer<A0>, UnsafePointer<A1>, UnsafePointer<A2>) throws -> Result) rethrows -> Result
Removed withVaList<R>(_: VaListBuilder, _: CVaListPointer -> R) -> R
Removed withVaList<R>(_: [CVarArgType], _: CVaListPointer -> R) -> R
Removed Zip2Generator.Element
Removed Zip2Sequence.Generator
Removed |=(_: T, _: T)
Removed ||(_: T, _: () throws -> Bool) rethrows -> Bool
Removed ||(_: T, _: () throws -> U) rethrows -> Bool
Removed ~=(_: Range<I>, _: I) -> Bool
Removed ~=(_: I, _: I.Bound) -> Bool
Added AnyBidirectionalCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.count
Added AnyBidirectionalCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax
Added AnyBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.first
Added AnyBidirectionalCollection.first
Added AnyBidirectionalCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added AnyBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnyBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnyBidirectionalCollection.formIndex(_: AnyIndex, offsetBy: IntMax)
Added AnyBidirectionalCollection.formIndex(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> Bool
Added AnyBidirectionalCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex
Added AnyBidirectionalCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?
Added AnyBidirectionalCollection.index(of: Element) -> AnyIndex?
Added AnyBidirectionalCollection.index(where: (Element) throws -> Bool) rethrows -> AnyIndex?
Added AnyBidirectionalCollection.indices
Added AnyBidirectionalCollection.init<C : BidirectionalCollection where C.Iterator.Element == Element, C.SubSequence : BidirectionalCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : BidirectionalCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : BidirectionalCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyBidirectionalCollection.init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyBidirectionalCollection.joined() -> FlattenCollection<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.joined() -> FlattenBidirectionalCollection<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.joined() -> FlattenSequence<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.last
Added AnyBidirectionalCollection.last
Added AnyBidirectionalCollection.lazy
Added AnyBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyBidirectionalCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyBidirectionalCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyBidirectionalCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnyBidirectionalCollection.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnyBidirectionalCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyBidirectionalCollection<Element>]
Added AnyBidirectionalCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnyBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added AnyBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.subscript(_: ClosedRange<AnyIndex>) -> AnyBidirectionalCollection<Element>
Added AnyBidirectionalCollection.underestimatedCount
Added AnyBidirectionalCollection.underestimatedCount
Added AnyBidirectionalCollection.underestimatedCount
Added AnyCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnyCollection.count
Added AnyCollection.count
Added AnyCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax
Added AnyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyCollection.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added AnyCollection.first
Added AnyCollection.first
Added AnyCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added AnyCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnyCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnyCollection.forEach(_: (Element) throws -> Swift.Void) rethrows
Added AnyCollection.formIndex(_: AnyIndex, offsetBy: IntMax)
Added AnyCollection.formIndex(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> Bool
Added AnyCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex
Added AnyCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?
Added AnyCollection.index(of: Element) -> AnyIndex?
Added AnyCollection.index(where: (Element) throws -> Bool) rethrows -> AnyIndex?
Added AnyCollection.indices
Added AnyCollection.init<C : BidirectionalCollection where C.Iterator.Element == Element, C.SubSequence : BidirectionalCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : BidirectionalCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : BidirectionalCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyCollection.init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyCollection.init<C : Collection where C.Iterator.Element == Element, C.SubSequence : Collection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : Collection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : Collection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyCollection.joined() -> FlattenSequence<AnyCollection<Element>>
Added AnyCollection.joined() -> FlattenCollection<AnyCollection<Element>>
Added AnyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnyCollection.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnyCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnyCollection<Element>]
Added AnyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyCollection<Element>]
Added AnyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnyCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added AnyCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyCollection.subscript(_: ClosedRange<AnyIndex>) -> AnyCollection<Element>
Added AnyCollection.underestimatedCount
Added AnyCollection.underestimatedCount
Added AnyCollection.underestimatedCount
Added AnyIterator.init<I : IteratorProtocol where I.Element == Element>(_: I)
Added AnyRandomAccessCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnyRandomAccessCollection.count
Added AnyRandomAccessCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax
Added AnyRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyRandomAccessCollection.first
Added AnyRandomAccessCollection.first
Added AnyRandomAccessCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added AnyRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnyRandomAccessCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnyRandomAccessCollection.formIndex(_: AnyIndex, offsetBy: IntMax)
Added AnyRandomAccessCollection.formIndex(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> Bool
Added AnyRandomAccessCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex
Added AnyRandomAccessCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?
Added AnyRandomAccessCollection.index(of: Element) -> AnyIndex?
Added AnyRandomAccessCollection.index(where: (Element) throws -> Bool) rethrows -> AnyIndex?
Added AnyRandomAccessCollection.indices
Added AnyRandomAccessCollection.init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyRandomAccessCollection.joined() -> FlattenBidirectionalCollection<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.joined() -> FlattenCollection<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.joined() -> FlattenSequence<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.last
Added AnyRandomAccessCollection.last
Added AnyRandomAccessCollection.lazy
Added AnyRandomAccessCollection.lazy
Added AnyRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyRandomAccessCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyRandomAccessCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyRandomAccessCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnyRandomAccessCollection.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnyRandomAccessCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyRandomAccessCollection<Element>]
Added AnyRandomAccessCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnyRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added AnyRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyRandomAccessCollection.subscript(_: ClosedRange<AnyIndex>) -> AnyRandomAccessCollection<Element>
Added AnyRandomAccessCollection.underestimatedCount
Added AnyRandomAccessCollection.underestimatedCount
Added AnyRandomAccessCollection.underestimatedCount
Added AnySequence.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnySequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnySequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnySequence.first(where: (Element) throws -> Bool) rethrows -> Element?
Added AnySequence.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnySequence.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnySequence.init<S : Sequence where S.Iterator.Element == Element, S.SubSequence : Sequence, S.SubSequence.Iterator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_: S)
Added AnySequence.init<I : IteratorProtocol where I.Element == Element>(_: () -> I)
Added AnySequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnySequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnySequence.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnySequence.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnySequence.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnySequence.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnySequence.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnySequence.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnySequence.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnySequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added AnySequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnySequence.underestimatedCount
Added AnySequence.underestimatedCount
Added Array.append<S : Sequence where S.Iterator.Element == Element>(contentsOf: S)
Added Array.append<C : Collection where C.Iterator.Element == Element>(contentsOf: C)
Added Array.count
Added Array.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Array.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Array.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added Array.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Array.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Array.formIndex(_: Int, offsetBy: Int)
Added Array.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Array.index(of: Element) -> Int?
Added Array.index(where: (Element) throws -> Bool) rethrows -> Int?
Added Array.indices
Added Array.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Array.joined() -> FlattenSequence<Array<Element>>
Added Array.joined() -> FlattenBidirectionalCollection<Array<Element>>
Added Array.joined() -> FlattenCollection<Array<Element>>
Added Array.joined(separator: String) -> String
Added Array.lazy
Added Array.lazy
Added Array.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Array.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Array.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Array.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Array.partition(by: (Element) throws -> Bool) rethrows -> Int
Added Array.partition(by: (Element) throws -> Bool) rethrows -> Int
Added Array.replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Added Array.sorted() -> [Element]
Added Array.sorted() -> [Element]
Added Array.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added Array.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Element>]
Added Array.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added Array.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Array.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: Range<Int>) -> MutableSlice<Array<Element>>
Added Array.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added Array.underestimatedCount
Added Array.underestimatedCount
Added ArraySlice.append<C : Collection where C.Iterator.Element == Element>(contentsOf: C)
Added ArraySlice.append<S : Sequence where S.Iterator.Element == Element>(contentsOf: S)
Added ArraySlice.count
Added ArraySlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ArraySlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ArraySlice.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added ArraySlice.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ArraySlice.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ArraySlice.formIndex(_: Int, offsetBy: Int)
Added ArraySlice.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added ArraySlice.index(of: Element) -> Int?
Added ArraySlice.index(where: (Element) throws -> Bool) rethrows -> Int?
Added ArraySlice.indices
Added ArraySlice.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added ArraySlice.joined() -> FlattenSequence<ArraySlice<Element>>
Added ArraySlice.joined() -> FlattenCollection<ArraySlice<Element>>
Added ArraySlice.joined() -> FlattenBidirectionalCollection<ArraySlice<Element>>
Added ArraySlice.lazy
Added ArraySlice.lazy
Added ArraySlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ArraySlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ArraySlice.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added ArraySlice.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added ArraySlice.partition(by: (Element) throws -> Bool) rethrows -> Int
Added ArraySlice.partition(by: (Element) throws -> Bool) rethrows -> Int
Added ArraySlice.removeFirst() -> Element
Added ArraySlice.removeLast() -> Element
Added ArraySlice.removeLast(_: Int)
Added ArraySlice.replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Added ArraySlice.sorted() -> [Element]
Added ArraySlice.sorted() -> [Element]
Added ArraySlice.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Element>]
Added ArraySlice.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added ArraySlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added ArraySlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ArraySlice.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: Range<Int>) -> MutableSlice<ArraySlice<Element>>
Added ArraySlice.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ArraySlice.underestimatedCount
Added ArraySlice.underestimatedCount
Added BidirectionalCollection.formIndex(before: Self.Index)
Added BidirectionalCollection.indices
Added BidirectionalCollection.joined() -> FlattenBidirectionalCollection<Self>
Added BidirectionalCollection.last
Added BidirectionalCollection.last
Added BidirectionalCollection.lazy
Added BidirectionalCollection.subscript(_: Range<Self.Index>) -> BidirectionalSlice<Self>
Added BidirectionalIndexable
Added BidirectionalIndexable.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance
Added BidirectionalIndexable.formIndex(before: Self.Index)
Added BidirectionalIndexable.formIndex(before: Self.Index)
Added BidirectionalIndexable.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index
Added BidirectionalIndexable.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added BidirectionalIndexable.index(before: Self.Index) -> Self.Index
Added BidirectionalSlice [struct]
Added BidirectionalSlice.base
Added BidirectionalSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added BidirectionalSlice.count
Added BidirectionalSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added BidirectionalSlice.dropFirst() -> BidirectionalSlice<Base>
Added BidirectionalSlice.dropFirst(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.dropLast() -> BidirectionalSlice<Base>
Added BidirectionalSlice.dropLast(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added BidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added BidirectionalSlice.endIndex
Added BidirectionalSlice.enumerated() -> EnumeratedSequence<BidirectionalSlice<Base>>
Added BidirectionalSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added BidirectionalSlice.first
Added BidirectionalSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added BidirectionalSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added BidirectionalSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added BidirectionalSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added BidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added BidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added BidirectionalSlice.formIndex(after: Base.Index)
Added BidirectionalSlice.formIndex(before: Base.Index)
Added BidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added BidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added BidirectionalSlice.index(after: Base.Index) -> Base.Index
Added BidirectionalSlice.index(before: Base.Index) -> Base.Index
Added BidirectionalSlice.index(of: Base._Element) -> Base.Index?
Added BidirectionalSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added BidirectionalSlice.indices
Added BidirectionalSlice.init(base: Base, bounds: Range<Base.Index>)
Added BidirectionalSlice.isEmpty
Added BidirectionalSlice.joined() -> FlattenCollection<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined() -> FlattenBidirectionalCollection<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined() -> FlattenSequence<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined(separator: String) -> String
Added BidirectionalSlice.last
Added BidirectionalSlice.lazy
Added BidirectionalSlice.lazy
Added BidirectionalSlice.lazy
Added BidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added BidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added BidirectionalSlice.makeIterator() -> IndexingIterator<BidirectionalSlice<Base>>
Added BidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added BidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added BidirectionalSlice.max() -> Base._Element?
Added BidirectionalSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added BidirectionalSlice.min() -> Base._Element?
Added BidirectionalSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added BidirectionalSlice.popFirst() -> Base._Element?
Added BidirectionalSlice.popLast() -> Base._Element?
Added BidirectionalSlice.prefix(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.prefix(through: Base.Index) -> BidirectionalSlice<Base>
Added BidirectionalSlice.prefix(upTo: Base.Index) -> BidirectionalSlice<Base>
Added BidirectionalSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added BidirectionalSlice.removeFirst() -> Base._Element
Added BidirectionalSlice.removeFirst(_: Int)
Added BidirectionalSlice.removeLast() -> Base._Element
Added BidirectionalSlice.removeLast(_: Int)
Added BidirectionalSlice.reversed() -> ReversedCollection<BidirectionalSlice<Base>>
Added BidirectionalSlice.sorted() -> [Base._Element]
Added BidirectionalSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added BidirectionalSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [BidirectionalSlice<Base>]
Added BidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added BidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<Base>]
Added BidirectionalSlice.startIndex
Added BidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added BidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added BidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: Range<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: Range<Base.Index>) -> BidirectionalSlice<BidirectionalSlice<Base>>
Added BidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: Base.Index) -> Base._Element
Added BidirectionalSlice.suffix(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.suffix(from: Base.Index) -> BidirectionalSlice<Base>
Added BidirectionalSlice.underestimatedCount
Added BidirectionalSlice.underestimatedCount
Added BitwiseOperations
Added BitwiseOperations.&(_: Self, _: Self) -> Self
Added BitwiseOperations.^(_: Self, _: Self) -> Self
Added BitwiseOperations.allZeros
Added BitwiseOperations.|(_: Self, _: Self) -> Self
Added BitwiseOperations.~(_: Self) -> Self
Added Character._SmallUTF16.contains(_: UInt16) -> Bool
Added Character._SmallUTF16.contains(where: (UInt16) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF16.count
Added Character._SmallUTF16.distance(from: Int, to: Int) -> Int
Added Character._SmallUTF16.dropFirst() -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.dropFirst(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.dropLast() -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.dropLast(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence) -> Bool
Added Character._SmallUTF16.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF16.enumerated() -> EnumeratedSequence<Character._SmallUTF16>
Added Character._SmallUTF16.filter(_: (UInt16) throws -> Bool) rethrows -> [UInt16]
Added Character._SmallUTF16.first
Added Character._SmallUTF16.first(where: (UInt16) throws -> Bool) rethrows -> UInt16?
Added Character._SmallUTF16.flatMap<SegmentOfResult : Sequence>(_: (UInt16) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Character._SmallUTF16.flatMap<ElementOfResult>(_: (UInt16) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Character._SmallUTF16.forEach(_: (UInt16) throws -> Void) rethrows
Added Character._SmallUTF16.formIndex(_: Int, offsetBy: Int)
Added Character._SmallUTF16.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Character._SmallUTF16.formIndex(after: Int)
Added Character._SmallUTF16.formIndex(before: Int)
Added Character._SmallUTF16.index(_: Int, offsetBy: Int) -> Int
Added Character._SmallUTF16.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added Character._SmallUTF16.index(after: Int) -> Int
Added Character._SmallUTF16.index(before: Int) -> Int
Added Character._SmallUTF16.index(of: UInt16) -> Int?
Added Character._SmallUTF16.index(where: (UInt16) throws -> Bool) rethrows -> Int?
Added Character._SmallUTF16.indices
Added Character._SmallUTF16.isEmpty
Added Character._SmallUTF16.last
Added Character._SmallUTF16.lazy
Added Character._SmallUTF16.lazy
Added Character._SmallUTF16.lazy
Added Character._SmallUTF16.lazy
Added Character._SmallUTF16.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence) -> Bool
Added Character._SmallUTF16.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF16.makeIterator() -> IndexingIterator<Character._SmallUTF16>
Added Character._SmallUTF16.map<T>(_: (UInt16) throws -> T) rethrows -> [T]
Added Character._SmallUTF16.map<T>(_: (UInt16) throws -> T) rethrows -> [T]
Added Character._SmallUTF16.max() -> UInt16?
Added Character._SmallUTF16.max(by: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16?
Added Character._SmallUTF16.min() -> UInt16?
Added Character._SmallUTF16.min(by: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16?
Added Character._SmallUTF16.prefix(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.prefix(through: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.prefix(upTo: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.reduce<Result>(_: Result, _: (Result, UInt16) throws -> Result) rethrows -> Result
Added Character._SmallUTF16.reversed() -> ReversedRandomAccessCollection<Character._SmallUTF16>
Added Character._SmallUTF16.sorted() -> [UInt16]
Added Character._SmallUTF16.sorted(by: (UInt16, UInt16) -> Bool) -> [UInt16]
Added Character._SmallUTF16.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (UInt16) throws -> Bool) rethrows -> [RandomAccessSlice<Character._SmallUTF16>]
Added Character._SmallUTF16.split(separator: UInt16, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<Character._SmallUTF16>]
Added Character._SmallUTF16.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with: PossiblePrefix) -> Bool
Added Character._SmallUTF16.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with: PossiblePrefix, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF16.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.subscript(_: CountableRange<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.subscript(_: Range<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.suffix(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.suffix(from: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.underestimatedCount
Added Character._SmallUTF16.underestimatedCount
Added Character._SmallUTF8.contains(_: UInt8) -> Bool
Added Character._SmallUTF8.contains(where: (UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.count
Added Character._SmallUTF8.distance(from: Int, to: Int) -> Int
Added Character._SmallUTF8.dropFirst() -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.dropFirst(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.dropLast() -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.dropLast(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence) -> Bool
Added Character._SmallUTF8.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.enumerated() -> EnumeratedSequence<Character._SmallUTF8>
Added Character._SmallUTF8.filter(_: (UInt8) throws -> Bool) rethrows -> [UInt8]
Added Character._SmallUTF8.first
Added Character._SmallUTF8.first(where: (UInt8) throws -> Bool) rethrows -> UInt8?
Added Character._SmallUTF8.flatMap<SegmentOfResult : Sequence>(_: (UInt8) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Character._SmallUTF8.flatMap<ElementOfResult>(_: (UInt8) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Character._SmallUTF8.forEach(_: (UInt8) throws -> Void) rethrows
Added Character._SmallUTF8.formIndex(_: Int, offsetBy: Int)
Added Character._SmallUTF8.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Character._SmallUTF8.formIndex(after: Int)
Added Character._SmallUTF8.formIndex(before: Int)
Added Character._SmallUTF8.index(_: Int, offsetBy: Int) -> Int
Added Character._SmallUTF8.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added Character._SmallUTF8.index(after: Int) -> Int
Added Character._SmallUTF8.index(before: Int) -> Int
Added Character._SmallUTF8.index(of: UInt8) -> Int?
Added Character._SmallUTF8.index(where: (UInt8) throws -> Bool) rethrows -> Int?
Added Character._SmallUTF8.indices
Added Character._SmallUTF8.isEmpty
Added Character._SmallUTF8.last
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence) -> Bool
Added Character._SmallUTF8.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.map<T>(_: (UInt8) throws -> T) rethrows -> [T]
Added Character._SmallUTF8.map<T>(_: (UInt8) throws -> T) rethrows -> [T]
Added Character._SmallUTF8.max() -> UInt8?
Added Character._SmallUTF8.max(by: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?
Added Character._SmallUTF8.min() -> UInt8?
Added Character._SmallUTF8.min(by: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?
Added Character._SmallUTF8.prefix(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.prefix(through: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.prefix(upTo: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.reduce<Result>(_: Result, _: (Result, UInt8) throws -> Result) rethrows -> Result
Added Character._SmallUTF8.reversed() -> ReversedRandomAccessCollection<Character._SmallUTF8>
Added Character._SmallUTF8.sorted() -> [UInt8]
Added Character._SmallUTF8.sorted(by: (UInt8, UInt8) -> Bool) -> [UInt8]
Added Character._SmallUTF8.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (UInt8) throws -> Bool) rethrows -> [RandomAccessSlice<Character._SmallUTF8>]
Added Character._SmallUTF8.split(separator: UInt8, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<Character._SmallUTF8>]
Added Character._SmallUTF8.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with: PossiblePrefix) -> Bool
Added Character._SmallUTF8.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with: PossiblePrefix, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.subscript(_: Range<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.subscript(_: CountableRange<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.suffix(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.suffix(from: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.underestimatedCount
Added Character._SmallUTF8.underestimatedCount
Added ClosedRangeIndex [struct]
Added ClosedRangeIterator [struct]
Added ClosedRangeIterator.contains(_: Bound) -> Bool
Added ClosedRangeIterator.contains(where: (Bound) throws -> Bool) rethrows -> Bool
Added ClosedRangeIterator.dropFirst() -> AnySequence<Bound>
Added ClosedRangeIterator.dropFirst(_: Int) -> AnySequence<Bound>
Added ClosedRangeIterator.dropLast() -> AnySequence<Bound>
Added ClosedRangeIterator.dropLast(_: Int) -> AnySequence<Bound>
Added ClosedRangeIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added ClosedRangeIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added ClosedRangeIterator.enumerated() -> EnumeratedSequence<ClosedRangeIterator<Bound>>
Added ClosedRangeIterator.filter(_: (Bound) throws -> Bool) rethrows -> [Bound]
Added ClosedRangeIterator.first(where: (Bound) throws -> Bool) rethrows -> Bound?
Added ClosedRangeIterator.flatMap<SegmentOfResult : Sequence>(_: (Bound) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ClosedRangeIterator.flatMap<ElementOfResult>(_: (Bound) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ClosedRangeIterator.forEach(_: (Bound) throws -> Void) rethrows
Added ClosedRangeIterator.joined() -> FlattenSequence<ClosedRangeIterator<Bound>>
Added ClosedRangeIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<ClosedRangeIterator<Bound>>
Added ClosedRangeIterator.joined(separator: String) -> String
Added ClosedRangeIterator.lazy
Added ClosedRangeIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added ClosedRangeIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added ClosedRangeIterator.makeIterator() -> ClosedRangeIterator<Bound>
Added ClosedRangeIterator.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added ClosedRangeIterator.max() -> Bound?
Added ClosedRangeIterator.max(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added ClosedRangeIterator.min() -> Bound?
Added ClosedRangeIterator.min(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added ClosedRangeIterator.next() -> Bound?
Added ClosedRangeIterator.prefix(_: Int) -> AnySequence<Bound>
Added ClosedRangeIterator.reduce<Result>(_: Result, _: (Result, Bound) throws -> Result) rethrows -> Result
Added ClosedRangeIterator.reversed() -> [Bound]
Added ClosedRangeIterator.sorted() -> [Bound]
Added ClosedRangeIterator.sorted(by: (Bound, Bound) -> Bool) -> [Bound]
Added ClosedRangeIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Bound) throws -> Bool) rethrows -> [AnySequence<Bound>]
Added ClosedRangeIterator.split(separator: Bound, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Bound>]
Added ClosedRangeIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix) -> Bool
Added ClosedRangeIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added ClosedRangeIterator.suffix(_: Int) -> AnySequence<Bound>
Added ClosedRangeIterator.underestimatedCount
Added Collection.count
Added Collection.count
Added Collection.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance
Added Collection.first
Added Collection.first
Added Collection.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index
Added Collection.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added Collection.index(of: Self.Iterator.Element) -> Self.Index?
Added Collection.index(where: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Index?
Added Collection.isEmpty
Added Collection.isEmpty
Added Collection.makeIterator() -> IndexingIterator<Self>
Added Collection.makeIterator() -> Self.Iterator
Added Collection.map<T>(_: (Self.Iterator.Element) throws -> T) rethrows -> [T]
Added Collection.prefix(through: Self.Index) -> Self.SubSequence
Added Collection.prefix(through: Self.Index) -> Self.SubSequence
Added Collection.prefix(upTo: Self.Index) -> Self.SubSequence
Added Collection.prefix(upTo: Self.Index) -> Self.SubSequence
Added Collection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Self.Iterator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Added Collection.split(separator: Self.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Self.SubSequence]
Added Collection.subscript(_: Range<Self.Index>) -> Self.SubSequence
Added Collection.subscript(_: Range<Self.Index>) -> Slice<Self>
Added Collection.suffix(from: Self.Index) -> Self.SubSequence
Added Collection.suffix(from: Self.Index) -> Self.SubSequence
Added CollectionOfOne.count
Added CollectionOfOne.distance(from: Int, to: Int) -> Int
Added CollectionOfOne.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added CollectionOfOne.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added CollectionOfOne.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added CollectionOfOne.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added CollectionOfOne.formIndex(_: Int, offsetBy: Int)
Added CollectionOfOne.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added CollectionOfOne.formIndex(after: Int)
Added CollectionOfOne.formIndex(before: Int)
Added CollectionOfOne.index(_: Int, offsetBy: Int) -> Int
Added CollectionOfOne.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added CollectionOfOne.index(of: Element) -> Int?
Added CollectionOfOne.index(where: (Element) throws -> Bool) rethrows -> Int?
Added CollectionOfOne.indices
Added CollectionOfOne.joined() -> FlattenSequence<CollectionOfOne<Element>>
Added CollectionOfOne.joined() -> FlattenCollection<CollectionOfOne<Element>>
Added CollectionOfOne.joined() -> FlattenBidirectionalCollection<CollectionOfOne<Element>>
Added CollectionOfOne.joined(separator: String) -> String
Added CollectionOfOne.lazy
Added CollectionOfOne.lazy
Added CollectionOfOne.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added CollectionOfOne.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added CollectionOfOne.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added CollectionOfOne.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added CollectionOfOne.partition(by: (Element) throws -> Bool) rethrows -> Int
Added CollectionOfOne.partition(by: (Element) throws -> Bool) rethrows -> Int
Added CollectionOfOne.sorted() -> [Element]
Added CollectionOfOne.sorted() -> [Element]
Added CollectionOfOne.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRandomAccessSlice<CollectionOfOne<Element>>]
Added CollectionOfOne.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added CollectionOfOne.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added CollectionOfOne.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added CollectionOfOne.subscript(_: CountableRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: ClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: CountableRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: ClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: Range<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: Range<Int>) -> MutableSlice<CollectionOfOne<Element>>
Added CollectionOfOne.underestimatedCount
Added CollectionOfOne.underestimatedCount
Added ContiguousArray.append<C : Collection where C.Iterator.Element == Element>(contentsOf: C)
Added ContiguousArray.append<S : Sequence where S.Iterator.Element == Element>(contentsOf: S)
Added ContiguousArray.count
Added ContiguousArray.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ContiguousArray.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ContiguousArray.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added ContiguousArray.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ContiguousArray.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ContiguousArray.formIndex(_: Int, offsetBy: Int)
Added ContiguousArray.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added ContiguousArray.index(of: Element) -> Int?
Added ContiguousArray.index(where: (Element) throws -> Bool) rethrows -> Int?
Added ContiguousArray.indices
Added ContiguousArray.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added ContiguousArray.init(repeating: Element, count: Int)
Added ContiguousArray.joined() -> FlattenBidirectionalCollection<ContiguousArray<Element>>
Added ContiguousArray.joined() -> FlattenCollection<ContiguousArray<Element>>
Added ContiguousArray.joined() -> FlattenSequence<ContiguousArray<Element>>
Added ContiguousArray.joined(separator: String) -> String
Added ContiguousArray.lazy
Added ContiguousArray.lazy
Added ContiguousArray.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ContiguousArray.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ContiguousArray.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added ContiguousArray.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added ContiguousArray.partition(by: (Element) throws -> Bool) rethrows -> Int
Added ContiguousArray.partition(by: (Element) throws -> Bool) rethrows -> Int
Added ContiguousArray.remove(at: Int) -> Element
Added ContiguousArray.removeAll(keepingCapacity: Bool)
Added ContiguousArray.replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Added ContiguousArray.sorted() -> [Element]
Added ContiguousArray.sorted() -> [Element]
Added ContiguousArray.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added ContiguousArray.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Element>]
Added ContiguousArray.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added ContiguousArray.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ContiguousArray.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: Range<Int>) -> MutableSlice<ContiguousArray<Element>>
Added ContiguousArray.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.underestimatedCount
Added ContiguousArray.underestimatedCount
Added CountableClosedRange [struct]
Added CountableClosedRange.clamped(to: CountableClosedRange<Bound>) -> CountableClosedRange<Bound>
Added CountableClosedRange.contains(_: Bound) -> Bool
Added CountableClosedRange.contains(where: (Bound) throws -> Bool) rethrows -> Bool
Added CountableClosedRange.count
Added CountableClosedRange.customMirror
Added CountableClosedRange.debugDescription
Added CountableClosedRange.description
Added CountableClosedRange.distance(from: ClosedRangeIndex<Bound>, to: ClosedRangeIndex<Bound>) -> Bound.Stride
Added CountableClosedRange.dropFirst() -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.dropFirst(_: Int) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.dropLast() -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.dropLast(_: Int) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added CountableClosedRange.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableClosedRange.endIndex
Added CountableClosedRange.enumerated() -> EnumeratedSequence<CountableClosedRange<Bound>>
Added CountableClosedRange.filter(_: (Bound) throws -> Bool) rethrows -> [Bound]
Added CountableClosedRange.first
Added CountableClosedRange.first(where: (Bound) throws -> Bool) rethrows -> Bound?
Added CountableClosedRange.flatMap<SegmentOfResult : Sequence>(_: (Bound) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added CountableClosedRange.flatMap<ElementOfResult>(_: (Bound) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added CountableClosedRange.forEach(_: (Bound) throws -> Void) rethrows
Added CountableClosedRange.formIndex(_: ClosedRangeIndex<Bound>, offsetBy: Bound.Stride)
Added CountableClosedRange.formIndex(_: ClosedRangeIndex<Bound>, offsetBy: Bound.Stride, limitedBy: ClosedRangeIndex<Bound>) -> Bool
Added CountableClosedRange.formIndex(after: ClosedRangeIndex<Bound>)
Added CountableClosedRange.formIndex(before: ClosedRangeIndex<Bound>)
Added CountableClosedRange.index(_: ClosedRangeIndex<Bound>, offsetBy: Bound.Stride) -> ClosedRangeIndex<Bound>
Added CountableClosedRange.index(_: ClosedRangeIndex<Bound>, offsetBy: Bound.Stride, limitedBy: ClosedRangeIndex<Bound>) -> ClosedRangeIndex<Bound>?
Added CountableClosedRange.index(after: ClosedRangeIndex<Bound>) -> ClosedRangeIndex<Bound>
Added CountableClosedRange.index(before: ClosedRangeIndex<Bound>) -> ClosedRangeIndex<Bound>
Added CountableClosedRange.index(of: Bound) -> ClosedRangeIndex<Bound>?
Added CountableClosedRange.index(where: (Bound) throws -> Bool) rethrows -> ClosedRangeIndex<Bound>?
Added CountableClosedRange.indices
Added CountableClosedRange.indices
Added CountableClosedRange.init(_: Range<Bound>)
Added CountableClosedRange.init(_: CountableClosedRange<Bound>)
Added CountableClosedRange.init(_: ClosedRange<Bound>)
Added CountableClosedRange.init(_: CountableRange<Bound>)
Added CountableClosedRange.init(uncheckedBounds: (lower: Bound, upper: Bound))
Added CountableClosedRange.isEmpty
Added CountableClosedRange.isEmpty
Added CountableClosedRange.joined() -> FlattenSequence<CountableClosedRange<Bound>>
Added CountableClosedRange.joined() -> FlattenBidirectionalCollection<CountableClosedRange<Bound>>
Added CountableClosedRange.joined() -> FlattenCollection<CountableClosedRange<Bound>>
Added CountableClosedRange.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<CountableClosedRange<Bound>>
Added CountableClosedRange.joined(separator: String) -> String
Added CountableClosedRange.last
Added CountableClosedRange.lazy
Added CountableClosedRange.lazy
Added CountableClosedRange.lazy
Added CountableClosedRange.lazy
Added CountableClosedRange.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added CountableClosedRange.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableClosedRange.lowerBound
Added CountableClosedRange.makeIterator() -> ClosedRangeIterator<Bound>
Added CountableClosedRange.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added CountableClosedRange.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added CountableClosedRange.max() -> Bound?
Added CountableClosedRange.max(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added CountableClosedRange.min() -> Bound?
Added CountableClosedRange.min(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added CountableClosedRange.overlaps(_: CountableClosedRange<Bound>) -> Bool
Added CountableClosedRange.overlaps(_: ClosedRange<Bound>) -> Bool
Added CountableClosedRange.overlaps(_: Range<Bound>) -> Bool
Added CountableClosedRange.overlaps(_: CountableRange<Bound>) -> Bool
Added CountableClosedRange.prefix(_: Int) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.prefix(through: ClosedRangeIndex<Bound>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.prefix(upTo: ClosedRangeIndex<Bound>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.reduce<Result>(_: Result, _: (Result, Bound) throws -> Result) rethrows -> Result
Added CountableClosedRange.reversed() -> ReversedRandomAccessCollection<CountableClosedRange<Bound>>
Added CountableClosedRange.sorted() -> [Bound]
Added CountableClosedRange.sorted(by: (Bound, Bound) -> Bool) -> [Bound]
Added CountableClosedRange.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Bound) throws -> Bool) rethrows -> [RandomAccessSlice<CountableClosedRange<Bound>>]
Added CountableClosedRange.split(separator: Bound, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<CountableClosedRange<Bound>>]
Added CountableClosedRange.startIndex
Added CountableClosedRange.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix) -> Bool
Added CountableClosedRange.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableClosedRange.subscript(_: ClosedRangeIndex<Bound>) -> Bound
Added CountableClosedRange.subscript(_: Range<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.subscript(_: Range<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.subscript(_: ClosedRange<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.suffix(_: Int) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.suffix(from: ClosedRangeIndex<Bound>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.underestimatedCount
Added CountableClosedRange.underestimatedCount
Added CountableClosedRange.upperBound
Added CountableRange [struct]
Added CountableRange.clamped(to: CountableRange<Bound>) -> CountableRange<Bound>
Added CountableRange.contains(_: Bound) -> Bool
Added CountableRange.contains(where: (Bound) throws -> Bool) rethrows -> Bool
Added CountableRange.count
Added CountableRange.customMirror
Added CountableRange.debugDescription
Added CountableRange.description
Added CountableRange.distance(from: Bound, to: Bound) -> Bound.Stride
Added CountableRange.dropFirst() -> CountableRange<Bound>
Added CountableRange.dropFirst(_: Int) -> CountableRange<Bound>
Added CountableRange.dropLast() -> CountableRange<Bound>
Added CountableRange.dropLast(_: Int) -> CountableRange<Bound>
Added CountableRange.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added CountableRange.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableRange.endIndex
Added CountableRange.enumerated() -> EnumeratedSequence<CountableRange<Bound>>
Added CountableRange.filter(_: (Bound) throws -> Bool) rethrows -> [Bound]
Added CountableRange.first
Added CountableRange.first(where: (Bound) throws -> Bool) rethrows -> Bound?
Added CountableRange.flatMap<SegmentOfResult : Sequence>(_: (Bound) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added CountableRange.flatMap<ElementOfResult>(_: (Bound) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added CountableRange.forEach(_: (Bound) throws -> Void) rethrows
Added CountableRange.formIndex(_: Bound, offsetBy: Bound.Stride)
Added CountableRange.formIndex(_: Bound, offsetBy: Bound.Stride, limitedBy: Bound) -> Bool
Added CountableRange.formIndex(after: Bound)
Added CountableRange.formIndex(before: Bound)
Added CountableRange.index(_: Bound, offsetBy: Bound.Stride) -> Bound
Added CountableRange.index(_: Bound, offsetBy: Bound.Stride, limitedBy: Bound) -> Bound?
Added CountableRange.index(after: Bound) -> Bound
Added CountableRange.index(before: Bound) -> Bound
Added CountableRange.index(of: Bound) -> Bound?
Added CountableRange.index(where: (Bound) throws -> Bool) rethrows -> Bound?
Added CountableRange.indices
Added CountableRange.indices
Added CountableRange.init(_: CountableRange<Bound>)
Added CountableRange.init(_: Range<Bound>)
Added CountableRange.init(_: CountableClosedRange<Bound>)
Added CountableRange.init(_: ClosedRange<Bound>)
Added CountableRange.init(uncheckedBounds: (lower: Bound, upper: Bound))
Added CountableRange.isEmpty
Added CountableRange.isEmpty
Added CountableRange.joined() -> FlattenSequence<CountableRange<Bound>>
Added CountableRange.joined() -> FlattenCollection<CountableRange<Bound>>
Added CountableRange.joined() -> FlattenBidirectionalCollection<CountableRange<Bound>>
Added CountableRange.joined(separator: String) -> String
Added CountableRange.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<CountableRange<Bound>>
Added CountableRange.last
Added CountableRange.lazy
Added CountableRange.lazy
Added CountableRange.lazy
Added CountableRange.lazy
Added CountableRange.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added CountableRange.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableRange.lowerBound
Added CountableRange.makeIterator() -> IndexingIterator<CountableRange<Bound>>
Added CountableRange.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added CountableRange.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added CountableRange.max() -> Bound?
Added CountableRange.max(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added CountableRange.min() -> Bound?
Added CountableRange.min(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added CountableRange.overlaps(_: CountableRange<Bound>) -> Bool
Added CountableRange.overlaps(_: CountableClosedRange<Bound>) -> Bool
Added CountableRange.overlaps(_: ClosedRange<Bound>) -> Bool
Added CountableRange.overlaps(_: Range<Bound>) -> Bool
Added CountableRange.popFirst() -> Bound?
Added CountableRange.popLast() -> Bound?
Added CountableRange.prefix(_: Int) -> CountableRange<Bound>
Added CountableRange.prefix(through: Bound) -> CountableRange<Bound>
Added CountableRange.prefix(upTo: Bound) -> CountableRange<Bound>
Added CountableRange.reduce<Result>(_: Result, _: (Result, Bound) throws -> Result) rethrows -> Result
Added CountableRange.removeFirst() -> Bound
Added CountableRange.removeFirst(_: Int)
Added CountableRange.removeLast() -> Bound
Added CountableRange.removeLast(_: Int)
Added CountableRange.reversed() -> ReversedRandomAccessCollection<CountableRange<Bound>>
Added CountableRange.sorted() -> [Bound]
Added CountableRange.sorted(by: (Bound, Bound) -> Bool) -> [Bound]
Added CountableRange.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Bound) throws -> Bool) rethrows -> [CountableRange<Bound>]
Added CountableRange.split(separator: Bound, maxSplits: Int, omittingEmptySubsequences: Bool) -> [CountableRange<Bound>]
Added CountableRange.startIndex
Added CountableRange.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix) -> Bool
Added CountableRange.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableRange.subscript(_: CountableClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: CountableRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: CountableClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: Bound) -> Bound
Added CountableRange.subscript(_: CountableRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: Range<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: ClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: ClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.suffix(_: Int) -> CountableRange<Bound>
Added CountableRange.suffix(from: Bound) -> CountableRange<Bound>
Added CountableRange.underestimatedCount
Added CountableRange.underestimatedCount
Added CountableRange.upperBound
Added CVarArg
Added DefaultBidirectionalIndices [struct]
Added DefaultBidirectionalIndices.contains(_: Elements.Index) -> Bool
Added DefaultBidirectionalIndices.contains(where: (Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultBidirectionalIndices.count
Added DefaultBidirectionalIndices.distance(from: Elements.Index, to: Elements.Index) -> Int
Added DefaultBidirectionalIndices.dropFirst() -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.dropFirst(_: Int) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.dropLast() -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.dropLast(_: Int) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultBidirectionalIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultBidirectionalIndices.endIndex
Added DefaultBidirectionalIndices.enumerated() -> EnumeratedSequence<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.filter(_: (Elements.Index) throws -> Bool) rethrows -> [Elements.Index]
Added DefaultBidirectionalIndices.first
Added DefaultBidirectionalIndices.first(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultBidirectionalIndices.flatMap<SegmentOfResult : Sequence>(_: (Elements.Index) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added DefaultBidirectionalIndices.flatMap<ElementOfResult>(_: (Elements.Index) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added DefaultBidirectionalIndices.forEach(_: (Elements.Index) throws -> Void) rethrows
Added DefaultBidirectionalIndices.formIndex(_: Elements.Index, offsetBy: Int)
Added DefaultBidirectionalIndices.formIndex(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Bool
Added DefaultBidirectionalIndices.formIndex(after: Elements.Index)
Added DefaultBidirectionalIndices.formIndex(before: Elements.Index)
Added DefaultBidirectionalIndices.index(_: Elements.Index, offsetBy: Int) -> Elements.Index
Added DefaultBidirectionalIndices.index(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Elements.Index?
Added DefaultBidirectionalIndices.index(after: Elements.Index) -> Elements.Index
Added DefaultBidirectionalIndices.index(before: Elements.Index) -> Elements.Index
Added DefaultBidirectionalIndices.index(of: Elements.Index) -> Elements.Index?
Added DefaultBidirectionalIndices.index(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultBidirectionalIndices.indices
Added DefaultBidirectionalIndices.indices
Added DefaultBidirectionalIndices.isEmpty
Added DefaultBidirectionalIndices.joined() -> FlattenCollection<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.joined() -> FlattenSequence<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.joined() -> FlattenBidirectionalCollection<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.joined(separator: String) -> String
Added DefaultBidirectionalIndices.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.last
Added DefaultBidirectionalIndices.lazy
Added DefaultBidirectionalIndices.lazy
Added DefaultBidirectionalIndices.lazy
Added DefaultBidirectionalIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultBidirectionalIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultBidirectionalIndices.makeIterator() -> IndexingIterator<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultBidirectionalIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultBidirectionalIndices.max() -> Elements.Index?
Added DefaultBidirectionalIndices.max(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultBidirectionalIndices.min() -> Elements.Index?
Added DefaultBidirectionalIndices.min(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultBidirectionalIndices.popFirst() -> Elements.Index?
Added DefaultBidirectionalIndices.popLast() -> Elements.Index?
Added DefaultBidirectionalIndices.prefix(_: Int) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.prefix(through: Elements.Index) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.prefix(upTo: Elements.Index) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.reduce<Result>(_: Result, _: (Result, Elements.Index) throws -> Result) rethrows -> Result
Added DefaultBidirectionalIndices.removeFirst() -> Elements.Index
Added DefaultBidirectionalIndices.removeFirst(_: Int)
Added DefaultBidirectionalIndices.removeLast() -> Elements.Index
Added DefaultBidirectionalIndices.removeLast(_: Int)
Added DefaultBidirectionalIndices.reversed() -> ReversedCollection<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.sorted() -> [Elements.Index]
Added DefaultBidirectionalIndices.sorted(by: (Elements.Index, Elements.Index) -> Bool) -> [Elements.Index]
Added DefaultBidirectionalIndices.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Elements.Index) throws -> Bool) rethrows -> [DefaultBidirectionalIndices<Elements>]
Added DefaultBidirectionalIndices.split(separator: Elements.Index, maxSplits: Int, omittingEmptySubsequences: Bool) -> [DefaultBidirectionalIndices<Elements>]
Added DefaultBidirectionalIndices.startIndex
Added DefaultBidirectionalIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix) -> Bool
Added DefaultBidirectionalIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultBidirectionalIndices.subscript(_: Range<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: CountableRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: CountableClosedRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: Elements.Index) -> Elements.Index
Added DefaultBidirectionalIndices.suffix(_: Int) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.suffix(from: Elements.Index) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.underestimatedCount
Added DefaultBidirectionalIndices.underestimatedCount
Added DefaultIndices.distance(from: Elements.Index, to: Elements.Index) -> Int
Added DefaultIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultIndices.flatMap<ElementOfResult>(_: (Elements.Index) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added DefaultIndices.flatMap<SegmentOfResult : Sequence>(_: (Elements.Index) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added DefaultIndices.formIndex(_: Elements.Index, offsetBy: Int)
Added DefaultIndices.formIndex(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Bool
Added DefaultIndices.index(_: Elements.Index, offsetBy: Int) -> Elements.Index
Added DefaultIndices.index(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Elements.Index?
Added DefaultIndices.index(of: Elements.Index) -> Elements.Index?
Added DefaultIndices.index(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultIndices.indices
Added DefaultIndices.joined() -> FlattenCollection<DefaultIndices<Elements>>
Added DefaultIndices.joined() -> FlattenSequence<DefaultIndices<Elements>>
Added DefaultIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix) -> Bool
Added DefaultIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultIndices.subscript(_: CountableClosedRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: Elements.Index) -> Elements.Index
Added DefaultIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: CountableRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: Range<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.underestimatedCount
Added DefaultIndices.underestimatedCount
Added DefaultRandomAccessIndices [struct]
Added DefaultRandomAccessIndices.contains(_: Elements.Index) -> Bool
Added DefaultRandomAccessIndices.contains(where: (Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultRandomAccessIndices.count
Added DefaultRandomAccessIndices.distance(from: Elements.Index, to: Elements.Index) -> Int
Added DefaultRandomAccessIndices.dropFirst() -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.dropFirst(_: Int) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.dropLast() -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.dropLast(_: Int) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultRandomAccessIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultRandomAccessIndices.endIndex
Added DefaultRandomAccessIndices.enumerated() -> EnumeratedSequence<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.filter(_: (Elements.Index) throws -> Bool) rethrows -> [Elements.Index]
Added DefaultRandomAccessIndices.first
Added DefaultRandomAccessIndices.first(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultRandomAccessIndices.flatMap<SegmentOfResult : Sequence>(_: (Elements.Index) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added DefaultRandomAccessIndices.flatMap<ElementOfResult>(_: (Elements.Index) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added DefaultRandomAccessIndices.forEach(_: (Elements.Index) throws -> Void) rethrows
Added DefaultRandomAccessIndices.formIndex(_: Elements.Index, offsetBy: Int)
Added DefaultRandomAccessIndices.formIndex(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Bool
Added DefaultRandomAccessIndices.formIndex(after: Elements.Index)
Added DefaultRandomAccessIndices.formIndex(before: Elements.Index)
Added DefaultRandomAccessIndices.index(_: Elements.Index, offsetBy: Int) -> Elements.Index
Added DefaultRandomAccessIndices.index(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Elements.Index?
Added DefaultRandomAccessIndices.index(after: Elements.Index) -> Elements.Index
Added DefaultRandomAccessIndices.index(before: Elements.Index) -> Elements.Index
Added DefaultRandomAccessIndices.index(of: Elements.Index) -> Elements.Index?
Added DefaultRandomAccessIndices.index(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultRandomAccessIndices.indices
Added DefaultRandomAccessIndices.indices
Added DefaultRandomAccessIndices.isEmpty
Added DefaultRandomAccessIndices.joined() -> FlattenCollection<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.joined() -> FlattenSequence<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.joined() -> FlattenBidirectionalCollection<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.joined(separator: String) -> String
Added DefaultRandomAccessIndices.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.last
Added DefaultRandomAccessIndices.lazy
Added DefaultRandomAccessIndices.lazy
Added DefaultRandomAccessIndices.lazy
Added DefaultRandomAccessIndices.lazy
Added DefaultRandomAccessIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultRandomAccessIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultRandomAccessIndices.makeIterator() -> IndexingIterator<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultRandomAccessIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultRandomAccessIndices.max() -> Elements.Index?
Added DefaultRandomAccessIndices.max(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultRandomAccessIndices.min() -> Elements.Index?
Added DefaultRandomAccessIndices.min(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultRandomAccessIndices.popFirst() -> Elements.Index?
Added DefaultRandomAccessIndices.popLast() -> Elements.Index?
Added DefaultRandomAccessIndices.prefix(_: Int) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.prefix(through: Elements.Index) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.prefix(upTo: Elements.Index) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.reduce<Result>(_: Result, _: (Result, Elements.Index) throws -> Result) rethrows -> Result
Added DefaultRandomAccessIndices.removeFirst() -> Elements.Index
Added DefaultRandomAccessIndices.removeFirst(_: Int)
Added DefaultRandomAccessIndices.removeLast() -> Elements.Index
Added DefaultRandomAccessIndices.removeLast(_: Int)
Added DefaultRandomAccessIndices.reversed() -> ReversedRandomAccessCollection<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.sorted() -> [Elements.Index]
Added DefaultRandomAccessIndices.sorted(by: (Elements.Index, Elements.Index) -> Bool) -> [Elements.Index]
Added DefaultRandomAccessIndices.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Elements.Index) throws -> Bool) rethrows -> [DefaultRandomAccessIndices<Elements>]
Added DefaultRandomAccessIndices.split(separator: Elements.Index, maxSplits: Int, omittingEmptySubsequences: Bool) -> [DefaultRandomAccessIndices<Elements>]
Added DefaultRandomAccessIndices.startIndex
Added DefaultRandomAccessIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix) -> Bool
Added DefaultRandomAccessIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultRandomAccessIndices.subscript(_: CountableRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: Elements.Index) -> Elements.Index
Added DefaultRandomAccessIndices.subscript(_: CountableClosedRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: Range<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.suffix(_: Int) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.suffix(from: Elements.Index) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.underestimatedCount
Added DefaultRandomAccessIndices.underestimatedCount
Added Dictionary.count
Added Dictionary.distance(from: DictionaryIndex<Key, Value>, to: DictionaryIndex<Key, Value>) -> Int
Added Dictionary.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (key: Key, value: Value)>(_: OtherSequence, by: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
Added Dictionary.filter(_: (Key, Value) throws -> Bool) rethrows -> [(key: Key, value: Value)]
Added Dictionary.flatMap<ElementOfResult>(_: (Key, Value) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Dictionary.flatMap<SegmentOfResult : Sequence>(_: (Key, Value) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Dictionary.formIndex(_: DictionaryIndex<Key, Value>, offsetBy: Int)
Added Dictionary.formIndex(_: DictionaryIndex<Key, Value>, offsetBy: Int, limitedBy: DictionaryIndex<Key, Value>) -> Bool
Added Dictionary.formIndex(after: DictionaryIndex<Key, Value>)
Added Dictionary.index(_: DictionaryIndex<Key, Value>, offsetBy: Int) -> DictionaryIndex<Key, Value>
Added Dictionary.index(_: DictionaryIndex<Key, Value>, offsetBy: Int, limitedBy: DictionaryIndex<Key, Value>) -> DictionaryIndex<Key, Value>?
Added Dictionary.index(after: DictionaryIndex<Key, Value>) -> DictionaryIndex<Key, Value>
Added Dictionary.index(where: (Key, Value) throws -> Bool) rethrows -> DictionaryIndex<Key, Value>?
Added Dictionary.indices
Added Dictionary.isEmpty
Added Dictionary.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (key: Key, value: Value)>(_: OtherSequence, by: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
Added Dictionary.map<T>(_: (Key, Value) throws -> T) rethrows -> [T]
Added Dictionary.map<T>(_: (Key, Value) throws -> T) rethrows -> [T]
Added Dictionary.remove(at: DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
Added Dictionary.removeValue<ConcreteKey : Hashable>(forKey: ConcreteKey) -> Value?
Added Dictionary.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (key: Key, value: Value)>(with: PossiblePrefix, by: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
Added Dictionary.subscript(_: ClosedRange<DictionaryIndex<Key, Value>>) -> Slice<Dictionary<Key, Value>>
Added Dictionary.subscript(_: DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
Added Dictionary.subscript(_: Range<DictionaryIndex<Key, Value>>) -> Slice<Dictionary<Key, Value>>
Added Dictionary.subscript(_: _Hashable) -> Value?
Added Dictionary.underestimatedCount
Added Dictionary.underestimatedCount
Added Dictionary.updateValue<ConcreteKey : Hashable>(_: Value, forKey: ConcreteKey) -> Value?
Added Double.add(_: Double)
Added Double.divide(by: Double)
Added Double.multiply(by: Double)
Added Double.pi
Added Double.subtract(_: Double)
Added EmptyCollection.count
Added EmptyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added EmptyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EmptyCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EmptyCollection.formIndex(_: Int, offsetBy: Int)
Added EmptyCollection.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added EmptyCollection.formIndex(after: Int)
Added EmptyCollection.formIndex(before: Int)
Added EmptyCollection.index(of: Element) -> Int?
Added EmptyCollection.index(where: (Element) throws -> Bool) rethrows -> Int?
Added EmptyCollection.indices
Added EmptyCollection.joined() -> FlattenSequence<EmptyCollection<Element>>
Added EmptyCollection.joined() -> FlattenBidirectionalCollection<EmptyCollection<Element>>
Added EmptyCollection.joined() -> FlattenCollection<EmptyCollection<Element>>
Added EmptyCollection.joined(separator: String) -> String
Added EmptyCollection.lazy
Added EmptyCollection.lazy
Added EmptyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added EmptyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added EmptyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added EmptyCollection.partition(by: (Element) throws -> Bool) rethrows -> Int
Added EmptyCollection.partition(by: (Element) throws -> Bool) rethrows -> Int
Added EmptyCollection.sorted() -> [Element]
Added EmptyCollection.sorted() -> [Element]
Added EmptyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [EmptyCollection<Element>]
Added EmptyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added EmptyCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added EmptyCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyCollection.subscript(_: CountableClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: ClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: Range<Int>) -> MutableSlice<EmptyCollection<Element>>
Added EmptyCollection.subscript(_: CountableClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: ClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.underestimatedCount
Added EmptyCollection.underestimatedCount
Added EmptyIterator [struct]
Added EmptyIterator.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added EmptyIterator.dropFirst() -> AnySequence<Element>
Added EmptyIterator.dropFirst(_: Int) -> AnySequence<Element>
Added EmptyIterator.dropLast() -> AnySequence<Element>
Added EmptyIterator.dropLast(_: Int) -> AnySequence<Element>
Added EmptyIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added EmptyIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyIterator.enumerated() -> EnumeratedSequence<EmptyIterator<Element>>
Added EmptyIterator.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added EmptyIterator.first(where: (Element) throws -> Bool) rethrows -> Element?
Added EmptyIterator.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EmptyIterator.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EmptyIterator.forEach(_: (Element) throws -> Void) rethrows
Added EmptyIterator.init()
Added EmptyIterator.joined() -> FlattenSequence<EmptyIterator<Element>>
Added EmptyIterator.joined(separator: String) -> String
Added EmptyIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<EmptyIterator<Element>>
Added EmptyIterator.lazy
Added EmptyIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added EmptyIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyIterator.makeIterator() -> EmptyIterator<Element>
Added EmptyIterator.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added EmptyIterator.max() -> Element?
Added EmptyIterator.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added EmptyIterator.min() -> Element?
Added EmptyIterator.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added EmptyIterator.next() -> Element?
Added EmptyIterator.prefix(_: Int) -> AnySequence<Element>
Added EmptyIterator.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added EmptyIterator.reversed() -> [Element]
Added EmptyIterator.sorted() -> [Element]
Added EmptyIterator.sorted(by: (Element, Element) -> Bool) -> [Element]
Added EmptyIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
Added EmptyIterator.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added EmptyIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added EmptyIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyIterator.suffix(_: Int) -> AnySequence<Element>
Added EmptyIterator.underestimatedCount
Added EnumeratedIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (offset: Int, element: Base.Element)>(_: OtherSequence, by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedIterator.flatMap<ElementOfResult>(_: (Int, Base.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EnumeratedIterator.flatMap<SegmentOfResult : Sequence>(_: (Int, Base.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EnumeratedIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (offset: Int, element: Base.Element)>(_: OtherSequence, by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (offset: Int, element: Base.Element)>(with: PossiblePrefix, by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedSequence.contains(where: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added EnumeratedSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (offset: Int, element: Base.Iterator.Element)>(_: OtherSequence, by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedSequence.filter(_: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> [(offset: Int, element: Base.Iterator.Element)]
Added EnumeratedSequence.first(where: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> (offset: Int, element: Base.Iterator.Element)?
Added EnumeratedSequence.flatMap<SegmentOfResult : Sequence>(_: (Int, Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EnumeratedSequence.flatMap<ElementOfResult>(_: (Int, Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EnumeratedSequence.forEach(_: (Int, Base.Iterator.Element) throws -> Void) rethrows
Added EnumeratedSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (offset: Int, element: Base.Iterator.Element)>(_: OtherSequence, by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedSequence.map<T>(_: (Int, Base.Iterator.Element) throws -> T) rethrows -> [T]
Added EnumeratedSequence.max(by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) throws -> Bool) rethrows -> (offset: Int, element: Base.Iterator.Element)?
Added EnumeratedSequence.min(by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) throws -> Bool) rethrows -> (offset: Int, element: Base.Iterator.Element)?
Added EnumeratedSequence.reduce<Result>(_: Result, _: (Result, (offset: Int, element: Base.Iterator.Element)) throws -> Result) rethrows -> Result
Added EnumeratedSequence.sorted(by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) -> Bool) -> [(offset: Int, element: Base.Iterator.Element)]
Added EnumeratedSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<(offset: Int, element: Base.Iterator.Element)>]
Added EnumeratedSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (offset: Int, element: Base.Iterator.Element)>(with: PossiblePrefix, by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) throws -> Bool) rethrows -> Bool
Added Error
Added ExpressibleByArrayLiteral.init(arrayLiteral: Self.Element)
Added ExpressibleByStringInterpolation
Added ExpressibleByStringInterpolation.init(stringInterpolation: Self)
Added ExpressibleByStringInterpolation.init<T>(stringInterpolationSegment: T)
Added FlattenBidirectionalCollection.contains(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenBidirectionalCollection.count
Added FlattenBidirectionalCollection.distance(from: FlattenBidirectionalCollectionIndex<Base>, to: FlattenBidirectionalCollectionIndex<Base>) -> Base.IndexDistance
Added FlattenBidirectionalCollection.dropFirst() -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.dropFirst(_: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.dropLast() -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.dropLast(_: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenBidirectionalCollection.enumerated() -> EnumeratedSequence<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.filter(_: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
Added FlattenBidirectionalCollection.first
Added FlattenBidirectionalCollection.first(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added FlattenBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added FlattenBidirectionalCollection.forEach(_: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows
Added FlattenBidirectionalCollection.formIndex(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance)
Added FlattenBidirectionalCollection.formIndex(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: FlattenBidirectionalCollectionIndex<Base>) -> Bool
Added FlattenBidirectionalCollection.formIndex(after: FlattenBidirectionalCollectionIndex<Base>)
Added FlattenBidirectionalCollection.formIndex(before: FlattenBidirectionalCollectionIndex<Base>)
Added FlattenBidirectionalCollection.index(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance) -> FlattenBidirectionalCollectionIndex<Base>
Added FlattenBidirectionalCollection.index(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>?
Added FlattenBidirectionalCollection.index(after: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>
Added FlattenBidirectionalCollection.index(before: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>
Added FlattenBidirectionalCollection.index(of: Base.Iterator.Element.Iterator.Element) -> FlattenBidirectionalCollectionIndex<Base>?
Added FlattenBidirectionalCollection.index(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenBidirectionalCollectionIndex<Base>?
Added FlattenBidirectionalCollection.indices
Added FlattenBidirectionalCollection.isEmpty
Added FlattenBidirectionalCollection.joined() -> FlattenCollection<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined() -> FlattenSequence<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined() -> FlattenBidirectionalCollection<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined(separator: String) -> String
Added FlattenBidirectionalCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.last
Added FlattenBidirectionalCollection.lazy
Added FlattenBidirectionalCollection.lazy
Added FlattenBidirectionalCollection.lazy
Added FlattenBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenBidirectionalCollection.makeIterator() -> FlattenIterator<Base.Iterator>
Added FlattenBidirectionalCollection.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenBidirectionalCollection.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenBidirectionalCollection.max() -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.max(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.min() -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.min(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.prefix(_: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.prefix(through: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.prefix(upTo: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
Added FlattenBidirectionalCollection.reversed() -> ReversedCollection<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.sorted() -> [Base.Iterator.Element.Iterator.Element]
Added FlattenBidirectionalCollection.sorted(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
Added FlattenBidirectionalCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>]
Added FlattenBidirectionalCollection.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>]
Added FlattenBidirectionalCollection.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added FlattenBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix) -> Bool
Added FlattenBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenBidirectionalCollection.subscript(_: FlattenBidirectionalCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element
Added FlattenBidirectionalCollection.subscript(_: ClosedRange<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.subscript(_: Range<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.subscript(_: Range<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.suffix(_: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.suffix(from: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.underestimatedCount
Added FlattenBidirectionalCollection.underestimatedCount
Added FlattenBidirectionalCollection.underestimatedCount
Added FlattenCollection.contains(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenCollection.count
Added FlattenCollection.distance(from: FlattenCollectionIndex<Base>, to: FlattenCollectionIndex<Base>) -> Base.IndexDistance
Added FlattenCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenCollection.filter(_: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
Added FlattenCollection.first
Added FlattenCollection.first(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added FlattenCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added FlattenCollection.forEach(_: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows
Added FlattenCollection.formIndex(_: FlattenCollectionIndex<Base>, offsetBy: Base.IndexDistance)
Added FlattenCollection.formIndex(_: FlattenCollectionIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: FlattenCollectionIndex<Base>) -> Bool
Added FlattenCollection.formIndex(after: FlattenCollectionIndex<Base>)
Added FlattenCollection.index(_: FlattenCollectionIndex<Base>, offsetBy: Base.IndexDistance) -> FlattenCollectionIndex<Base>
Added FlattenCollection.index(_: FlattenCollectionIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: FlattenCollectionIndex<Base>) -> FlattenCollectionIndex<Base>?
Added FlattenCollection.index(after: FlattenCollectionIndex<Base>) -> FlattenCollectionIndex<Base>
Added FlattenCollection.index(of: Base.Iterator.Element.Iterator.Element) -> FlattenCollectionIndex<Base>?
Added FlattenCollection.index(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenCollectionIndex<Base>?
Added FlattenCollection.indices
Added FlattenCollection.joined() -> FlattenCollection<FlattenCollection<Base>>
Added FlattenCollection.joined() -> FlattenSequence<FlattenCollection<Base>>
Added FlattenCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenCollection.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenCollection.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenCollection.max(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenCollection.min(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenCollection.prefix(through: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.prefix(upTo: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
Added FlattenCollection.sorted(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
Added FlattenCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Slice<FlattenCollection<Base>>]
Added FlattenCollection.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<FlattenCollection<Base>>]
Added FlattenCollection.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added FlattenCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix) -> Bool
Added FlattenCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenCollection.subscript(_: Range<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.subscript(_: Range<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.subscript(_: ClosedRange<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.subscript(_: FlattenCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element
Added FlattenCollection.suffix(from: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.underestimatedCount
Added FlattenCollection.underestimatedCount
Added FlattenCollection.underestimatedCount
Added FlattenIterator [struct]
Added FlattenIterator.contains(where: (Base.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenIterator.dropFirst() -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.dropFirst(_: Int) -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.dropLast() -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.dropLast(_: Int) -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element.Iterator.Element>(_: OtherSequence, by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenIterator.enumerated() -> EnumeratedSequence<FlattenIterator<Base>>
Added FlattenIterator.filter(_: (Base.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Element.Iterator.Element]
Added FlattenIterator.first(where: (Base.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Element.Iterator.Element?
Added FlattenIterator.flatMap<ElementOfResult>(_: (Base.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added FlattenIterator.flatMap<SegmentOfResult : Sequence>(_: (Base.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added FlattenIterator.forEach(_: (Base.Element.Iterator.Element) throws -> Void) rethrows
Added FlattenIterator.joined() -> FlattenSequence<FlattenIterator<Base>>
Added FlattenIterator.joined(separator: String) -> String
Added FlattenIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<FlattenIterator<Base>>
Added FlattenIterator.lazy
Added FlattenIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element.Iterator.Element>(_: OtherSequence, by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenIterator.makeIterator() -> FlattenIterator<Base>
Added FlattenIterator.map<T>(_: (Base.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenIterator.max() -> Base.Element.Iterator.Element?
Added FlattenIterator.max(by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Element.Iterator.Element?
Added FlattenIterator.min() -> Base.Element.Iterator.Element?
Added FlattenIterator.min(by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Element.Iterator.Element?
Added FlattenIterator.next() -> Base.Element.Iterator.Element?
Added FlattenIterator.prefix(_: Int) -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.reduce<Result>(_: Result, _: (Result, Base.Element.Iterator.Element) throws -> Result) rethrows -> Result
Added FlattenIterator.reversed() -> [Base.Element.Iterator.Element]
Added FlattenIterator.sorted() -> [Base.Element.Iterator.Element]
Added FlattenIterator.sorted(by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) -> Bool) -> [Base.Element.Iterator.Element]
Added FlattenIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Element.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Element.Iterator.Element>]
Added FlattenIterator.split(separator: Base.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Element.Iterator.Element>]
Added FlattenIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Element.Iterator.Element>(with: PossiblePrefix) -> Bool
Added FlattenIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Element.Iterator.Element>(with: PossiblePrefix, by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenIterator.suffix(_: Int) -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.underestimatedCount
Added FlattenSequence.contains(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenSequence.filter(_: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
Added FlattenSequence.first(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenSequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added FlattenSequence.flatMap<ElementOfResult>(_: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added FlattenSequence.forEach(_: (Base.Iterator.Element.Iterator.Element) throws -> Void) rethrows
Added FlattenSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenSequence.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenSequence.max(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenSequence.min(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenSequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
Added FlattenSequence.sorted(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
Added FlattenSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added FlattenSequence.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added FlattenSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix) -> Bool
Added FlattenSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Float.add(_: Float)
Added Float.divide(by: Float)
Added Float.multiply(by: Float)
Added Float.nan
Added Float.pi
Added Float.subtract(_: Float)
Added Float.ulp
Added FloatingPoint.add(_: Self)
Added FloatingPoint.adding(_: Self) -> Self
Added FloatingPoint.adding(_: Self) -> Self
Added FloatingPoint.addingProduct(_: Self, _: Self) -> Self
Added FloatingPoint.addingProduct(_: Self, _: Self) -> Self
Added FloatingPoint.divide(by: Self)
Added FloatingPoint.divided(by: Self) -> Self
Added FloatingPoint.divided(by: Self) -> Self
Added FloatingPoint.floatingPointClass
Added FloatingPoint.floatingPointClass
Added FloatingPoint.maximum(_: Self, _: Self) -> Self [class]
Added FloatingPoint.maximum(_: Self, _: Self) -> Self [class]
Added FloatingPoint.maximumMagnitude(_: Self, _: Self) -> Self [class]
Added FloatingPoint.maximumMagnitude(_: Self, _: Self) -> Self [class]
Added FloatingPoint.minimum(_: Self, _: Self) -> Self [class]
Added FloatingPoint.minimum(_: Self, _: Self) -> Self [class]
Added FloatingPoint.minimumMagnitude(_: Self, _: Self) -> Self [class]
Added FloatingPoint.minimumMagnitude(_: Self, _: Self) -> Self [class]
Added FloatingPoint.multiplied(by: Self) -> Self
Added FloatingPoint.multiplied(by: Self) -> Self
Added FloatingPoint.multiply(by: Self)
Added FloatingPoint.negated() -> Self
Added FloatingPoint.negated() -> Self
Added FloatingPoint.nextDown
Added FloatingPoint.nextDown
Added FloatingPoint.remainder(dividingBy: Self) -> Self
Added FloatingPoint.remainder(dividingBy: Self) -> Self
Added FloatingPoint.rounded(_: FloatingPointRoundingRule) -> Self
Added FloatingPoint.rounded(_: FloatingPointRoundingRule) -> Self
Added FloatingPoint.squareRoot() -> Self
Added FloatingPoint.squareRoot() -> Self
Added FloatingPoint.subtract(_: Self)
Added FloatingPoint.subtracting(_: Self) -> Self
Added FloatingPoint.subtracting(_: Self) -> Self
Added FloatingPoint.truncatingRemainder(dividingBy: Self) -> Self
Added FloatingPoint.truncatingRemainder(dividingBy: Self) -> Self
Added FloatingPoint.ulpOfOne
Added FloatingPoint.ulpOfOne
Added ImplicitlyUnwrappedOptional.none
Added ImplicitlyUnwrappedOptional.some
Added Index.samePosition(in: String.UTF8View) -> String.UTF8View.Index
Added Index.samePosition(in: String.UTF16View) -> String.UTF16View.Index
Added Index.samePosition(in: String.UnicodeScalarView) -> String.UnicodeScalarView.Index
Added Indexable.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance
Added Indexable.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance
Added Indexable.formIndex(_: Self.Index, offsetBy: Self.IndexDistance)
Added Indexable.formIndex(_: Self.Index, offsetBy: Self.IndexDistance)
Added Indexable.formIndex(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Bool
Added Indexable.formIndex(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Bool
Added Indexable.formIndex(after: Self.Index)
Added Indexable.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index
Added Indexable.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index
Added Indexable.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added Indexable.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added Indexable.subscript(_: CountableRange<Self.Index>) -> Self.SubSequence
Added Indexable.subscript(_: CountableClosedRange<Self.Index>) -> Self.SubSequence
Added Indexable.subscript(_: ClosedRange<Self.Index>) -> Self.SubSequence
Added IndexableBase
Added IndexableBase.endIndex
Added IndexableBase.formIndex(after: Self.Index)
Added IndexableBase.index(after: Self.Index) -> Self.Index
Added IndexableBase.startIndex
Added IndexableBase.subscript(_: Range<Self.Index>) -> Self.SubSequence
Added IndexableBase.subscript(_: Self.Index) -> Self._Element
Added IndexingIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements._Element>(_: OtherSequence) -> Bool
Added IndexingIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements._Element>(_: OtherSequence, by: (Elements._Element, Elements._Element) throws -> Bool) rethrows -> Bool
Added IndexingIterator.flatMap<ElementOfResult>(_: (Elements._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added IndexingIterator.flatMap<SegmentOfResult : Sequence>(_: (Elements._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added IndexingIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements._Element>(_: OtherSequence) -> Bool
Added IndexingIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements._Element>(_: OtherSequence, by: (Elements._Element, Elements._Element) throws -> Bool) rethrows -> Bool
Added IndexingIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements._Element>(with: PossiblePrefix) -> Bool
Added IndexingIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements._Element>(with: PossiblePrefix, by: (Elements._Element, Elements._Element) throws -> Bool) rethrows -> Bool
Added Int.init(exactly: UInt64)
Added Int.init(exactly: Int8)
Added Int.init(exactly: Int32)
Added Int.init(exactly: Int16)
Added Int.init(exactly: UInt16)
Added Int.init(exactly: Int64)
Added Int.init(exactly: Int)
Added Int.init(exactly: UInt32)
Added Int.init(exactly: UInt8)
Added Int.init(exactly: UInt)
Added Int16.init(exactly: Int64)
Added Int16.init(exactly: Int32)
Added Int16.init(exactly: UInt32)
Added Int16.init(exactly: UInt64)