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 : BidirectionalIndexType, C.Generator.Element == Element>(_: C)
Removed AnyBidirectionalCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, 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<C : CollectionType where C.Index : BidirectionalIndexType, 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.init(_: AnyForwardCollection<Element>)
Removed AnyForwardCollection.init(_: AnyRandomAccessCollection<Element>)
Removed AnyForwardCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
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(_: AnyForwardCollection<Element>)
Removed AnyRandomAccessCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
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<S : SequenceType where S.Generator.Element == Element, S.SubSequence : SequenceType, S.SubSequence.Generator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_: S)
Removed AnySequence.init<G : GeneratorType where G.Element == Element>(_: () -> G)
Removed AnySequence.underestimateCount() -> Int
Removed Array.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed Array.appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_: C)
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() -> IndexingGenerator<Self>
Removed CollectionType.generate() -> Self.Generator
Removed CollectionType.indexOf(_: Self.Generator.Element) -> Self.Index?
Removed CollectionType.indexOf(_: (Self.Generator.Element) throws -> Bool) rethrows -> 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>) -> Slice<Self>
Removed CollectionType.subscript(_: Self.Index) -> Self.Generator.Element
Removed CollectionType.subscript(_: Range<Self.Index>) -> Self.SubSequence
Removed CollectionType.subscript(_: Self.Index) -> Self.Base.Generator.Element
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<C : CollectionType where C.Generator.Element == Element>(_: C)
Removed ContiguousArray.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
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>(_: UnsafePointer<T>)
Removed COpaquePointer.init<T>(_: UnsafeMutablePointer<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(_: UInt)
Removed FloatingPointType.init(_: UInt32)
Removed FloatingPointType.init(_: Int8)
Removed FloatingPointType.init(_: UInt64)
Removed FloatingPointType.init(_: Int16)
Removed FloatingPointType.init(_: UInt8)
Removed FloatingPointType.init(_: Int64)
Removed FloatingPointType.init(_: Int32)
Removed FloatingPointType.init(_: Int)
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 where Intermediate.Index : BidirectionalIndexType>(_: (Self.Elements.Generator.Element) -> Intermediate) -> LazyCollection<FlattenBidirectionalCollection<LazyMapCollection<Self.Elements, Intermediate>>>
Removed LazyCollectionType.flatMap<Intermediate : CollectionType>(_: (Self.Elements.Generator.Element) -> Intermediate) -> LazyCollection<FlattenCollection<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(_: Range<Self.Index>) -> Self.SubSequence
Removed MutableCollectionType.subscript(_: Range<Self.Index>) -> MutableSlice<Self>
Removed MutableCollectionType.subscript(_: Self.Index) -> Self.Generator.Element
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._DisabledRangeIndex) -> Element
Removed Range.subscript(_: Element) -> 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<C : CollectionType where C.Generator.Element == Generator.Element>(_: C, at: Self.Index)
Removed RangeReplaceableCollectionType.insertContentsOf<S : CollectionType where S.Generator.Element == Generator.Element>(_: S, 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<S : SequenceType>(_: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
Removed SequenceType.flatMap<T>(_: (Self.Generator.Element) throws -> T?) rethrows -> [T]
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 -> [Self.SubSequence]
Removed SequenceType.split(_: Int, allowEmptySlices: Bool, isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [AnySequence<Self.Generator.Element>]
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(_: String)
Removed String.appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed String.fromCString(_: UnsafePointer<CChar>) -> String? [static]
Removed String.fromCStringRepairingIllFormedUTF8(_: UnsafePointer<CChar>) -> (String?, hadError: Bool) [static]
Removed String.init<T>(_: T)
Removed String.init<T : _SignedIntegerType>(_: T)
Removed String.init<T : UnsignedIntegerType>(_: T)
Removed String.init<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed String.init<T : _SignedIntegerType>(_: T, radix: Int, uppercase: Bool)
Removed String.init<T : UnsignedIntegerType>(_: 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: UnicodeScalar)
Removed String.init(count: Int, repeatedValue: Character)
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<C : CollectionType where C.Generator.Element == Character>(_: Range<Index>, with: C)
Removed String.replaceRange(_: Range<Index>, with: String)
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.UTF8View) -> String.UTF8View.Index?
Removed String.UTF16View.Index.samePositionIn(_: String.UnicodeScalarView) -> UnicodeScalarIndex?
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.UTF8View) -> String.UTF8View.Index
Removed UnicodeScalarIndex.samePositionIn(_: String) -> Index?
Removed UnicodeScalarIndex.samePositionIn(_: String.UTF16View) -> String.UTF16View.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>(_: UnsafePointer<U>)
Removed UnsafeMutablePointer.init<U>(_: UnsafeMutablePointer<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 !(_: T) -> Bool
Removed !(_: Bool) -> Bool
Removed !=(_: Double, _: Double) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !=(_: Float, _: Float) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !=(_: [Key : Value], _: [Key : Value]) -> Bool
Removed !==(_: L, _: R) -> Bool
Removed %(_: T, _: T) -> T
Removed %(_: Float, _: Float) -> Float
Removed %(_: Double, _: Double) -> Double
Removed %=(_: Double, _: Double)
Removed %=(_: T, _: T)
Removed %=(_: Float, _: Float)
Removed &&(_: T, _: () throws -> U) rethrows -> Bool
Removed &&(_: T, _: () throws -> Bool) 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 +(_: C, _: S) -> C
Removed +(_: String, _: String) -> String
Removed +(_: C, _: S) -> C
Removed +(_: S, _: C) -> C
Removed +(_: RRC1, _: RRC2) -> RRC1
Removed +(_: T, _: T._DisallowMixedSignArithmetic) -> T
Removed +(_: T, _: T) -> T
Removed +(_: T._DisallowMixedSignArithmetic, _: T) -> T
Removed ++(_: UInt) -> UInt
Removed ++(_: UInt8) -> UInt8
Removed ++(_: Float) -> Float
Removed ++(_: Float) -> Float
Removed ++(_: UInt32) -> UInt32
Removed ++(_: Int16) -> Int16
Removed ++(_: UInt) -> UInt
Removed ++(_: Int64) -> Int64
Removed ++(_: T) -> T
Removed ++(_: Double) -> Double
Removed ++(_: UInt16) -> UInt16
Removed ++(_: Int32) -> Int32
Removed ++(_: UInt16) -> UInt16
Removed ++(_: T) -> T
Removed ++(_: UInt32) -> UInt32
Removed ++(_: UInt64) -> UInt64
Removed ++(_: UInt8) -> UInt8
Removed ++(_: Int) -> Int
Removed ++(_: Int16) -> Int16
Removed ++(_: UInt64) -> UInt64
Removed ++(_: Int8) -> Int8
Removed ++(_: Int32) -> Int32
Removed ++(_: Int) -> Int
Removed ++(_: Int64) -> Int64
Removed ++(_: Double) -> Double
Removed ++(_: Int8) -> Int8
Removed +=(_: [Element], _: C)
Removed +=(_: _ContiguousArrayBuffer<Element>, _: C)
Removed +=(_: ContiguousArray<Element>, _: S)
Removed +=(_: String, _: String)
Removed +=(_: ContiguousArray<Element>, _: C)
Removed +=(_: [Element], _: S)
Removed +=(_: T, _: T)
Removed +=(_: T, _: T._DisallowMixedSignArithmetic)
Removed +=(_: ArraySlice<Element>, _: S)
Removed +=(_: ArraySlice<Element>, _: C)
Removed -(_: T) -> T
Removed -(_: T, _: T) -> T
Removed --(_: Int) -> Int
Removed --(_: UInt) -> UInt
Removed --(_: Int) -> Int
Removed --(_: Int8) -> Int8
Removed --(_: Int32) -> Int32
Removed --(_: Double) -> Double
Removed --(_: Int16) -> Int16
Removed --(_: Int8) -> Int8
Removed --(_: UInt32) -> UInt32
Removed --(_: Float) -> Float
Removed --(_: UInt8) -> UInt8
Removed --(_: UInt32) -> UInt32
Removed --(_: Double) -> Double
Removed --(_: Int64) -> Int64
Removed --(_: UInt64) -> UInt64
Removed --(_: Int64) -> Int64
Removed --(_: UInt16) -> UInt16
Removed --(_: Int16) -> Int16
Removed --(_: UInt16) -> UInt16
Removed --(_: UInt64) -> UInt64
Removed --(_: UInt8) -> UInt8
Removed --(_: Float) -> Float
Removed --(_: T) -> T
Removed --(_: UInt) -> UInt
Removed --(_: T) -> T
Removed --(_: Int32) -> Int32
Removed -=(_: T, _: T)
Removed -=(_: T, _: T._DisallowMixedSignArithmetic)
Removed ...(_: Bound, _: Bound) -> ClosedInterval<Bound>
Removed ...(_: Pos, _: Pos) -> Range<Pos>
Removed ...(_: Pos, _: Pos) -> Range<Pos>
Removed ..<(_: Pos, _: Pos) -> Range<Pos>
Removed ..<(_: Bound, _: Bound) -> HalfOpenInterval<Bound>
Removed ..<(_: Pos, _: Pos) -> Range<Pos>
Removed /(_: T, _: T) -> T
Removed /=(_: T, _: T)
Removed <(_: Index, _: Index) -> Bool
Removed <(_: Character, _: Character) -> Bool
Removed <(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool
Removed <(_: T?, _: T?) -> Bool
Removed <(_: UnicodeScalar, _: UnicodeScalar) -> Bool
Removed <(_: Float, _: Float) -> Bool
Removed <(_: Double, _: Double) -> Bool
Removed <(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool
Removed <(_: T, _: T) -> Bool
Removed <(_: String, _: String) -> Bool
Removed <(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool
Removed <(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool
Removed <(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> Bool
Removed <(_: ObjectIdentifier, _: ObjectIdentifier) -> Bool
Removed <(_: Bit, _: Bit) -> Bool
Removed <=(_: T, _: T) -> Bool
Removed <=(_: Float, _: Float) -> Bool
Removed <=(_: Double, _: Double) -> Bool
Removed <=(_: T?, _: T?) -> Bool
Removed ==(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool
Removed ==(_: T, _: T) -> Bool
Removed ==(_: Set<Element>, _: Set<Element>) -> Bool
Removed ==(_: FlattenCollectionIndex<BaseElements>, _: FlattenCollectionIndex<BaseElements>) -> Bool
Removed ==(_: COpaquePointer, _: COpaquePointer) -> Bool
Removed ==(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool
Removed ==(_: Double, _: Double) -> Bool
Removed ==(_: Range<Element>, _: Range<Element>) -> Bool
Removed ==(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool
Removed ==(_: FlattenBidirectionalCollectionIndex<BaseElements>, _: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool
Removed ==(_: ManagedBufferPointer<Value, Element>, _: ManagedBufferPointer<Value, Element>) -> Bool
Removed ==(_: Bit, _: Bit) -> Bool
Removed ==(_: ReverseIndex<Base>, _: ReverseIndex<Base>) -> Bool
Removed ==(_: Float, _: Float) -> Bool
Removed ==(_: ObjectIdentifier, _: ObjectIdentifier) -> Bool
Removed ==(_: AnyForwardIndex, _: AnyForwardIndex) -> Bool
Removed ==(_: Character, _: Character) -> Bool
Removed ==(_: Bool, _: Bool) -> Bool
Removed ==(_: [Key : Value], _: [Key : Value]) -> Bool
Removed ==(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool
Removed ==(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> Bool
Removed ==(_: ClosedInterval<Bound>, _: ClosedInterval<Bound>) -> Bool
Removed ==(_: T, _: T) -> Bool
Removed ==(_: HalfOpenInterval<Bound>, _: HalfOpenInterval<Bound>) -> Bool
Removed ==(_: AnyBidirectionalIndex, _: AnyBidirectionalIndex) -> Bool
Removed ==(_: AnyRandomAccessIndex, _: AnyRandomAccessIndex) -> Bool
Removed ==(_: UnicodeScalar, _: UnicodeScalar) -> Bool
Removed ==(_: String.UTF8View.Index, _: String.UTF8View.Index) -> Bool
Removed ==(_: String, _: String) -> Bool
Removed ==(_: Index, _: Index) -> Bool
Removed ==(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Removed ===(_: L, _: R) -> Bool
Removed >(_: Double, _: Double) -> Bool
Removed >(_: Float, _: Float) -> Bool
Removed >(_: T, _: T) -> Bool
Removed >(_: T?, _: T?) -> Bool
Removed >=(_: T, _: T) -> Bool
Removed >=(_: T?, _: T?) -> Bool
Removed >=(_: Double, _: Double) -> Bool
Removed >=(_: Float, _: Float) -> Bool
Removed >=(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> 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<G : GeneratorType>(_: G) -> AnyGenerator<G.Element>
Removed anyGenerator<Element>(_: () -> Element?) -> AnyGenerator<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 : _SignedIntegerType>(_: T) -> U
Removed numericCast<T : _SignedIntegerType, U : _SignedIntegerType>(_: T) -> U
Removed numericCast<T : _SignedIntegerType, U : UnsignedIntegerType>(_: T) -> U
Removed numericCast<T : UnsignedIntegerType, U : UnsignedIntegerType>(_: 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 -> U) rethrows -> Bool
Removed ||(_: T, _: () throws -> Bool) rethrows -> Bool
Removed ~=(_: I, _: I.Bound) -> Bool
Removed ~=(_: Range<I>, _: I) -> 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<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnyBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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() -> FlattenSequence<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.joined() -> FlattenBidirectionalCollection<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) -> [AnySequence<Element>]
Added AnyBidirectionalCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyBidirectionalCollection<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 : 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.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.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) -> [AnySequence<Element>]
Added AnyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyCollection<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() -> FlattenSequence<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.joined() -> FlattenCollection<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.joined() -> FlattenBidirectionalCollection<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<C : Collection where C.Iterator.Element == Element>(contentsOf: C)
Added Array.append<S : Sequence where S.Iterator.Element == Element>(contentsOf: S)
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() -> FlattenCollection<Array<Element>>
Added Array.joined() -> FlattenBidirectionalCollection<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(_: Range<Int>) -> MutableSlice<Array<Element>>
Added Array.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added Array.underestimatedCount
Added Array.underestimatedCount
Added ArraySlice.append<S : Sequence where S.Iterator.Element == Element>(contentsOf: S)
Added ArraySlice.append<C : Collection where C.Iterator.Element == Element>(contentsOf: C)
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) -> [AnySequence<Element>]
Added ArraySlice.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<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(_: CountableRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: Range<Int>) -> MutableSlice<ArraySlice<Element>>
Added ArraySlice.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: ClosedRange<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<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added BidirectionalSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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() -> FlattenSequence<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined() -> FlattenBidirectionalCollection<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined() -> FlattenCollection<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) -> [BidirectionalSlice<Base>]
Added BidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
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(_: Range<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: Base.Index) -> Base._Element
Added BidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: Range<Base.Index>) -> BidirectionalSlice<BidirectionalSlice<Base>>
Added BidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> BidirectionalSlice<Base>
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(_: Range<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.subscript(_: ClosedRange<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(_: Range<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.subscript(_: CountableClosedRange<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: String) -> String
Added ClosedRangeIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<ClosedRangeIterator<Bound>>
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>) -> Slice<Self>
Added Collection.subscript(_: Range<Self.Index>) -> Self.SubSequence
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() -> FlattenCollection<CollectionOfOne<Element>>
Added CollectionOfOne.joined() -> FlattenBidirectionalCollection<CollectionOfOne<Element>>
Added CollectionOfOne.joined() -> FlattenSequence<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) -> [AnySequence<Element>]
Added CollectionOfOne.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRandomAccessSlice<CollectionOfOne<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(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: Range<Int>) -> MutableSlice<CollectionOfOne<Element>>
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(_: ClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: Range<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<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<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ContiguousArray.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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() -> FlattenSequence<ContiguousArray<Element>>
Added ContiguousArray.joined() -> FlattenCollection<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) -> [ArraySlice<Element>]
Added ContiguousArray.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<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(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: Range<Int>) -> MutableSlice<ContiguousArray<Element>>
Added ContiguousArray.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: CountableRange<Int>) -> ArraySlice<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(_: ClosedRange<Bound>)
Added CountableClosedRange.init(_: Range<Bound>)
Added CountableClosedRange.init(_: CountableClosedRange<Bound>)
Added CountableClosedRange.init(_: CountableRange<Bound>)
Added CountableClosedRange.init(uncheckedBounds: (lower: Bound, upper: Bound))
Added CountableClosedRange.isEmpty
Added CountableClosedRange.isEmpty
Added CountableClosedRange.joined() -> FlattenBidirectionalCollection<CountableClosedRange<Bound>>
Added CountableClosedRange.joined() -> FlattenCollection<CountableClosedRange<Bound>>
Added CountableClosedRange.joined() -> FlattenSequence<CountableClosedRange<Bound>>
Added CountableClosedRange.joined(separator: String) -> String
Added CountableClosedRange.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<CountableClosedRange<Bound>>
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(_: ClosedRange<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.subscript(_: Range<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.subscript(_: Range<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.subscript(_: ClosedRangeIndex<Bound>) -> 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(_: ClosedRange<Bound>)
Added CountableRange.init(_: CountableRange<Bound>)
Added CountableRange.init(_: CountableClosedRange<Bound>)
Added CountableRange.init(_: Range<Bound>)
Added CountableRange.init(uncheckedBounds: (lower: Bound, upper: Bound))
Added CountableRange.isEmpty
Added CountableRange.isEmpty
Added CountableRange.joined() -> FlattenBidirectionalCollection<CountableRange<Bound>>
Added CountableRange.joined() -> FlattenSequence<CountableRange<Bound>>
Added CountableRange.joined() -> FlattenCollection<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(_: ClosedRange<Bound>) -> Bool
Added CountableRange.overlaps(_: CountableRange<Bound>) -> Bool
Added CountableRange.overlaps(_: CountableClosedRange<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(_: Bound) -> Bound
Added CountableRange.subscript(_: Range<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: CountableClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: ClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: CountableRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: CountableClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: CountableRange<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<ElementOfResult>(_: (Elements.Index) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added DefaultBidirectionalIndices.flatMap<SegmentOfResult : Sequence>(_: (Elements.Index) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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 : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.joined(separator: String) -> String
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(_: CountableClosedRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: Range<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: CountableRange<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(_: CountableRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: CountableClosedRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: Elements.Index) -> Elements.Index
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() -> FlattenSequence<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.joined() -> FlattenBidirectionalCollection<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.joined() -> FlattenCollection<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(_: CountableClosedRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: CountableRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: Range<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: Elements.Index) -> Elements.Index
Added DefaultRandomAccessIndices.subscript(_: ClosedRange<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<SegmentOfResult : Sequence>(_: (Key, Value) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Dictionary.flatMap<ElementOfResult>(_: (Key, Value) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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(_: DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
Added Dictionary.subscript(_: ClosedRange<DictionaryIndex<Key, Value>>) -> Slice<Dictionary<Key, Value>>
Added Dictionary.subscript(_: _Hashable) -> Value?
Added Dictionary.subscript(_: Range<DictionaryIndex<Key, Value>>) -> Slice<Dictionary<Key, 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<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EmptyCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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() -> FlattenCollection<EmptyCollection<Element>>
Added EmptyCollection.joined() -> FlattenBidirectionalCollection<EmptyCollection<Element>>
Added EmptyCollection.joined() -> FlattenSequence<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(_: CountableRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: ClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: ClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: Range<Int>) -> MutableSlice<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<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EmptyIterator.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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<ElementOfResult>(_: (Int, Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EnumeratedSequence.flatMap<SegmentOfResult : Sequence>(_: (Int, Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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<ElementOfResult>(_: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added FlattenBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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() -> FlattenBidirectionalCollection<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined() -> FlattenSequence<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined(separator: String) -> String
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(_: ClosedRange<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.subscript(_: Range<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.subscript(_: FlattenBidirectionalCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element
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(_: FlattenCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element
Added FlattenCollection.subscript(_: Range<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.subscript(_: ClosedRange<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.subscript(_: Range<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>>
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 : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<FlattenIterator<Base>>
Added FlattenIterator.joined(separator: String) -> String
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.UnicodeScalarView) -> String.UnicodeScalarView.Index
Added Index.samePosition(in: String.UTF16View) -> String.UTF16View.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(_: CountableClosedRange<Self.Index>) -> Self.SubSequence
Added Indexable.subscript(_: ClosedRange<Self.Index>) -> Self.SubSequence
Added Indexable.subscript(_: CountableRange<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: Int)
Added Int.init(exactly: UInt16)
Added Int.init(exactly: UInt64)
Added Int.init(exactly: Int8)
Added Int.init(exactly: Int32)
Added Int.init(exactly: Int64)
Added Int.init(exactly: Int16)
Added Int.init(exactly: UInt32)
Added Int.init(exactly: UInt8)
Added Int.init(exactly: UInt)
Added Int16.init(exactly: UInt)
Added Int16.init(exactly: Int8)
Added Int16.init(exactly: UInt16)
Added Int16.init(exactly: UInt32)
Added Int16.init(exactly: UInt64)
Added Int16.init(exactly: UInt8)
Added Int16.init(exactly: Int)
Added Int16.init(exactly: Int64)
Added Int16.init(exactly: Int16)
Added Int16.init(exactly: Int32)
Added Int32.init(exactly: Int32)
Added Int32.init(exactly: UInt64)
Added Int32.init(exactly: Int)
Added Int32.init(exactly: Int64)
Added Int32.init(exactly: UInt8)
Added Int32.init(exactly: UInt16)
Added Int32.init(exactly: UInt)
Added Int32.init(exactly: Int16)
Added Int32.init(exactly: Int8)
Added Int32.init(exactly: UInt32)
Added Int64.init(exactly: UInt32)
Added Int64.init(exactly: Int)
Added Int64.init(exactly: Int16)
Added Int64.init(exactly: UInt)
Added Int64.init(exactly: Int32)
Added Int64.init(exactly: Int64)
Added Int64.init(exactly: UInt16)
Added Int64.init(exactly: Int8)
Added Int64.init(exactly: UInt64)
Added Int64.init(exactly: UInt8)
Added Int8.init(exactly: Int64)
Added Int8.init(exactly: Int8)
Added Int8.init(exactly: Int)
Added Int8.init(exactly: Int32)
Added Int8.init(exactly: UInt)
Added Int8.init(exactly: UInt32)
Added Int8.init(exactly: Int16)
Added Int8.init(exactly: UInt8)
Added Int8.init(exactly: UInt64)
Added Int8.init(exactly: UInt16)
Added Integer
Added IntegerArithmetic
Added IntegerArithmetic.%(_: Self, _: Self) -> Self
Added IntegerArithmetic.*(_: Self, _: Self) -> Self
Added IntegerArithmetic.+(_: Self, _: Self) -> Self
Added IntegerArithmetic.-(_: Self, _: Self) -> Self
Added IntegerArithmetic./(_: Self, _: Self) -> Self
Added IntegerArithmetic.toIntMax() -> IntMax
Added IteratorOverOne.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added IteratorOverOne.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added IteratorOverOne.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added IteratorOverOne.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added IteratorOverOne.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added IteratorOverOne.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added IteratorOverOne.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added IteratorOverOne.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added IteratorSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence) -> Bool
Added IteratorSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence, by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Bool
Added IteratorSequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added IteratorSequence.flatMap<ElementOfResult>(_: (Base.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added IteratorSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence) -> Bool
Added IteratorSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence, by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Bool
Added IteratorSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Element>(with: PossiblePrefix) -> Bool
Added IteratorSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Element>(with: PossiblePrefix, by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Bool
Added JoinedIterator [struct]
Added JoinedIterator.init<Separator : Sequence where Separator.Iterator.Element == Base.Element.Iterator.Element>(base: Base, separator: Separator)
Added JoinedIterator.next() -> Base.Element.Iterator.Element?
Added JoinedSequence.contains(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added JoinedSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added JoinedSequence.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 JoinedSequence.filter(_: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
Added JoinedSequence.first(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added JoinedSequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added JoinedSequence.flatMap<ElementOfResult>(_: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added JoinedSequence.forEach(_: (Base.Iterator.Element.Iterator.Element) throws -> Void) rethrows
Added JoinedSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added JoinedSequence.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 JoinedSequence.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added JoinedSequence.max(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added JoinedSequence.min(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added JoinedSequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
Added JoinedSequence.sorted(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
Added JoinedSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added JoinedSequence.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added JoinedSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix) -> Bool
Added JoinedSequence.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 LazyBidirectionalCollection [struct]
Added LazyBidirectionalCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyBidirectionalCollection.count
Added LazyBidirectionalCollection.count
Added LazyBidirectionalCollection.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added LazyBidirectionalCollection.dropFirst() -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.dropFirst(_: Int) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.dropLast() -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.elements
Added LazyBidirectionalCollection.elements
Added LazyBidirectionalCollection.elements
Added LazyBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyBidirectionalCollection.endIndex
Added LazyBidirectionalCollection.enumerated() -> EnumeratedSequence<LazyBidirectionalCollection<Base>>
Added LazyBidirectionalCollection.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterBidirectionalCollection<Base>
Added LazyBidirectionalCollection.first
Added LazyBidirectionalCollection.first
Added LazyBidirectionalCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<Base, ElementOfResult?>>, ElementOfResult>
Added LazyBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult>
Added LazyBidirectionalCollection.flatMap<SegmentOfResult : Collection where SegmentOfResult : BidirectionalCollection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenBidirectionalCollection<LazyMapBidirectionalCollection<Base, SegmentOfResult>>>
Added LazyBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>>
Added LazyBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<Base, ElementOfResult?>>, ElementOfResult>
Added LazyBidirectionalCollection.flatMap<SegmentOfResult : Collection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<Base, SegmentOfResult>>>
Added LazyBidirectionalCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazyBidirectionalCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyBidirectionalCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyBidirectionalCollection.formIndex(after: Base.Index)
Added LazyBidirectionalCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyBidirectionalCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyBidirectionalCollection.index(after: Base.Index) -> Base.Index
Added LazyBidirectionalCollection.index(before: Base.Index) -> Base.Index
Added LazyBidirectionalCollection.index(of: Base.Iterator.Element) -> Base.Index?
Added LazyBidirectionalCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Index?
Added LazyBidirectionalCollection.indices
Added LazyBidirectionalCollection.indices
Added LazyBidirectionalCollection.isEmpty
Added LazyBidirectionalCollection.isEmpty
Added LazyBidirectionalCollection.joined() -> FlattenCollection<LazyBidirectionalCollection<Base>>
Added LazyBidirectionalCollection.joined() -> LazyCollection<FlattenBidirectionalCollection<Base>>
Added LazyBidirectionalCollection.joined() -> FlattenSequence<LazyBidirectionalCollection<Base>>
Added LazyBidirectionalCollection.joined() -> LazyCollection<FlattenCollection<Base>>
Added LazyBidirectionalCollection.joined() -> LazySequence<FlattenSequence<Base>>
Added LazyBidirectionalCollection.joined(separator: String) -> String
Added LazyBidirectionalCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyBidirectionalCollection<Base>>
Added LazyBidirectionalCollection.last
Added LazyBidirectionalCollection.lazy
Added LazyBidirectionalCollection.lazy
Added LazyBidirectionalCollection.lazy
Added LazyBidirectionalCollection.lazy
Added LazyBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyBidirectionalCollection.makeIterator() -> Base.Iterator
Added LazyBidirectionalCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>
Added LazyBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapBidirectionalCollection<Base, U>
Added LazyBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<Base, U>
Added LazyBidirectionalCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyBidirectionalCollection.max() -> Base.Iterator.Element?
Added LazyBidirectionalCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyBidirectionalCollection.min() -> Base.Iterator.Element?
Added LazyBidirectionalCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyBidirectionalCollection.popFirst() -> Base.Iterator.Element?
Added LazyBidirectionalCollection.prefix(_: Int) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.prefix(through: Base.Index) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.prefix(upTo: Base.Index) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyBidirectionalCollection.removeFirst() -> Base.Iterator.Element
Added LazyBidirectionalCollection.removeFirst(_: Int)
Added LazyBidirectionalCollection.reversed() -> LazyBidirectionalCollection<ReversedCollection<Base>>
Added LazyBidirectionalCollection.sorted() -> [Base.Iterator.Element]
Added LazyBidirectionalCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyBidirectionalCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyBidirectionalCollection<BidirectionalSlice<Base>>]
Added LazyBidirectionalCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [LazyBidirectionalCollection<BidirectionalSlice<Base>>]
Added LazyBidirectionalCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazyBidirectionalCollection.startIndex
Added LazyBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added LazyBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyBidirectionalCollection.subscript(_: Base.Index) -> Base.Iterator.Element
Added LazyBidirectionalCollection.subscript(_: CountableRange<Base.Index>) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.subscript(_: CountableClosedRange<Base.Index>) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.subscript(_: Range<Base.Index>) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.subscript(_: ClosedRange<Base.Index>) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.suffix(from: Base.Index) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.underestimatedCount
Added LazyBidirectionalCollection.underestimatedCount
Added LazyBidirectionalCollection.underestimatedCount
Added LazyCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyCollection.count
Added LazyCollection.count
Added LazyCollection.elements
Added LazyCollection.elements
Added LazyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyCollection.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterCollection<Base>
Added LazyCollection.first
Added LazyCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>>
Added LazyCollection.flatMap<SegmentOfResult : Collection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<Base, SegmentOfResult>>>
Added LazyCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult>
Added LazyCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<Base, ElementOfResult?>>, ElementOfResult>
Added LazyCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazyCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyCollection.formIndex(after: Base.Index)
Added LazyCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyCollection.index(after: Base.Index) -> Base.Index
Added LazyCollection.index(of: Base.Iterator.Element) -> Base.Index?
Added LazyCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Index?
Added LazyCollection.isEmpty
Added LazyCollection.joined() -> LazySequence<FlattenSequence<Base>>
Added LazyCollection.joined() -> LazyCollection<FlattenCollection<Base>>
Added LazyCollection.joined() -> FlattenSequence<LazyCollection<Base>>
Added LazyCollection.joined() -> FlattenCollection<LazyCollection<Base>>
Added LazyCollection.lazy
Added LazyCollection.lazy
Added LazyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<Base, U>
Added LazyCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>
Added LazyCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyCollection.popFirst() -> Base.Iterator.Element?
Added LazyCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyCollection.removeFirst() -> Base.Iterator.Element
Added LazyCollection.removeFirst(_: Int)
Added LazyCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyCollection<Slice<Base>>]
Added LazyCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [LazyCollection<Slice<Base>>]
Added LazyCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazyCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added LazyCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyCollection.subscript(_: CountableClosedRange<Base.Index>) -> LazyCollection<Slice<Base>>
Added LazyCollection.subscript(_: CountableRange<Base.Index>) -> LazyCollection<Slice<Base>>
Added LazyCollection.subscript(_: ClosedRange<Base.Index>) -> LazyCollection<Slice<Base>>
Added LazyCollection.subscript(_: Base.Index) -> Base.Iterator.Element
Added LazyCollection.underestimatedCount
Added LazyCollection.underestimatedCount
Added LazyCollection.underestimatedCount
Added LazyCollectionProtocol.elements
Added LazyCollectionProtocol.filter(_: (Self.Elements.Iterator.Element) -> Bool) -> LazyFilterCollection<Self.Elements>
Added LazyCollectionProtocol.flatMap<SegmentOfResult : Collection>(_: (Self.Elements.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<Self.Elements, SegmentOfResult>>>
Added LazyCollectionProtocol.flatMap<ElementOfResult>(_: (Self.Elements.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<Self.Elements, ElementOfResult?>>, ElementOfResult>
Added LazyCollectionProtocol.joined() -> LazyCollection<FlattenCollection<Self.Elements>>
Added LazyCollectionProtocol.map<U>(_: (Self.Elements.Iterator.Element) -> U) -> LazyMapCollection<Self.Elements, U>
Added LazyFilterBidirectionalCollection [struct]
Added LazyFilterBidirectionalCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterBidirectionalCollection.count
Added LazyFilterBidirectionalCollection.distance(from: LazyFilterIndex<Base>, to: LazyFilterIndex<Base>) -> Base.IndexDistance
Added LazyFilterBidirectionalCollection.dropFirst() -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.dropFirst(_: Int) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.dropLast() -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.dropLast(_: Int) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.elements
Added LazyFilterBidirectionalCollection.elements
Added LazyFilterBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterBidirectionalCollection.endIndex
Added LazyFilterBidirectionalCollection.enumerated() -> EnumeratedSequence<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterBidirectionalCollection<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.first
Added LazyFilterBidirectionalCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyFilterBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyFilterBidirectionalCollection<Base>, ElementOfResult?>>, ElementOfResult>
Added LazyFilterBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyFilterBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyFilterBidirectionalCollection<Base>, ElementOfResult?>>, ElementOfResult>
Added LazyFilterBidirectionalCollection.flatMap<SegmentOfResult : Collection where SegmentOfResult : BidirectionalCollection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenBidirectionalCollection<LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<Base>, SegmentOfResult>>>
Added LazyFilterBidirectionalCollection.flatMap<SegmentOfResult : Collection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyFilterBidirectionalCollection<Base>, SegmentOfResult>>>
Added LazyFilterBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<Base>, ElementOfResult?>>, ElementOfResult>
Added LazyFilterBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyFilterBidirectionalCollection<Base>, SegmentOfResult>>>
Added LazyFilterBidirectionalCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazyFilterBidirectionalCollection.formIndex(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance)
Added LazyFilterBidirectionalCollection.formIndex(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: LazyFilterIndex<Base>) -> Bool
Added LazyFilterBidirectionalCollection.formIndex(after: LazyFilterIndex<Base>)
Added LazyFilterBidirectionalCollection.formIndex(before: LazyFilterIndex<Base>)
Added LazyFilterBidirectionalCollection.index(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance) -> LazyFilterIndex<Base>
Added LazyFilterBidirectionalCollection.index(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: LazyFilterIndex<Base>) -> LazyFilterIndex<Base>?
Added LazyFilterBidirectionalCollection.index(after: LazyFilterIndex<Base>) -> LazyFilterIndex<Base>
Added LazyFilterBidirectionalCollection.index(before: LazyFilterIndex<Base>) -> LazyFilterIndex<Base>
Added LazyFilterBidirectionalCollection.index(of: Base.Iterator.Element) -> LazyFilterIndex<Base>?
Added LazyFilterBidirectionalCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> LazyFilterIndex<Base>?
Added LazyFilterBidirectionalCollection.indices
Added LazyFilterBidirectionalCollection.isEmpty
Added LazyFilterBidirectionalCollection.joined() -> LazyCollection<FlattenBidirectionalCollection<LazyFilterBidirectionalCollection<Base>>>
Added LazyFilterBidirectionalCollection.joined() -> LazyCollection<FlattenCollection<LazyFilterBidirectionalCollection<Base>>>
Added LazyFilterBidirectionalCollection.joined() -> LazySequence<FlattenSequence<LazyFilterBidirectionalCollection<Base>>>
Added LazyFilterBidirectionalCollection.joined() -> FlattenCollection<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.joined() -> FlattenBidirectionalCollection<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.joined() -> FlattenSequence<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.joined(separator: String) -> String
Added LazyFilterBidirectionalCollection.last
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterBidirectionalCollection.makeIterator() -> LazyFilterIterator<Base.Iterator>
Added LazyFilterBidirectionalCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyFilterBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<Base>, U>
Added LazyFilterBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<LazyFilterBidirectionalCollection<Base>, U>
Added LazyFilterBidirectionalCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyFilterBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterBidirectionalCollection<Base>, U>
Added LazyFilterBidirectionalCollection.max() -> Base.Iterator.Element?
Added LazyFilterBidirectionalCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterBidirectionalCollection.min() -> Base.Iterator.Element?
Added LazyFilterBidirectionalCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterBidirectionalCollection.prefix(_: Int) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.prefix(through: LazyFilterIndex<Base>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.prefix(upTo: LazyFilterIndex<Base>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyFilterBidirectionalCollection.reversed() -> LazyBidirectionalCollection<ReversedCollection<LazyFilterBidirectionalCollection<Base>>>
Added LazyFilterBidirectionalCollection.sorted() -> [Base.Iterator.Element]
Added LazyFilterBidirectionalCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyFilterBidirectionalCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>]
Added LazyFilterBidirectionalCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazyFilterBidirectionalCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>]
Added LazyFilterBidirectionalCollection.startIndex
Added LazyFilterBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added LazyFilterBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterBidirectionalCollection.subscript(_: LazyFilterIndex<Base>) -> Base.Iterator.Element
Added LazyFilterBidirectionalCollection.subscript(_: ClosedRange<LazyFilterIndex<Base>>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.subscript(_: Range<LazyFilterIndex<Base>>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.subscript(_: Range<LazyFilterIndex<Base>>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.suffix(_: Int) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.suffix(from: LazyFilterIndex<Base>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.underestimatedCount
Added LazyFilterBidirectionalCollection.underestimatedCount
Added LazyFilterCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterCollection.count
Added LazyFilterCollection.distance(from: LazyFilterIndex<Base>, to: LazyFilterIndex<Base>) -> Base.IndexDistance
Added LazyFilterCollection.elements
Added LazyFilterCollection.elements
Added LazyFilterCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterCollection.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterCollection<LazyFilterCollection<Base>>
Added LazyFilterCollection.first
Added LazyFilterCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterCollection.flatMap<SegmentOfResult : Collection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyFilterCollection<Base>, SegmentOfResult>>>
Added LazyFilterCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyFilterCollection<Base>, ElementOfResult?>>, ElementOfResult>
Added LazyFilterCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyFilterCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyFilterCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyFilterCollection<Base>, ElementOfResult?>>, ElementOfResult>
Added LazyFilterCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyFilterCollection<Base>, SegmentOfResult>>>
Added LazyFilterCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazyFilterCollection.formIndex(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance)
Added LazyFilterCollection.formIndex(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: LazyFilterIndex<Base>) -> Bool
Added LazyFilterCollection.index(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance) -> LazyFilterIndex<Base>
Added LazyFilterCollection.index(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: LazyFilterIndex<Base>) -> LazyFilterIndex<Base>?
Added LazyFilterCollection.index(of: Base.Iterator.Element) -> LazyFilterIndex<Base>?
Added LazyFilterCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> LazyFilterIndex<Base>?
Added LazyFilterCollection.indices
Added LazyFilterCollection.joined() -> FlattenSequence<LazyFilterCollection<Base>>
Added LazyFilterCollection.joined() -> LazyCollection<FlattenCollection<LazyFilterCollection<Base>>>
Added LazyFilterCollection.joined() -> FlattenCollection<LazyFilterCollection<Base>>
Added LazyFilterCollection.joined() -> LazySequence<FlattenSequence<LazyFilterCollection<Base>>>
Added LazyFilterCollection.lazy
Added LazyFilterCollection.lazy
Added LazyFilterCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyFilterCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterCollection<Base>, U>
Added LazyFilterCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyFilterCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<LazyFilterCollection<Base>, U>
Added LazyFilterCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyFilterCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyFilterCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [Slice<LazyFilterCollection<Base>>]
Added LazyFilterCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazyFilterCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<LazyFilterCollection<Base>>]
Added LazyFilterCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added LazyFilterCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterCollection.subscript(_: LazyFilterIndex<Base>) -> Base.Iterator.Element
Added LazyFilterCollection.subscript(_: ClosedRange<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>>
Added LazyFilterCollection.subscript(_: Range<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>>
Added LazyFilterCollection.subscript(_: Range<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>>
Added LazyFilterCollection.underestimatedCount
Added LazyFilterCollection.underestimatedCount
Added LazyFilterIterator [struct]
Added LazyFilterIterator.base
Added LazyFilterIterator.contains(where: (Base.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterIterator.dropFirst() -> AnySequence<Base.Element>
Added LazyFilterIterator.dropFirst(_: Int) -> AnySequence<Base.Element>
Added LazyFilterIterator.dropLast() -> AnySequence<Base.Element>
Added LazyFilterIterator.dropLast(_: Int) -> AnySequence<Base.Element>
Added LazyFilterIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence) -> Bool
Added LazyFilterIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence, by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterIterator.enumerated() -> EnumeratedSequence<LazyFilterIterator<Base>>
Added LazyFilterIterator.filter(_: (Base.Element) throws -> Bool) rethrows -> [Base.Element]
Added LazyFilterIterator.first(where: (Base.Element) throws -> Bool) rethrows -> Base.Element?
Added LazyFilterIterator.flatMap<SegmentOfResult : Sequence>(_: (Base.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyFilterIterator.flatMap<ElementOfResult>(_: (Base.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyFilterIterator.forEach(_: (Base.Element) throws -> Void) rethrows
Added LazyFilterIterator.joined() -> FlattenSequence<LazyFilterIterator<Base>>
Added LazyFilterIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyFilterIterator<Base>>
Added LazyFilterIterator.joined(separator: String) -> String
Added LazyFilterIterator.lazy
Added LazyFilterIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence) -> Bool
Added LazyFilterIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence, by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterIterator.makeIterator() -> LazyFilterIterator<Base>
Added LazyFilterIterator.map<T>(_: (Base.Element) throws -> T) rethrows -> [T]
Added LazyFilterIterator.max() -> Base.Element?
Added LazyFilterIterator.max(by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Base.Element?
Added LazyFilterIterator.min() -> Base.Element?
Added LazyFilterIterator.min(by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Base.Element?
Added LazyFilterIterator.next() -> Base.Element?
Added LazyFilterIterator.prefix(_: Int) -> AnySequence<Base.Element>
Added LazyFilterIterator.reduce<Result>(_: Result, _: (Result, Base.Element) throws -> Result) rethrows -> Result
Added LazyFilterIterator.reversed() -> [Base.Element]
Added LazyFilterIterator.sorted() -> [Base.Element]
Added LazyFilterIterator.sorted(by: (Base.Element, Base.Element) -> Bool) -> [Base.Element]
Added LazyFilterIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Element) throws -> Bool) rethrows -> [AnySequence<Base.Element>]
Added LazyFilterIterator.split(separator: Base.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Element>]
Added LazyFilterIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Element>(with: PossiblePrefix) -> Bool
Added LazyFilterIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Element>(with: PossiblePrefix, by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterIterator.suffix(_: Int) -> AnySequence<Base.Element>
Added LazyFilterIterator.underestimatedCount
Added LazyFilterSequence.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterSequence.elements
Added LazyFilterSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterSequence.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterSequence<LazyFilterSequence<Base>>
Added LazyFilterSequence.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterSequence.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyFilterSequence<Base>, ElementOfResult?>>, ElementOfResult>
Added LazyFilterSequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyFilterSequence<Base>, SegmentOfResult>>>
Added LazyFilterSequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyFilterSequence.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyFilterSequence.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazyFilterSequence.joined() -> LazySequence<FlattenSequence<LazyFilterSequence<Base>>>
Added LazyFilterSequence.joined() -> FlattenSequence<LazyFilterSequence<Base>>
Added LazyFilterSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterSequence.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterSequence<Base>, U>
Added LazyFilterSequence.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyFilterSequence.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterSequence.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterSequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyFilterSequence.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyFilterSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>]
Added LazyFilterSequence.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazyFilterSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added LazyFilterSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyMapBidirectionalCollection [struct]
Added LazyMapBidirectionalCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added LazyMapBidirectionalCollection.count
Added LazyMapBidirectionalCollection.count
Added LazyMapBidirectionalCollection.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added LazyMapBidirectionalCollection.dropFirst() -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.dropFirst(_: Int) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.dropLast() -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.dropLast(_: Int) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.elements
Added LazyMapBidirectionalCollection.elements
Added LazyMapBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapBidirectionalCollection.endIndex
Added LazyMapBidirectionalCollection.enumerated() -> EnumeratedSequence<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.filter(_: (Element) -> Bool) -> LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.first
Added LazyMapBidirectionalCollection.first
Added LazyMapBidirectionalCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added LazyMapBidirectionalCollection.flatMap<SegmentOfResult : Collection>(_: (Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyMapBidirectionalCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapBidirectionalCollection.flatMap<SegmentOfResult : Collection where SegmentOfResult : BidirectionalCollection>(_: (Element) -> SegmentOfResult) -> LazyCollection<FlattenBidirectionalCollection<LazyMapBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapBidirectionalCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapBidirectionalCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyMapBidirectionalCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyMapBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyMapBidirectionalCollection.forEach(_: (Element) throws -> Void) rethrows
Added LazyMapBidirectionalCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyMapBidirectionalCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyMapBidirectionalCollection.formIndex(after: Base.Index)
Added LazyMapBidirectionalCollection.formIndex(before: Base.Index)
Added LazyMapBidirectionalCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyMapBidirectionalCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyMapBidirectionalCollection.index(after: Base.Index) -> Base.Index
Added LazyMapBidirectionalCollection.index(before: Base.Index) -> Base.Index
Added LazyMapBidirectionalCollection.index(of: Element) -> Base.Index?
Added LazyMapBidirectionalCollection.index(where: (Element) throws -> Bool) rethrows -> Base.Index?
Added LazyMapBidirectionalCollection.indices
Added LazyMapBidirectionalCollection.indices
Added LazyMapBidirectionalCollection.indices
Added LazyMapBidirectionalCollection.isEmpty
Added LazyMapBidirectionalCollection.isEmpty
Added LazyMapBidirectionalCollection.joined() -> LazyCollection<FlattenCollection<LazyMapBidirectionalCollection<Base, Element>>>
Added LazyMapBidirectionalCollection.joined() -> LazyCollection<FlattenBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>>>
Added LazyMapBidirectionalCollection.joined() -> LazySequence<FlattenSequence<LazyMapBidirectionalCollection<Base, Element>>>
Added LazyMapBidirectionalCollection.joined() -> FlattenBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.joined() -> FlattenCollection<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.joined() -> FlattenSequence<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.joined(separator: String) -> String
Added LazyMapBidirectionalCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.last
Added LazyMapBidirectionalCollection.last
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapBidirectionalCollection.makeIterator() -> LazyMapIterator<Base.Iterator, Element>
Added LazyMapBidirectionalCollection.map<U>(_: (Element) -> U) -> LazyMapBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>, U>
Added LazyMapBidirectionalCollection.map<U>(_: (Element) -> U) -> LazyMapSequence<LazyMapBidirectionalCollection<Base, Element>, U>
Added LazyMapBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapBidirectionalCollection.map<U>(_: (Element) -> U) -> LazyMapCollection<LazyMapBidirectionalCollection<Base, Element>, U>
Added LazyMapBidirectionalCollection.max() -> Element?
Added LazyMapBidirectionalCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added LazyMapBidirectionalCollection.min() -> Element?
Added LazyMapBidirectionalCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added LazyMapBidirectionalCollection.prefix(_: Int) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.prefix(through: Base.Index) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.prefix(upTo: Base.Index) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added LazyMapBidirectionalCollection.reversed() -> LazyBidirectionalCollection<ReversedCollection<LazyMapBidirectionalCollection<Base, Element>>>
Added LazyMapBidirectionalCollection.sorted() -> [Element]
Added LazyMapBidirectionalCollection.sorted(by: (Element, Element) -> Bool) -> [Element]
Added LazyMapBidirectionalCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>]
Added LazyMapBidirectionalCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>]
Added LazyMapBidirectionalCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added LazyMapBidirectionalCollection.startIndex
Added LazyMapBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added LazyMapBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapBidirectionalCollection.subscript(_: CountableClosedRange<Base.Index>) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.subscript(_: ClosedRange<Base.Index>) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.subscript(_: Range<Base.Index>) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.subscript(_: Base.Index) -> Element
Added LazyMapBidirectionalCollection.subscript(_: CountableRange<Base.Index>) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.subscript(_: Range<Base.Index>) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.suffix(_: Int) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.suffix(from: Base.Index) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.underestimatedCount
Added LazyMapBidirectionalCollection.underestimatedCount
Added LazyMapBidirectionalCollection.underestimatedCount
Added LazyMapCollection.count
Added LazyMapCollection.count
Added LazyMapCollection.elements
Added LazyMapCollection.elements
Added LazyMapCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapCollection.first
Added LazyMapCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyMapCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyMapCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapCollection.flatMap<SegmentOfResult : Collection>(_: (Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyMapCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyMapCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyMapCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyMapCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyMapCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyMapCollection.index(of: Element) -> Base.Index?
Added LazyMapCollection.index(where: (Element) throws -> Bool) rethrows -> Base.Index?
Added LazyMapCollection.isEmpty
Added LazyMapCollection.joined() -> LazyCollection<FlattenCollection<LazyMapCollection<Base, Element>>>
Added LazyMapCollection.joined() -> LazySequence<FlattenSequence<LazyMapCollection<Base, Element>>>
Added LazyMapCollection.joined() -> FlattenCollection<LazyMapCollection<Base, Element>>
Added LazyMapCollection.joined() -> FlattenSequence<LazyMapCollection<Base, Element>>
Added LazyMapCollection.lazy
Added LazyMapCollection.lazy
Added LazyMapCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapCollection.map<U>(_: (Element) -> U) -> LazyMapCollection<LazyMapCollection<Base, Element>, U>
Added LazyMapCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapCollection.map<U>(_: (Element) -> U) -> LazyMapSequence<LazyMapCollection<Base, Element>, U>
Added LazyMapCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added LazyMapCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<LazyMapCollection<Base, Element>>]
Added LazyMapCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added LazyMapCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapCollection.subscript(_: CountableRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>>
Added LazyMapCollection.subscript(_: Range<Base.Index>) -> Slice<LazyMapCollection<Base, Element>>
Added LazyMapCollection.subscript(_: Range<Base.Index>) -> Slice<LazyMapCollection<Base, Element>>
Added LazyMapCollection.subscript(_: CountableClosedRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>>
Added LazyMapCollection.subscript(_: ClosedRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>>
Added LazyMapCollection.underestimatedCount
Added LazyMapCollection.underestimatedCount
Added LazyMapCollection.underestimatedCount
Added LazyMapIterator [struct]
Added LazyMapIterator.base
Added LazyMapIterator.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added LazyMapIterator.dropFirst() -> AnySequence<Element>
Added LazyMapIterator.dropFirst(_: Int) -> AnySequence<Element>
Added LazyMapIterator.dropLast() -> AnySequence<Element>
Added LazyMapIterator.dropLast(_: Int) -> AnySequence<Element>
Added LazyMapIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapIterator.enumerated() -> EnumeratedSequence<LazyMapIterator<Base, Element>>
Added LazyMapIterator.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added LazyMapIterator.first(where: (Element) throws -> Bool) rethrows -> Element?
Added LazyMapIterator.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyMapIterator.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyMapIterator.forEach(_: (Element) throws -> Void) rethrows
Added LazyMapIterator.joined() -> FlattenSequence<LazyMapIterator<Base, Element>>
Added LazyMapIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyMapIterator<Base, Element>>
Added LazyMapIterator.joined(separator: String) -> String
Added LazyMapIterator.lazy
Added LazyMapIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapIterator.makeIterator() -> LazyMapIterator<Base, Element>
Added LazyMapIterator.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapIterator.max() -> Element?
Added LazyMapIterator.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added LazyMapIterator.min() -> Element?
Added LazyMapIterator.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added LazyMapIterator.next() -> Element?
Added LazyMapIterator.prefix(_: Int) -> AnySequence<Element>
Added LazyMapIterator.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added LazyMapIterator.reversed() -> [Element]
Added LazyMapIterator.sorted() -> [Element]
Added LazyMapIterator.sorted(by: (Element, Element) -> Bool) -> [Element]
Added LazyMapIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
Added LazyMapIterator.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added LazyMapIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added LazyMapIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapIterator.suffix(_: Int) -> AnySequence<Element>
Added LazyMapIterator.underestimatedCount
Added LazyMapRandomAccessCollection [struct]
Added LazyMapRandomAccessCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added LazyMapRandomAccessCollection.count
Added LazyMapRandomAccessCollection.count
Added LazyMapRandomAccessCollection.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added LazyMapRandomAccessCollection.dropFirst() -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.dropFirst(_: Int) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.dropLast() -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.dropLast(_: Int) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.elements
Added LazyMapRandomAccessCollection.elements
Added LazyMapRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapRandomAccessCollection.endIndex
Added LazyMapRandomAccessCollection.enumerated() -> EnumeratedSequence<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.filter(_: (Element) -> Bool) -> LazyFilterBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.first
Added LazyMapRandomAccessCollection.first
Added LazyMapRandomAccessCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added LazyMapRandomAccessCollection.flatMap<SegmentOfResult : Collection where SegmentOfResult : BidirectionalCollection>(_: (Element) -> SegmentOfResult) -> LazyCollection<FlattenBidirectionalCollection<LazyMapBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapRandomAccessCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyMapRandomAccessCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyMapRandomAccessCollection.flatMap<SegmentOfResult : Collection>(_: (Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyMapRandomAccessCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapRandomAccessCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyMapRandomAccessCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapRandomAccessCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapRandomAccessCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapRandomAccessCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapRandomAccessCollection.forEach(_: (Element) throws -> Void) rethrows
Added LazyMapRandomAccessCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyMapRandomAccessCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyMapRandomAccessCollection.formIndex(after: Base.Index)
Added LazyMapRandomAccessCollection.formIndex(before: Base.Index)
Added LazyMapRandomAccessCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyMapRandomAccessCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyMapRandomAccessCollection.index(after: Base.Index) -> Base.Index
Added LazyMapRandomAccessCollection.index(before: Base.Index) -> Base.Index
Added LazyMapRandomAccessCollection.index(of: Element) -> Base.Index?
Added LazyMapRandomAccessCollection.index(where: (Element) throws -> Bool) rethrows -> Base.Index?
Added LazyMapRandomAccessCollection.indices
Added LazyMapRandomAccessCollection.indices
Added LazyMapRandomAccessCollection.indices
Added LazyMapRandomAccessCollection.indices
Added LazyMapRandomAccessCollection.indices
Added LazyMapRandomAccessCollection.isEmpty
Added LazyMapRandomAccessCollection.isEmpty
Added LazyMapRandomAccessCollection.joined() -> LazyCollection<FlattenCollection<LazyMapRandomAccessCollection<Base, Element>>>
Added LazyMapRandomAccessCollection.joined() -> FlattenBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.joined() -> FlattenSequence<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.joined() -> LazySequence<FlattenSequence<LazyMapRandomAccessCollection<Base, Element>>>
Added LazyMapRandomAccessCollection.joined() -> FlattenCollection<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.joined() -> LazyCollection<FlattenBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>>>
Added LazyMapRandomAccessCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.joined(separator: String) -> String
Added LazyMapRandomAccessCollection.last
Added LazyMapRandomAccessCollection.last
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapRandomAccessCollection.makeIterator() -> LazyMapIterator<Base.Iterator, Element>
Added LazyMapRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapRandomAccessCollection.map<U>(_: (Element) -> U) -> LazyMapRandomAccessCollection<LazyMapRandomAccessCollection<Base, Element>, U>
Added LazyMapRandomAccessCollection.map<U>(_: (Element) -> U) -> LazyMapBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>, U>
Added LazyMapRandomAccessCollection.map<U>(_: (Element) -> U) -> LazyMapSequence<LazyMapRandomAccessCollection<Base, Element>, U>
Added LazyMapRandomAccessCollection.map<U>(_: (Element) -> U) -> LazyMapCollection<LazyMapRandomAccessCollection<Base, Element>, U>
Added LazyMapRandomAccessCollection.max() -> Element?
Added LazyMapRandomAccessCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added LazyMapRandomAccessCollection.min() -> Element?
Added LazyMapRandomAccessCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added LazyMapRandomAccessCollection.prefix(_: Int) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.prefix(through: Base.Index) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.prefix(upTo: Base.Index) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added LazyMapRandomAccessCollection.reversed() -> LazyRandomAccessCollection<ReversedRandomAccessCollection<LazyMapRandomAccessCollection<Base, Element>>>
Added LazyMapRandomAccessCollection.sorted() -> [Element]
Added LazyMapRandomAccessCollection.sorted(by: (Element, Element) -> Bool) -> [Element]
Added LazyMapRandomAccessCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>]
Added LazyMapRandomAccessCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>]
Added LazyMapRandomAccessCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added LazyMapRandomAccessCollection.startIndex
Added LazyMapRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added LazyMapRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapRandomAccessCollection.subscript(_: ClosedRange<Base.Index>) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.subscript(_: CountableRange<Base.Index>) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.subscript(_: Range<Base.Index>) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.subscript(_: Base.Index) -> Element
Added LazyMapRandomAccessCollection.subscript(_: CountableClosedRange<Base.Index>) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.subscript(_: Range<Base.Index>) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.suffix(_: Int) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.suffix(from: Base.Index) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.underestimatedCount
Added LazyMapRandomAccessCollection.underestimatedCount
Added LazyMapRandomAccessCollection.underestimatedCount
Added LazyMapSequence.elements
Added LazyMapSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapSequence.flatMap<SegmentOfResult : Sequence>(_: (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapSequence<Base, Element>, SegmentOfResult>>>
Added LazyMapSequence.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyMapSequence.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyMapSequence.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapSequence<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapSequence.joined() -> FlattenSequence<LazyMapSequence<Base, Element>>
Added LazyMapSequence.joined() -> LazySequence<FlattenSequence<LazyMapSequence<Base, Element>>>
Added LazyMapSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added LazyMapSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapSequence.underestimatedCount
Added LazyMapSequence.underestimatedCount
Added LazyRandomAccessCollection [struct]
Added LazyRandomAccessCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyRandomAccessCollection.count
Added LazyRandomAccessCollection.count
Added LazyRandomAccessCollection.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added LazyRandomAccessCollection.dropFirst() -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.dropFirst(_: Int) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.dropLast() -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.elements
Added LazyRandomAccessCollection.elements
Added LazyRandomAccessCollection.elements
Added LazyRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyRandomAccessCollection.endIndex
Added LazyRandomAccessCollection.enumerated() -> EnumeratedSequence<LazyRandomAccessCollection<Base>>
Added LazyRandomAccessCollection.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterBidirectionalCollection<Base>
Added LazyRandomAccessCollection.first
Added LazyRandomAccessCollection.first
Added LazyRandomAccessCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyRandomAccessCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<Base, ElementOfResult?>>, ElementOfResult>
Added LazyRandomAccessCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult>
Added LazyRandomAccessCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyRandomAccessCollection.flatMap<SegmentOfResult : Collection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<Base, SegmentOfResult>>>
Added LazyRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyRandomAccessCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<Base, ElementOfResult?>>, ElementOfResult>
Added LazyRandomAccessCollection.flatMap<SegmentOfResult : Collection where SegmentOfResult : BidirectionalCollection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenBidirectionalCollection<LazyMapBidirectionalCollection<Base, SegmentOfResult>>>
Added LazyRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>>
Added LazyRandomAccessCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazyRandomAccessCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyRandomAccessCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyRandomAccessCollection.formIndex(after: Base.Index)
Added LazyRandomAccessCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyRandomAccessCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyRandomAccessCollection.index(after: Base.Index) -> Base.Index
Added LazyRandomAccessCollection.index(before: Base.Index) -> Base.Index
Added LazyRandomAccessCollection.index(of: Base.Iterator.Element) -> Base.Index?
Added LazyRandomAccessCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Index?
Added LazyRandomAccessCollection.indices
Added LazyRandomAccessCollection.indices
Added LazyRandomAccessCollection.isEmpty
Added LazyRandomAccessCollection.isEmpty
Added LazyRandomAccessCollection.joined() -> LazySequence<FlattenSequence<Base>>
Added LazyRandomAccessCollection.joined() -> FlattenCollection<LazyRandomAccessCollection<Base>>
Added LazyRandomAccessCollection.joined() -> LazyCollection<FlattenCollection<Base>>
Added LazyRandomAccessCollection.joined() -> LazyCollection<FlattenBidirectionalCollection<Base>>
Added LazyRandomAccessCollection.joined() -> FlattenSequence<LazyRandomAccessCollection<Base>>
Added LazyRandomAccessCollection.joined(separator: String) -> String
Added LazyRandomAccessCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyRandomAccessCollection<Base>>
Added LazyRandomAccessCollection.last
Added LazyRandomAccessCollection.lazy
Added LazyRandomAccessCollection.lazy
Added LazyRandomAccessCollection.lazy
Added LazyRandomAccessCollection.lazy
Added LazyRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyRandomAccessCollection.makeIterator() -> Base.Iterator
Added LazyRandomAccessCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<Base, U>
Added LazyRandomAccessCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>
Added LazyRandomAccessCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapBidirectionalCollection<Base, U>
Added LazyRandomAccessCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyRandomAccessCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyRandomAccessCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapRandomAccessCollection<Base, U>
Added LazyRandomAccessCollection.max() -> Base.Iterator.Element?
Added LazyRandomAccessCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyRandomAccessCollection.min() -> Base.Iterator.Element?
Added LazyRandomAccessCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyRandomAccessCollection.popFirst() -> Base.Iterator.Element?
Added LazyRandomAccessCollection.prefix(_: Int) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.prefix(through: Base.Index) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.prefix(upTo: Base.Index) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyRandomAccessCollection.removeFirst() -> Base.Iterator.Element
Added LazyRandomAccessCollection.removeFirst(_: Int)
Added LazyRandomAccessCollection.reversed() -> LazyRandomAccessCollection<ReversedRandomAccessCollection<Base>>
Added LazyRandomAccessCollection.sorted() -> [Base.Iterator.Element]
Added LazyRandomAccessCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyRandomAccessCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyRandomAccessCollection<RandomAccessSlice<Base>>]
Added LazyRandomAccessCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazyRandomAccessCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [LazyRandomAccessCollection<RandomAccessSlice<Base>>]
Added LazyRandomAccessCollection.startIndex
Added LazyRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added LazyRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyRandomAccessCollection.subscript(_: Base.Index) -> Base.Iterator.Element
Added LazyRandomAccessCollection.subscript(_: CountableClosedRange<Base.Index>) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.subscript(_: Range<Base.Index>) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.subscript(_: ClosedRange<Base.Index>) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.subscript(_: CountableRange<Base.Index>) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.suffix(from: Base.Index) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.underestimatedCount
Added LazyRandomAccessCollection.underestimatedCount
Added LazyRandomAccessCollection.underestimatedCount
Added LazySequence.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazySequence.elements
Added LazySequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazySequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazySequence.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterSequence<Base>
Added LazySequence.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazySequence.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult>
Added LazySequence.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazySequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazySequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>>
Added LazySequence.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazySequence.joined() -> LazySequence<FlattenSequence<Base>>
Added LazySequence.joined() -> FlattenSequence<LazySequence<Base>>
Added LazySequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazySequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazySequence.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>
Added LazySequence.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazySequence.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazySequence.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazySequence.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazySequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazySequence.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazySequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>]
Added LazySequence.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazySequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added LazySequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazySequence.underestimatedCount
Added LazySequence.underestimatedCount
Added LazySequenceProtocol.filter(_: (Self.Elements.Iterator.Element) -> Bool) -> LazyFilterSequence<Self.Elements>
Added LazySequenceProtocol.flatMap<SegmentOfResult : Sequence>(_: (Self.Elements.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Self.Elements, SegmentOfResult>>>
Added LazySequenceProtocol.flatMap<ElementOfResult>(_: (Self.Elements.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Self.Elements, ElementOfResult?>>, ElementOfResult>
Added LazySequenceProtocol.lazy
Added LazySequenceProtocol.map<U>(_: (Self.Elements.Iterator.Element) -> U) -> LazyMapSequence<Self.Elements, U>
Added Mirror.init<Subject, C : Collection where C.Iterator.Element == Child, C.SubSequence : Collection, C.SubSequence.Iterator.Element == Child, 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>(_: Subject, children: C, displayStyle: Mirror.DisplayStyle?, ancestorRepresentation: Mirror.AncestorRepresentation)
Added Mirror.init<Subject, C : Collection where C.SubSequence : Collection, C.SubSequence.SubSequence == C.SubSequence, C.Indices : Collection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: Subject, unlabeledChildren: C, displayStyle: Mirror.DisplayStyle?, ancestorRepresentation: Mirror.AncestorRepresentation)
Added Mirror.LegacyChildren.contains(where: (String?, Any) throws -> Bool) rethrows -> Bool
Added Mirror.LegacyChildren.count
Added Mirror.LegacyChildren.distance(from: Int, to: Int) -> Int
Added Mirror.LegacyChildren.dropFirst() -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.dropFirst(_: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.dropLast() -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.dropLast(_: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (label: String?, value: Any)>(_: OtherSequence, by: ((label: String?, value: Any), (label: String?, value: Any)) throws -> Bool) rethrows -> Bool
Added Mirror.LegacyChildren.enumerated() -> EnumeratedSequence<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.filter(_: (String?, Any) throws -> Bool) rethrows -> [(label: String?, value: Any)]
Added Mirror.LegacyChildren.first
Added Mirror.LegacyChildren.first(where: (String?, Any) throws -> Bool) rethrows -> (label: String?, value: Any)?
Added Mirror.LegacyChildren.flatMap<SegmentOfResult : Sequence>(_: (String?, Any) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Mirror.LegacyChildren.flatMap<ElementOfResult>(_: (String?, Any) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Mirror.LegacyChildren.forEach(_: (String?, Any) throws -> Void) rethrows
Added Mirror.LegacyChildren.formIndex(_: Int, offsetBy: Int)
Added Mirror.LegacyChildren.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Mirror.LegacyChildren.formIndex(after: Int)
Added Mirror.LegacyChildren.formIndex(before: Int)
Added Mirror.LegacyChildren.index(_: Int, offsetBy: Int) -> Int
Added Mirror.LegacyChildren.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added Mirror.LegacyChildren.index(after: Int) -> Int
Added Mirror.LegacyChildren.index(before: Int) -> Int
Added Mirror.LegacyChildren.index(where: (String?, Any) throws -> Bool) rethrows -> Int?
Added Mirror.LegacyChildren.indices
Added Mirror.LegacyChildren.isEmpty
Added Mirror.LegacyChildren.last
Added Mirror.LegacyChildren.lazy
Added Mirror.LegacyChildren.lazy
Added Mirror.LegacyChildren.lazy
Added Mirror.LegacyChildren.lazy
Added Mirror.LegacyChildren.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (label: String?, value: Any)>(_: OtherSequence, by: ((label: String?, value: Any), (label: String?, value: Any)) throws -> Bool) rethrows -> Bool
Added Mirror.LegacyChildren.makeIterator() -> IndexingIterator<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.map<T>(_: (String?, Any) throws -> T) rethrows -> [T]
Added Mirror.LegacyChildren.map<T>(_: (String?, Any) throws -> T) rethrows -> [T]
Added Mirror.LegacyChildren.max(by: ((label: String?, value: Any), (label: String?, value: Any)) throws -> Bool) rethrows -> (label: String?, value: Any)?
Added Mirror.LegacyChildren.min(by: ((label: String?, value: Any), (label: String?, value: Any)) throws -> Bool) rethrows -> (label: String?, value: Any)?
Added Mirror.LegacyChildren.prefix(_: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.prefix(through: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.prefix(upTo: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.reduce<Result>(_: Result, _: (Result, (label: String?, value: Any)) throws -> Result) rethrows -> Result
Added Mirror.LegacyChildren.reversed() -> ReversedRandomAccessCollection<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.sorted(by: ((label: String?, value: Any), (label: String?, value: Any)) -> Bool) -> [(label: String?, value: Any)]
Added Mirror.LegacyChildren.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (String?, Any) throws -> Bool) rethrows -> [RandomAccessSlice<Mirror.LegacyChildren>]
Added Mirror.LegacyChildren.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (label: String?, value: Any)>(with: PossiblePrefix, by: ((label: String?, value: Any), (label: String?, value: Any)) throws -> Bool) rethrows -> Bool
Added Mirror.LegacyChildren.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.subscript(_: CountableRange<Int>) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.subscript(_: Range<Int>) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.suffix(_: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.suffix(from: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.underestimatedCount
Added Mirror.LegacyChildren.underestimatedCount
Added MutableBidirectionalSlice [struct]
Added MutableBidirectionalSlice.base
Added MutableBidirectionalSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added MutableBidirectionalSlice.count
Added MutableBidirectionalSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added MutableBidirectionalSlice.dropFirst() -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.dropFirst(_: Int) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.dropLast() -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.dropLast(_: Int) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableBidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableBidirectionalSlice.endIndex
Added MutableBidirectionalSlice.enumerated() -> EnumeratedSequence<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added MutableBidirectionalSlice.first
Added MutableBidirectionalSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableBidirectionalSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added MutableBidirectionalSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added MutableBidirectionalSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added MutableBidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added MutableBidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added MutableBidirectionalSlice.formIndex(after: Base.Index)
Added MutableBidirectionalSlice.formIndex(before: Base.Index)
Added MutableBidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added MutableBidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added MutableBidirectionalSlice.index(after: Base.Index) -> Base.Index
Added MutableBidirectionalSlice.index(before: Base.Index) -> Base.Index
Added MutableBidirectionalSlice.index(of: Base._Element) -> Base.Index?
Added MutableBidirectionalSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added MutableBidirectionalSlice.indices
Added MutableBidirectionalSlice.init(base: Base, bounds: Range<Base.Index>)
Added MutableBidirectionalSlice.isEmpty
Added MutableBidirectionalSlice.joined() -> FlattenCollection<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.joined() -> FlattenSequence<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.joined() -> FlattenBidirectionalCollection<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.joined(separator: String) -> String
Added MutableBidirectionalSlice.last
Added MutableBidirectionalSlice.lazy
Added MutableBidirectionalSlice.lazy
Added MutableBidirectionalSlice.lazy
Added MutableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableBidirectionalSlice.makeIterator() -> IndexingIterator<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableBidirectionalSlice.max() -> Base._Element?
Added MutableBidirectionalSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableBidirectionalSlice.min() -> Base._Element?
Added MutableBidirectionalSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableBidirectionalSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableBidirectionalSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableBidirectionalSlice.popFirst() -> Base._Element?
Added MutableBidirectionalSlice.popLast() -> Base._Element?
Added MutableBidirectionalSlice.prefix(_: Int) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.prefix(through: Base.Index) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.prefix(upTo: Base.Index) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableBidirectionalSlice.removeFirst() -> Base._Element
Added MutableBidirectionalSlice.removeFirst(_: Int)
Added MutableBidirectionalSlice.removeLast() -> Base._Element
Added MutableBidirectionalSlice.removeLast(_: Int)
Added MutableBidirectionalSlice.reversed() -> ReversedCollection<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.sorted() -> [Base._Element]
Added MutableBidirectionalSlice.sorted() -> [Base._Element]
Added MutableBidirectionalSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableBidirectionalSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableBidirectionalSlice<Base>]
Added MutableBidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableBidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableBidirectionalSlice<Base>]
Added MutableBidirectionalSlice.startIndex
Added MutableBidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added MutableBidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableBidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: Range<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: Base.Index) -> Base._Element
Added MutableBidirectionalSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.suffix(_: Int) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.suffix(from: Base.Index) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.underestimatedCount
Added MutableBidirectionalSlice.underestimatedCount
Added MutableCollection.partition(by: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Index
Added MutableCollection.partition(by: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Index
Added MutableCollection.sorted() -> [Self.Iterator.Element]
Added MutableCollection.sorted(by: (Self.Iterator.Element, Self.Iterator.Element) -> Bool) -> [Self.Iterator.Element]
Added MutableCollection.subscript(_: Range<Self.Index>) -> Self.SubSequence
Added MutableCollection.subscript(_: Range<Self.Index>) -> MutableSlice<Self>
Added MutableIndexable.formIndex(after: Self.Index)
Added MutableIndexable.index(after: Self.Index) -> Self.Index
Added MutableIndexable.subscript(_: CountableRange<Self.Index>) -> Self.SubSequence
Added MutableIndexable.subscript(_: CountableClosedRange<Self.Index>) -> Self.SubSequence
Added MutableIndexable.subscript(_: Range<Self.Index>) -> Self.SubSequence
Added MutableIndexable.subscript(_: ClosedRange<Self.Index>) -> Self.SubSequence
Added MutableRandomAccessSlice [struct]
Added MutableRandomAccessSlice.base
Added MutableRandomAccessSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRandomAccessSlice.count
Added MutableRandomAccessSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added MutableRandomAccessSlice.dropFirst() -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.dropFirst(_: Int) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.dropLast() -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.dropLast(_: Int) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRandomAccessSlice.endIndex
Added MutableRandomAccessSlice.enumerated() -> EnumeratedSequence<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added MutableRandomAccessSlice.first
Added MutableRandomAccessSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRandomAccessSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added MutableRandomAccessSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added MutableRandomAccessSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added MutableRandomAccessSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added MutableRandomAccessSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added MutableRandomAccessSlice.formIndex(after: Base.Index)
Added MutableRandomAccessSlice.formIndex(before: Base.Index)
Added MutableRandomAccessSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added MutableRandomAccessSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added MutableRandomAccessSlice.index(after: Base.Index) -> Base.Index
Added MutableRandomAccessSlice.index(before: Base.Index) -> Base.Index
Added MutableRandomAccessSlice.index(of: Base._Element) -> Base.Index?
Added MutableRandomAccessSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added MutableRandomAccessSlice.indices
Added MutableRandomAccessSlice.init(base: Base, bounds: Range<Base.Index>)
Added MutableRandomAccessSlice.isEmpty
Added MutableRandomAccessSlice.joined() -> FlattenCollection<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.joined() -> FlattenSequence<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.joined() -> FlattenBidirectionalCollection<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.joined(separator: String) -> String
Added MutableRandomAccessSlice.last
Added MutableRandomAccessSlice.lazy
Added MutableRandomAccessSlice.lazy
Added MutableRandomAccessSlice.lazy
Added MutableRandomAccessSlice.lazy
Added MutableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRandomAccessSlice.makeIterator() -> IndexingIterator<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRandomAccessSlice.max() -> Base._Element?
Added MutableRandomAccessSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRandomAccessSlice.min() -> Base._Element?
Added MutableRandomAccessSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRandomAccessSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRandomAccessSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRandomAccessSlice.popFirst() -> Base._Element?
Added MutableRandomAccessSlice.popLast() -> Base._Element?
Added MutableRandomAccessSlice.prefix(_: Int) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.prefix(through: Base.Index) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.prefix(upTo: Base.Index) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableRandomAccessSlice.removeFirst() -> Base._Element
Added MutableRandomAccessSlice.removeFirst(_: Int)
Added MutableRandomAccessSlice.removeLast() -> Base._Element
Added MutableRandomAccessSlice.removeLast(_: Int)
Added MutableRandomAccessSlice.reversed() -> ReversedRandomAccessCollection<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.sort()
Added MutableRandomAccessSlice.sort(by: (Base._Element, Base._Element) -> Bool)
Added MutableRandomAccessSlice.sorted() -> [Base._Element]
Added MutableRandomAccessSlice.sorted() -> [Base._Element]
Added MutableRandomAccessSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableRandomAccessSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<Base>]
Added MutableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRandomAccessSlice<Base>]
Added MutableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableRandomAccessSlice.startIndex
Added MutableRandomAccessSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added MutableRandomAccessSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.subscript(_: Base.Index) -> Base._Element
Added MutableRandomAccessSlice.subscript(_: CountableRange<Base.Index>) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.subscript(_: Range<Base.Index>) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.subscript(_: CountableRange<Base.Index>) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.suffix(_: Int) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.suffix(from: Base.Index) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.underestimatedCount
Added MutableRandomAccessSlice.underestimatedCount
Added MutableRangeReplaceableBidirectionalSlice [struct]
Added MutableRangeReplaceableBidirectionalSlice.append(_: Base._Element)
Added MutableRangeReplaceableBidirectionalSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added MutableRangeReplaceableBidirectionalSlice.base
Added MutableRangeReplaceableBidirectionalSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableBidirectionalSlice.count
Added MutableRangeReplaceableBidirectionalSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added MutableRangeReplaceableBidirectionalSlice.dropFirst() -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.dropFirst(_: Int) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.dropLast() -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.dropLast(_: Int) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableBidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableBidirectionalSlice.endIndex
Added MutableRangeReplaceableBidirectionalSlice.enumerated() -> EnumeratedSequence<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added MutableRangeReplaceableBidirectionalSlice.first
Added MutableRangeReplaceableBidirectionalSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added MutableRangeReplaceableBidirectionalSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added MutableRangeReplaceableBidirectionalSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added MutableRangeReplaceableBidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added MutableRangeReplaceableBidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added MutableRangeReplaceableBidirectionalSlice.formIndex(after: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.formIndex(before: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added MutableRangeReplaceableBidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added MutableRangeReplaceableBidirectionalSlice.index(after: Base.Index) -> Base.Index
Added MutableRangeReplaceableBidirectionalSlice.index(before: Base.Index) -> Base.Index
Added MutableRangeReplaceableBidirectionalSlice.index(of: Base._Element) -> Base.Index?
Added MutableRangeReplaceableBidirectionalSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added MutableRangeReplaceableBidirectionalSlice.indices
Added MutableRangeReplaceableBidirectionalSlice.init()
Added MutableRangeReplaceableBidirectionalSlice.init<S : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableBidirectionalSlice.init<S where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableBidirectionalSlice.init(base: Base, bounds: Range<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableBidirectionalSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableBidirectionalSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.isEmpty
Added MutableRangeReplaceableBidirectionalSlice.joined() -> FlattenBidirectionalCollection<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.joined() -> FlattenCollection<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.joined() -> FlattenSequence<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.joined(separator: String) -> String
Added MutableRangeReplaceableBidirectionalSlice.last
Added MutableRangeReplaceableBidirectionalSlice.lazy
Added MutableRangeReplaceableBidirectionalSlice.lazy
Added MutableRangeReplaceableBidirectionalSlice.lazy
Added MutableRangeReplaceableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableBidirectionalSlice.makeIterator() -> IndexingIterator<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableBidirectionalSlice.max() -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.min() -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRangeReplaceableBidirectionalSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRangeReplaceableBidirectionalSlice.popFirst() -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.popLast() -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.prefix(_: Int) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.prefix(through: Base.Index) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.prefix(upTo: Base.Index) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableRangeReplaceableBidirectionalSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeAll(keepingCapacity: Bool)
Added MutableRangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeSubrange(_: Range<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.removeSubrange(_: ClosedRange<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.removeSubrange(_: CountableRange<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.removeSubrange(_: Range<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: Range<Base.Index>, with: C)
Added MutableRangeReplaceableBidirectionalSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableClosedRange<Base.Index>, with: C)
Added MutableRangeReplaceableBidirectionalSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableRange<Base.Index>, with: C)
Added MutableRangeReplaceableBidirectionalSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: ClosedRange<Base.Index>, with: C)
Added MutableRangeReplaceableBidirectionalSlice.reserveCapacity(_: Base.IndexDistance)
Added MutableRangeReplaceableBidirectionalSlice.reversed() -> ReversedCollection<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableBidirectionalSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableBidirectionalSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableRangeReplaceableBidirectionalSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableRangeReplaceableBidirectionalSlice<Base>]
Added MutableRangeReplaceableBidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRangeReplaceableBidirectionalSlice<Base>]
Added MutableRangeReplaceableBidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableRangeReplaceableBidirectionalSlice.startIndex
Added MutableRangeReplaceableBidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added MutableRangeReplaceableBidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: Base.Index) -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: Range<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.suffix(_: Int) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.suffix(from: Base.Index) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.underestimatedCount
Added MutableRangeReplaceableBidirectionalSlice.underestimatedCount
Added MutableRangeReplaceableRandomAccessSlice [struct]
Added MutableRangeReplaceableRandomAccessSlice.append(_: Base._Element)
Added MutableRangeReplaceableRandomAccessSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added MutableRangeReplaceableRandomAccessSlice.base
Added MutableRangeReplaceableRandomAccessSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableRandomAccessSlice.count
Added MutableRangeReplaceableRandomAccessSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added MutableRangeReplaceableRandomAccessSlice.dropFirst() -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.dropFirst(_: Int) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.dropLast() -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.dropLast(_: Int) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableRandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableRandomAccessSlice.endIndex
Added MutableRangeReplaceableRandomAccessSlice.enumerated() -> EnumeratedSequence<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added MutableRangeReplaceableRandomAccessSlice.first
Added MutableRangeReplaceableRandomAccessSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added MutableRangeReplaceableRandomAccessSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added MutableRangeReplaceableRandomAccessSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added MutableRangeReplaceableRandomAccessSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added MutableRangeReplaceableRandomAccessSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added MutableRangeReplaceableRandomAccessSlice.formIndex(after: Base.Index)
Added MutableRangeReplaceableRandomAccessSlice.formIndex(before: Base.Index)
Added MutableRangeReplaceableRandomAccessSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added MutableRangeReplaceableRandomAccessSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added MutableRangeReplaceableRandomAccessSlice.index(after: Base.Index) -> Base.Index
Added MutableRangeReplaceableRandomAccessSlice.index(before: Base.Index) -> Base.Index
Added MutableRangeReplaceableRandomAccessSlice.index(of: Base._Element) -> Base.Index?
Added MutableRangeReplaceableRandomAccessSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added MutableRangeReplaceableRandomAccessSlice.indices
Added MutableRangeReplaceableRandomAccessSlice.init()
Added MutableRangeReplaceableRandomAccessSlice.init<S where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableRandomAccessSlice.init<S : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableRandomAccessSlice.init(base: Base, bounds: Range<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableRandomAccessSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableRandomAccessSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableRandomAccessSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableRandomAccessSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added MutableRangeReplaceableRandomAccessSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added MutableRangeReplaceableRandomAccessSlice.isEmpty
Added MutableRangeReplaceableRandomAccessSlice.joined() -> FlattenSequence<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.joined() -> FlattenCollection<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.joined() -> FlattenBidirectionalCollection<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.joined(separator: String) -> String
Added MutableRangeReplaceableRandomAccessSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.last
Added MutableRangeReplaceableRandomAccessSlice.lazy
Added MutableRangeReplaceableRandomAccessSlice.lazy
Added MutableRangeReplaceableRandomAccessSlice.lazy
Added MutableRangeReplaceableRandomAccessSlice.lazy
Added MutableRangeReplaceableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableRandomAccessSlice.makeIterator() -> IndexingIterator<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableRandomAccessSlice.max() -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.min() -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRangeReplaceableRandomAccessSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRangeReplaceableRandomAccessSlice.popFirst() -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.popLast() -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.prefix(_: Int) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.prefix(through: Base.Index) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.prefix(upTo: Base.Index) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableRangeReplaceableRandomAccessSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeAll(keepingCapacity: Bool)
Added MutableRangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeSubrange(_: Range<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.removeSubrange(_: ClosedRange<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.removeSubrange(_: CountableRange<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.removeSubrange(_: Range<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: Range<Base.Index>, with: C)
Added MutableRangeReplaceableRandomAccessSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: ClosedRange<Base.Index>, with: C)
Added MutableRangeReplaceableRandomAccessSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableClosedRange<Base.Index>, with: C)
Added MutableRangeReplaceableRandomAccessSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableRange<Base.Index>, with: C)
Added MutableRangeReplaceableRandomAccessSlice.reserveCapacity(_: Base.IndexDistance)
Added MutableRangeReplaceableRandomAccessSlice.reversed() -> ReversedRandomAccessCollection<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.sort()
Added MutableRangeReplaceableRandomAccessSlice.sort(by: (Base._Element, Base._Element) -> Bool)
Added MutableRangeReplaceableRandomAccessSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableRandomAccessSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableRandomAccessSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableRangeReplaceableRandomAccessSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableRangeReplaceableRandomAccessSlice<Base>]
Added MutableRangeReplaceableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableRangeReplaceableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRangeReplaceableRandomAccessSlice<Base>]
Added MutableRangeReplaceableRandomAccessSlice.startIndex
Added MutableRangeReplaceableRandomAccessSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added MutableRangeReplaceableRandomAccessSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: Base.Index) -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: Range<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.suffix(_: Int) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.suffix(from: Base.Index) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.underestimatedCount
Added MutableRangeReplaceableRandomAccessSlice.underestimatedCount
Added MutableRangeReplaceableSlice [struct]
Added MutableRangeReplaceableSlice.append(_: Base._Element)
Added MutableRangeReplaceableSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added MutableRangeReplaceableSlice.base
Added MutableRangeReplaceableSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableSlice.count
Added MutableRangeReplaceableSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added MutableRangeReplaceableSlice.dropFirst() -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.dropFirst(_: Int) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.dropLast() -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.dropLast(_: Int) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableSlice.endIndex
Added MutableRangeReplaceableSlice.enumerated() -> EnumeratedSequence<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added MutableRangeReplaceableSlice.first
Added MutableRangeReplaceableSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added MutableRangeReplaceableSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added MutableRangeReplaceableSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added MutableRangeReplaceableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added MutableRangeReplaceableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added MutableRangeReplaceableSlice.formIndex(after: Base.Index)
Added MutableRangeReplaceableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added MutableRangeReplaceableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added MutableRangeReplaceableSlice.index(after: Base.Index) -> Base.Index
Added MutableRangeReplaceableSlice.index(of: Base._Element) -> Base.Index?
Added MutableRangeReplaceableSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added MutableRangeReplaceableSlice.indices
Added MutableRangeReplaceableSlice.init()
Added MutableRangeReplaceableSlice.init<S : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableSlice.init<S where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableSlice.init(base: Base, bounds: Range<Base.Index>)
Added MutableRangeReplaceableSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added MutableRangeReplaceableSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added MutableRangeReplaceableSlice.isEmpty
Added MutableRangeReplaceableSlice.joined() -> FlattenSequence<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.joined() -> FlattenCollection<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.joined(separator: String) -> String
Added MutableRangeReplaceableSlice.lazy
Added MutableRangeReplaceableSlice.lazy
Added MutableRangeReplaceableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableSlice.makeIterator() -> IndexingIterator<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableSlice.max() -> Base._Element?
Added MutableRangeReplaceableSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableSlice.min() -> Base._Element?
Added MutableRangeReplaceableSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRangeReplaceableSlice.popFirst() -> Base._Element?
Added MutableRangeReplaceableSlice.prefix(_: Int) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.prefix(through: Base.Index) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.prefix(upTo: Base.Index) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableRangeReplaceableSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableSlice.removeAll(keepingCapacity: Bool)
Added MutableRangeReplaceableSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableSlice.removeFirst(_: Int)
Added MutableRangeReplaceableSlice.removeFirst(_: Int)
Added MutableRangeReplaceableSlice.removeFirst(_: Int)
Added MutableRangeReplaceableSlice.removeSubrange(_: Range<Base.Index>)
Added MutableRangeReplaceableSlice.removeSubrange(_: Range<Base.Index>)
Added MutableRangeReplaceableSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added MutableRangeReplaceableSlice.removeSubrange(_: CountableRange<Base.Index>)
Added MutableRangeReplaceableSlice.removeSubrange(_: ClosedRange<Base.Index>)
Added MutableRangeReplaceableSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: ClosedRange<Base.Index>, with: C)
Added MutableRangeReplaceableSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableClosedRange<Base.Index>, with: C)
Added MutableRangeReplaceableSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableRange<Base.Index>, with: C)
Added MutableRangeReplaceableSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: Range<Base.Index>, with: C)
Added MutableRangeReplaceableSlice.reserveCapacity(_: Base.IndexDistance)
Added MutableRangeReplaceableSlice.reversed() -> [Base._Element]
Added MutableRangeReplaceableSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableRangeReplaceableSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableRangeReplaceableSlice<Base>]
Added MutableRangeReplaceableSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableRangeReplaceableSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRangeReplaceableSlice<Base>]
Added MutableRangeReplaceableSlice.startIndex
Added MutableRangeReplaceableSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added MutableRangeReplaceableSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: Base.Index) -> Base._Element
Added MutableRangeReplaceableSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.subscript(_: Range<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.suffix(_: Int) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.suffix(from: Base.Index) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.underestimatedCount
Added MutableRangeReplaceableSlice.underestimatedCount
Added MutableSlice.base
Added MutableSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added MutableSlice.count
Added MutableSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added MutableSlice.dropFirst() -> MutableSlice<Base>
Added MutableSlice.dropFirst(_: Int) -> MutableSlice<Base>
Added MutableSlice.dropLast() -> MutableSlice<Base>
Added MutableSlice.dropLast(_: Int) -> MutableSlice<Base>
Added MutableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableSlice.enumerated() -> EnumeratedSequence<MutableSlice<Base>>
Added MutableSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added MutableSlice.first
Added MutableSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added MutableSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added MutableSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added MutableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added MutableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added MutableSlice.formIndex(after: Base.Index)
Added MutableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added MutableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added MutableSlice.index(after: Base.Index) -> Base.Index
Added MutableSlice.index(of: Base._Element) -> Base.Index?
Added MutableSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added MutableSlice.indices
Added MutableSlice.isEmpty
Added MutableSlice.joined() -> FlattenCollection<MutableSlice<Base>>
Added MutableSlice.joined() -> FlattenSequence<MutableSlice<Base>>
Added MutableSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableSlice<Base>>
Added MutableSlice.joined(separator: String) -> String
Added MutableSlice.lazy
Added MutableSlice.lazy
Added MutableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableSlice.makeIterator() -> IndexingIterator<MutableSlice<Base>>
Added MutableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableSlice.max() -> Base._Element?
Added MutableSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableSlice.min() -> Base._Element?
Added MutableSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableSlice.popFirst() -> Base._Element?
Added MutableSlice.prefix(_: Int) -> MutableSlice<Base>
Added MutableSlice.prefix(through: Base.Index) -> MutableSlice<Base>
Added MutableSlice.prefix(upTo: Base.Index) -> MutableSlice<Base>
Added MutableSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableSlice.removeFirst() -> Base._Element
Added MutableSlice.removeFirst(_: Int)
Added MutableSlice.reversed() -> [Base._Element]
Added MutableSlice.sorted() -> [Base._Element]
Added MutableSlice.sorted() -> [Base._Element]
Added MutableSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableSlice<Base>]
Added MutableSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableSlice<Base>]
Added MutableSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added MutableSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableSlice.subscript(_: ClosedRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.subscript(_: CountableRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableSlice<Base>>
Added MutableSlice.subscript(_: ClosedRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.subscript(_: CountableRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.suffix(_: Int) -> MutableSlice<Base>
Added MutableSlice.suffix(from: Base.Index) -> MutableSlice<Base>
Added MutableSlice.underestimatedCount
Added MutableSlice.underestimatedCount
Added OptionSet
Added RandomAccessCollection.indices
Added RandomAccessCollection.indices
Added RandomAccessCollection.lazy
Added RandomAccessCollection.reversed() -> ReversedRandomAccessCollection<Self>
Added RandomAccessCollection.subscript(_: Range<Self.Index>) -> RandomAccessSlice<Self>
Added RandomAccessIndexable
Added RandomAccessIndexable.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added RandomAccessSlice [struct]
Added RandomAccessSlice.base
Added RandomAccessSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added RandomAccessSlice.count
Added RandomAccessSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added RandomAccessSlice.dropFirst() -> RandomAccessSlice<Base>
Added RandomAccessSlice.dropFirst(_: Int) -> RandomAccessSlice<Base>
Added RandomAccessSlice.dropLast() -> RandomAccessSlice<Base>
Added RandomAccessSlice.dropLast(_: Int) -> RandomAccessSlice<Base>
Added RandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RandomAccessSlice.endIndex
Added RandomAccessSlice.enumerated() -> EnumeratedSequence<RandomAccessSlice<Base>>
Added RandomAccessSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added RandomAccessSlice.first
Added RandomAccessSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RandomAccessSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added RandomAccessSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added RandomAccessSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added RandomAccessSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added RandomAccessSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added RandomAccessSlice.formIndex(after: Base.Index)
Added RandomAccessSlice.formIndex(before: Base.Index)
Added RandomAccessSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added RandomAccessSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added RandomAccessSlice.index(after: Base.Index) -> Base.Index
Added RandomAccessSlice.index(before: Base.Index) -> Base.Index
Added RandomAccessSlice.index(of: Base._Element) -> Base.Index?
Added RandomAccessSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added RandomAccessSlice.indices
Added RandomAccessSlice.init(base: Base, bounds: Range<Base.Index>)
Added RandomAccessSlice.isEmpty
Added RandomAccessSlice.joined() -> FlattenCollection<RandomAccessSlice<Base>>
Added RandomAccessSlice.joined() -> FlattenSequence<RandomAccessSlice<Base>>
Added RandomAccessSlice.joined() -> FlattenBidirectionalCollection<RandomAccessSlice<Base>>
Added RandomAccessSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<RandomAccessSlice<Base>>
Added RandomAccessSlice.joined(separator: String) -> String
Added RandomAccessSlice.last
Added RandomAccessSlice.lazy
Added RandomAccessSlice.lazy
Added RandomAccessSlice.lazy
Added RandomAccessSlice.lazy
Added RandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RandomAccessSlice.makeIterator() -> IndexingIterator<RandomAccessSlice<Base>>
Added RandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RandomAccessSlice.max() -> Base._Element?
Added RandomAccessSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RandomAccessSlice.min() -> Base._Element?
Added RandomAccessSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RandomAccessSlice.popFirst() -> Base._Element?
Added RandomAccessSlice.popLast() -> Base._Element?
Added RandomAccessSlice.prefix(_: Int) -> RandomAccessSlice<Base>
Added RandomAccessSlice.prefix(through: Base.Index) -> RandomAccessSlice<Base>
Added RandomAccessSlice.prefix(upTo: Base.Index) -> RandomAccessSlice<Base>
Added RandomAccessSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added RandomAccessSlice.removeFirst() -> Base._Element
Added RandomAccessSlice.removeFirst(_: Int)
Added RandomAccessSlice.removeLast() -> Base._Element
Added RandomAccessSlice.removeLast(_: Int)
Added RandomAccessSlice.reversed() -> ReversedRandomAccessCollection<RandomAccessSlice<Base>>
Added RandomAccessSlice.sorted() -> [Base._Element]
Added RandomAccessSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added RandomAccessSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [RandomAccessSlice<Base>]
Added RandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added RandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<Base>]
Added RandomAccessSlice.startIndex
Added RandomAccessSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added RandomAccessSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RandomAccessSlice.subscript(_: Range<Base.Index>) -> RandomAccessSlice<RandomAccessSlice<Base>>
Added RandomAccessSlice.subscript(_: CountableRange<Base.Index>) -> RandomAccessSlice<Base>
Added RandomAccessSlice.subscript(_: Base.Index) -> Base._Element
Added RandomAccessSlice.subscript(_: Range<Base.Index>) -> RandomAccessSlice<Base>
Added RandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> RandomAccessSlice<Base>
Added RandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> RandomAccessSlice<Base>
Added RandomAccessSlice.suffix(_: Int) -> RandomAccessSlice<Base>
Added RandomAccessSlice.suffix(from: Base.Index) -> RandomAccessSlice<Base>
Added RandomAccessSlice.underestimatedCount
Added RandomAccessSlice.underestimatedCount
Added RangeReplaceableBidirectionalSlice [struct]
Added RangeReplaceableBidirectionalSlice.append(_: Base._Element)
Added RangeReplaceableBidirectionalSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added RangeReplaceableBidirectionalSlice.base
Added RangeReplaceableBidirectionalSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableBidirectionalSlice.count
Added RangeReplaceableBidirectionalSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added RangeReplaceableBidirectionalSlice.dropFirst() -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.dropFirst(_: Int) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.dropLast() -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.dropLast(_: Int) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableBidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableBidirectionalSlice.endIndex
Added RangeReplaceableBidirectionalSlice.enumerated() -> EnumeratedSequence<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added RangeReplaceableBidirectionalSlice.first
Added RangeReplaceableBidirectionalSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableBidirectionalSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added RangeReplaceableBidirectionalSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added RangeReplaceableBidirectionalSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added RangeReplaceableBidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added RangeReplaceableBidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added RangeReplaceableBidirectionalSlice.formIndex(after: Base.Index)
Added RangeReplaceableBidirectionalSlice.formIndex(before: Base.Index)
Added RangeReplaceableBidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added RangeReplaceableBidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added RangeReplaceableBidirectionalSlice.index(after: Base.Index) -> Base.Index
Added RangeReplaceableBidirectionalSlice.index(before: Base.Index) -> Base.Index
Added RangeReplaceableBidirectionalSlice.index(of: Base._Element) -> Base.Index?
Added RangeReplaceableBidirectionalSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added RangeReplaceableBidirectionalSlice.indices
Added RangeReplaceableBidirectionalSlice.init()
Added RangeReplaceableBidirectionalSlice.init<S where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added RangeReplaceableBidirectionalSlice.init<S : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added RangeReplaceableBidirectionalSlice.init(base: Base, bounds: Range<Base.Index>)
Added RangeReplaceableBidirectionalSlice.init(repeating: Base._Element, count: Int)
Added RangeReplaceableBidirectionalSlice.init(repeating: Base._Element, count: Int)
Added RangeReplaceableBidirectionalSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableBidirectionalSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableBidirectionalSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added RangeReplaceableBidirectionalSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added RangeReplaceableBidirectionalSlice.isEmpty
Added RangeReplaceableBidirectionalSlice.joined() -> FlattenCollection<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.joined() -> FlattenSequence<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.joined() -> FlattenBidirectionalCollection<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.joined(separator: String) -> String
Added RangeReplaceableBidirectionalSlice.last
Added RangeReplaceableBidirectionalSlice.lazy
Added RangeReplaceableBidirectionalSlice.lazy
Added RangeReplaceableBidirectionalSlice.lazy
Added RangeReplaceableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableBidirectionalSlice.makeIterator() -> IndexingIterator<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableBidirectionalSlice.max() -> Base._Element?
Added RangeReplaceableBidirectionalSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableBidirectionalSlice.min() -> Base._Element?
Added RangeReplaceableBidirectionalSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableBidirectionalSlice.popFirst() -> Base._Element?
Added RangeReplaceableBidirectionalSlice.popLast() -> Base._Element?
Added RangeReplaceableBidirectionalSlice.prefix(_: Int) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.prefix(through: Base.Index) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.prefix(upTo: Base.Index) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added RangeReplaceableBidirectionalSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableBidirectionalSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeAll(keepingCapacity: Bool)
Added RangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added RangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added RangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added RangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added RangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added RangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added RangeReplaceableBidirectionalSlice.removeSubrange(_: Range<Base.Index>)
Added RangeReplaceableBidirectionalSlice.removeSubrange(_: ClosedRange<Base.Index>)
Added RangeReplaceableBidirectionalSlice.removeSubrange(_: Range<Base.Index>)
Added RangeReplaceableBidirectionalSlice.removeSubrange(_: CountableRange<Base.Index>)
Added RangeReplaceableBidirectionalSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added RangeReplaceableBidirectionalSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableRange<Base.Index>, with: C)
Added RangeReplaceableBidirectionalSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableClosedRange<Base.Index>, with: C)
Added RangeReplaceableBidirectionalSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: Range<Base.Index>, with: C)
Added RangeReplaceableBidirectionalSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: ClosedRange<Base.Index>, with: C)
Added RangeReplaceableBidirectionalSlice.reserveCapacity(_: Base.IndexDistance)
Added RangeReplaceableBidirectionalSlice.reversed() -> ReversedCollection<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.sorted() -> [Base._Element]
Added RangeReplaceableBidirectionalSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added RangeReplaceableBidirectionalSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [RangeReplaceableBidirectionalSlice<Base>]
Added RangeReplaceableBidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RangeReplaceableBidirectionalSlice<Base>]
Added RangeReplaceableBidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added RangeReplaceableBidirectionalSlice.startIndex
Added RangeReplaceableBidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added RangeReplaceableBidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableBidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.subscript(_: Base.Index) -> Base._Element
Added RangeReplaceableBidirectionalSlice.subscript(_: Range<Base.Index>) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.suffix(_: Int) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.suffix(from: Base.Index) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.underestimatedCount
Added RangeReplaceableBidirectionalSlice.underestimatedCount
Added RangeReplaceableCollection.append(_: Self.Iterator.Element)
Added RangeReplaceableCollection.append(_: Self.Iterator.Element)
Added RangeReplaceableCollection.append<S : Sequence where S.Iterator.Element == Iterator.Element>(contentsOf: S)
Added RangeReplaceableCollection.append<S : Sequence where S.Iterator.Element == Iterator.Element>(contentsOf: S)
Added RangeReplaceableCollection.init<S : Sequence where S.Iterator.Element == Iterator.Element>(_: S)
Added RangeReplaceableCollection.init<S : Sequence where S.Iterator.Element == Iterator.Element>(_: S)
Added RangeReplaceableCollection.init(repeating: Self.Iterator.Element, count: Int)
Added RangeReplaceableCollection.init(repeating: Self.Iterator.Element, count: Int)
Added RangeReplaceableCollection.insert(_: Self.Iterator.Element, at: Self.Index)
Added RangeReplaceableCollection.insert(_: Self.Iterator.Element, at: Self.Index)
Added RangeReplaceableCollection.insert<C : Collection where C.Iterator.Element == Iterator.Element>(contentsOf: C, at: Self.Index)
Added RangeReplaceableCollection.insert<S : Collection where S.Iterator.Element == Iterator.Element>(contentsOf: S, at: Self.Index)
Added RangeReplaceableCollection.remove(at: Self.Index) -> Self.Iterator.Element
Added RangeReplaceableCollection.remove(at: Self.Index) -> Self.Iterator.Element
Added RangeReplaceableCollection.removeAll(keepingCapacity: Bool)
Added RangeReplaceableCollection.removeAll(keepingCapacity: Bool)
Added RangeReplaceableCollection.removeFirst() -> Self.Iterator.Element
Added RangeReplaceableCollection.removeFirst() -> Self.Iterator.Element
Added RangeReplaceableCollection.removeFirst() -> Self.Iterator.Element
Added RangeReplaceableCollection.removeFirst(_: Int)
Added RangeReplaceableCollection.removeFirst(_: Int)
Added RangeReplaceableCollection.removeFirst(_: Int)
Added RangeReplaceableCollection.removeSubrange(_: ClosedRange<Self.Index>)
Added RangeReplaceableCollection.removeSubrange(_: Range<Self.Index>)
Added RangeReplaceableCollection.removeSubrange(_: CountableRange<Self.Index>)
Added RangeReplaceableCollection.removeSubrange(_: CountableClosedRange<Self.Index>)
Added RangeReplaceableCollection.replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_: ClosedRange<Self.Index>, with: C)
Added RangeReplaceableCollection.replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_: CountableClosedRange<Self.Index>, with: C)
Added RangeReplaceableCollection.replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_: Range<Self.Index>, with: C)
Added RangeReplaceableCollection.replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_: CountableRange<Self.Index>, with: C)
Added RangeReplaceableCollection.reserveCapacity(_: Self.IndexDistance)
Added RangeReplaceableCollection.reserveCapacity(_: Self.IndexDistance)
Added RangeReplaceableIndexable
Added RangeReplaceableIndexable.init()
Added RangeReplaceableIndexable.init<S : Sequence where S.Iterator.Element == _Element>(_: S)
Added RangeReplaceableIndexable.init(repeating: Self._Element, count: Int)
Added RangeReplaceableIndexable.insert(_: Self._Element, at: Self.Index)
Added RangeReplaceableIndexable.insert<S : Collection where S.Iterator.Element == _Element>(contentsOf: S, at: Self.Index)
Added RangeReplaceableIndexable.remove(at: Self.Index) -> Self._Element
Added RangeReplaceableIndexable.removeSubrange(_: Range<Self.Index>)
Added RangeReplaceableIndexable.replaceSubrange<C where C : Collection, C.Iterator.Element == _Element>(_: Range<Self.Index>, with: C)
Added RangeReplaceableRandomAccessSlice [struct]
Added RangeReplaceableRandomAccessSlice.append(_: Base._Element)
Added RangeReplaceableRandomAccessSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added RangeReplaceableRandomAccessSlice.base
Added RangeReplaceableRandomAccessSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableRandomAccessSlice.count
Added RangeReplaceableRandomAccessSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added RangeReplaceableRandomAccessSlice.dropFirst() -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.dropFirst(_: Int) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.dropLast() -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.dropLast(_: Int) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableRandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableRandomAccessSlice.endIndex
Added RangeReplaceableRandomAccessSlice.enumerated() -> EnumeratedSequence<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added RangeReplaceableRandomAccessSlice.first
Added RangeReplaceableRandomAccessSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableRandomAccessSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added RangeReplaceableRandomAccessSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added RangeReplaceableRandomAccessSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added RangeReplaceableRandomAccessSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added RangeReplaceableRandomAccessSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added RangeReplaceableRandomAccessSlice.formIndex(after: Base.Index)
Added RangeReplaceableRandomAccessSlice.formIndex(before: Base.Index)
Added RangeReplaceableRandomAccessSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added RangeReplaceableRandomAccessSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added RangeReplaceableRandomAccessSlice.index(after: Base.Index) -> Base.Index
Added RangeReplaceableRandomAccessSlice.index(before: Base.Index) -> Base.Index
Added RangeReplaceableRandomAccessSlice.index(of: Base._Element) -> Base.Index?
Added RangeReplaceableRandomAccessSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added RangeReplaceableRandomAccessSlice.indices
Added RangeReplaceableRandomAccessSlice.init()
Added RangeReplaceableRandomAccessSlice.init<S : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added RangeReplaceableRandomAccessSlice.init<S where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added RangeReplaceableRandomAccessSlice.init(base: Base, bounds: Range<Base.Index>)
Added RangeReplaceableRandomAccessSlice.init(repeating: Base._Element, count: Int)
Added RangeReplaceableRandomAccessSlice.init(repeating: Base._Element, count: Int)
Added RangeReplaceableRandomAccessSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableRandomAccessSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableRandomAccessSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added RangeReplaceableRandomAccessSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added RangeReplaceableRandomAccessSlice.isEmpty
Added RangeReplaceableRandomAccessSlice.joined() -> FlattenCollection<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.joined() -> FlattenBidirectionalCollection<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.joined() -> FlattenSequence<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.joined(separator: String) -> String
Added RangeReplaceableRandomAccessSlice.last
Added RangeReplaceableRandomAccessSlice.lazy
Added RangeReplaceableRandomAccessSlice.lazy
Added RangeReplaceableRandomAccessSlice.lazy
Added RangeReplaceableRandomAccessSlice.lazy
Added RangeReplaceableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableRandomAccessSlice.makeIterator() -> IndexingIterator<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableRandomAccessSlice.max() -> Base._Element?
Added RangeReplaceableRandomAccessSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableRandomAccessSlice.min() -> Base._Element?
Added RangeReplaceableRandomAccessSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableRandomAccessSlice.popFirst() -> Base._Element?
Added RangeReplaceableRandomAccessSlice.popLast() -> Base._Element?
Added RangeReplaceableRandomAccessSlice.prefix(_: Int) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.prefix(through: Base.Index) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.prefix(upTo: Base.Index) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added RangeReplaceableRandomAccessSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableRandomAccessSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeAll(keepingCapacity: Bool)
Added RangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added RangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added RangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added RangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added RangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added RangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added RangeReplaceableRandomAccessSlice.removeSubrange(_: Range<Base.Index>)
Added RangeReplaceableRandomAccessSlice.removeSubrange(_: Range<Base.Index>)
Added RangeReplaceableRandomAccessSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added RangeReplaceableRandomAccessSlice.removeSubrange(_: CountableRange<Base.Index>)
Added RangeReplaceableRandomAccessSlice.removeSubrange(_: ClosedRange<Base.Index>)
Added RangeReplaceableRandomAccessSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: ClosedRange<Base.Index>, with: C)
Added RangeReplaceableRandomAccessSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableClosedRange<Base.Index>, with: C)
Added RangeReplaceableRandomAccessSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: Range<Base.Index>, with: C)
Added RangeReplaceableRandomAccessSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableRange<Base.Index>, with: C)
Added RangeReplaceableRandomAccessSlice.reserveCapacity(_: Base.IndexDistance)
Added RangeReplaceableRandomAccessSlice.reversed() -> ReversedRandomAccessCollection<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.sorted() -> [Base._Element]
Added RangeReplaceableRandomAccessSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added RangeReplaceableRandomAccessSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [RangeReplaceableRandomAccessSlice<Base>]
Added RangeReplaceableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added RangeReplaceableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RangeReplaceableRandomAccessSlice<Base>]
Added RangeReplaceableRandomAccessSlice.startIndex
Added RangeReplaceableRandomAccessSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added RangeReplaceableRandomAccessSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableRandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.subscript(_: CountableRange<Base.Index>) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.subscript(_: Range<Base.Index>) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.subscript(_: Base.Index) -> Base._Element
Added RangeReplaceableRandomAccessSlice.suffix(_: Int) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.suffix(from: Base.Index) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.underestimatedCount
Added RangeReplaceableRandomAccessSlice.underestimatedCount
Added RangeReplaceableSlice [struct]
Added RangeReplaceableSlice.append(_: Base._Element)
Added RangeReplaceableSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added RangeReplaceableSlice.base
Added RangeReplaceableSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableSlice.count
Added RangeReplaceableSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added RangeReplaceableSlice.dropFirst() -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.dropFirst(_: Int) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.dropLast() -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.dropLast(_: Int) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableSlice.endIndex
Added RangeReplaceableSlice.enumerated() -> EnumeratedSequence<RangeReplaceableSlice<Base>>
Added RangeReplaceableSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added RangeReplaceableSlice.first
Added RangeReplaceableSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added RangeReplaceableSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added RangeReplaceableSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added RangeReplaceableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added RangeReplaceableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added RangeReplaceableSlice.formIndex(after: Base.Index)
Added RangeReplaceableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added RangeReplaceableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added RangeReplaceableSlice.index(after: Base.Index) -> Base.Index
Added RangeReplaceableSlice.index(of: Base._Element) -> Base.Index?
Added RangeReplaceableSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added RangeReplaceableSlice.indices
Added RangeReplaceableSlice.init()
Added RangeReplaceableSlice.init<S where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added RangeReplaceableSlice.init<S : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added RangeReplaceableSlice.init(base: Base, bounds: Range<Base.Index>)
Added RangeReplaceableSlice.init(repeating: Base._Element, count: Int)
Added RangeReplaceableSlice.init(repeating: Base._Element, count: Int)
Added RangeReplaceableSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added RangeReplaceableSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added RangeReplaceableSlice.isEmpty
Added RangeReplaceableSlice.joined() -> FlattenCollection<RangeReplaceableSlice<Base>>
Added RangeReplaceableSlice.joined() -> FlattenSequence<RangeReplaceableSlice<Base>>
Added RangeReplaceableSlice.joined(separator: String) -> String
Added RangeReplaceableSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<RangeReplaceableSlice<Base>>
Added RangeReplaceableSlice.lazy
Added RangeReplaceableSlice.lazy
Added RangeReplaceableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableSlice.makeIterator() -> IndexingIterator<RangeReplaceableSlice<Base>>
Added RangeReplaceableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableSlice.max() -> Base._Element?
Added RangeReplaceableSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableSlice.min() -> Base._Element?
Added RangeReplaceableSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableSlice.popFirst() -> Base._Element?
Added RangeReplaceableSlice.prefix(_: Int) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.prefix(through: Base.Index) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.prefix(upTo: Base.Index) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added RangeReplaceableSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableSlice.removeAll(keepingCapacity: Bool)
Added RangeReplaceableSlice.removeFirst() -> Base._Element
Added RangeReplaceableSlice.removeFirst() -> Base._Element
Added RangeReplaceableSlice.removeFirst() -> Base._Element
Added RangeReplaceableSlice.removeFirst(_: Int)
Added RangeReplaceableSlice.removeFirst(_: Int)
Added RangeReplaceableSlice.removeFirst(_: Int)
Added RangeReplaceableSlice.removeSubrange(_: CountableRange<Base.Index>)
Added RangeReplaceableSlice.removeSubrange(_: Range<Base.Index>)
Added RangeReplaceableSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added RangeReplaceableSlice.removeSubrange(_: ClosedRange<Base.Index>)
Added RangeReplaceableSlice.removeSubrange(_: Range<Base.Index>)
Added RangeReplaceableSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: ClosedRange<Base.Index>, with: C)
Added RangeReplaceableSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableRange<Base.Index>, with: C)
Added RangeReplaceableSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableClosedRange<Base.Index>, with: C)
Added RangeReplaceableSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: Range<Base.Index>, with: C)
Added RangeReplaceableSlice.reserveCapacity(_: Base.IndexDistance)
Added RangeReplaceableSlice.reversed() -> [Base._Element]
Added RangeReplaceableSlice.sorted() -> [Base._Element]
Added RangeReplaceableSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added RangeReplaceableSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [RangeReplaceableSlice<Base>]
Added RangeReplaceableSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RangeReplaceableSlice<Base>]
Added RangeReplaceableSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added RangeReplaceableSlice.startIndex
Added RangeReplaceableSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added RangeReplaceableSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableSlice.subscript(_: Range<Base.Index>) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.subscript(_: CountableRange<Base.Index>) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.subscript(_: CountableClosedRange<Base.Index>) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.subscript(_: Base.Index) -> Base._Element
Added RangeReplaceableSlice.subscript(_: ClosedRange<Base.Index>) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.suffix(_: Int) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.suffix(from: Base.Index) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.underestimatedCount
Added RangeReplaceableSlice.underestimatedCount
Added Repeated.distance(from: Int, to: Int) -> Int
Added Repeated.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Repeated.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Repeated.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Repeated.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Repeated.formIndex(_: Int, offsetBy: Int)
Added Repeated.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Repeated.formIndex(after: Int)
Added Repeated.formIndex(before: Int)
Added Repeated.index(_: Int, offsetBy: Int) -> Int
Added Repeated.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added Repeated.index(after: Int) -> Int
Added Repeated.index(before: Int) -> Int
Added Repeated.index(of: Element) -> Int?
Added Repeated.index(where: (Element) throws -> Bool) rethrows -> Int?
Added Repeated.indices
Added Repeated.joined() -> FlattenSequence<Repeated<Element>>
Added Repeated.joined() -> FlattenBidirectionalCollection<Repeated<Element>>
Added Repeated.joined() -> FlattenCollection<Repeated<Element>>
Added Repeated.joined(separator: String) -> String
Added Repeated.lazy
Added Repeated.lazy
Added Repeated.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Repeated.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Repeated.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Repeated.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Repeated.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added Repeated.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<Repeated<Element>>]
Added Repeated.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added Repeated.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Repeated.subscript(_: Range<Int>) -> RandomAccessSlice<Repeated<Element>>
Added Repeated.subscript(_: CountableRange<Int>) -> RandomAccessSlice<Repeated<Element>>
Added Repeated.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<Repeated<Element>>
Added Repeated.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Repeated<Element>>
Added Repeated.underestimatedCount
Added Repeated.underestimatedCount
Added ReversedCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedCollection.count
Added ReversedCollection.distance(from: ReversedIndex<Base>, to: ReversedIndex<Base>) -> Base.IndexDistance
Added ReversedCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added ReversedCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedCollection.endIndex
Added ReversedCollection.filter(_: (Base.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element]
Added ReversedCollection.first
Added ReversedCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ReversedCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ReversedCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added ReversedCollection.formIndex(_: ReversedIndex<Base>, offsetBy: Base.IndexDistance)
Added ReversedCollection.formIndex(_: ReversedIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: ReversedIndex<Base>) -> Bool
Added ReversedCollection.formIndex(after: ReversedIndex<Base>)
Added ReversedCollection.formIndex(before: ReversedIndex<Base>)
Added ReversedCollection.index(_: ReversedIndex<Base>, offsetBy: Base.IndexDistance) -> ReversedIndex<Base>
Added ReversedCollection.index(_: ReversedIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: ReversedIndex<Base>) -> ReversedIndex<Base>?
Added ReversedCollection.index(after: ReversedIndex<Base>) -> ReversedIndex<Base>
Added ReversedCollection.index(before: ReversedIndex<Base>) -> ReversedIndex<Base>
Added ReversedCollection.index(of: Base.Iterator.Element) -> ReversedIndex<Base>?
Added ReversedCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> ReversedIndex<Base>?
Added ReversedCollection.indices
Added ReversedCollection.joined() -> FlattenBidirectionalCollection<ReversedCollection<Base>>
Added ReversedCollection.joined() -> FlattenSequence<ReversedCollection<Base>>
Added ReversedCollection.joined() -> FlattenCollection<ReversedCollection<Base>>
Added ReversedCollection.joined(separator: String) -> String
Added ReversedCollection.last
Added ReversedCollection.lazy
Added ReversedCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added ReversedCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added ReversedCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added ReversedCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedCollection.prefix(through: ReversedIndex<Base>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.prefix(upTo: ReversedIndex<Base>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added ReversedCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added ReversedCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<ReversedCollection<Base>>]
Added ReversedCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<ReversedCollection<Base>>]
Added ReversedCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added ReversedCollection.startIndex
Added ReversedCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added ReversedCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedCollection.subscript(_: Range<ReversedIndex<Base>>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.subscript(_: ClosedRange<ReversedIndex<Base>>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.subscript(_: Range<ReversedIndex<Base>>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.subscript(_: ReversedIndex<Base>) -> Base.Iterator.Element
Added ReversedCollection.suffix(from: ReversedIndex<Base>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.underestimatedCount
Added ReversedCollection.underestimatedCount
Added ReversedIndex [struct]
Added ReversedIndex.base
Added ReversedIndex.init(_: Base.Index)
Added ReversedRandomAccessCollection [struct]
Added ReversedRandomAccessCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedRandomAccessCollection.count
Added ReversedRandomAccessCollection.distance(from: ReversedRandomAccessIndex<Base>, to: ReversedRandomAccessIndex<Base>) -> Base.IndexDistance
Added ReversedRandomAccessCollection.dropFirst() -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.dropFirst(_: Int) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.dropLast() -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.dropLast(_: Int) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added ReversedRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedRandomAccessCollection.endIndex
Added ReversedRandomAccessCollection.enumerated() -> EnumeratedSequence<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.filter(_: (Base.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element]
Added ReversedRandomAccessCollection.first
Added ReversedRandomAccessCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ReversedRandomAccessCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ReversedRandomAccessCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added ReversedRandomAccessCollection.formIndex(_: ReversedRandomAccessIndex<Base>, offsetBy: Base.IndexDistance)
Added ReversedRandomAccessCollection.formIndex(_: ReversedRandomAccessIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: ReversedRandomAccessIndex<Base>) -> Bool
Added ReversedRandomAccessCollection.formIndex(after: ReversedRandomAccessIndex<Base>)
Added ReversedRandomAccessCollection.formIndex(before: ReversedRandomAccessIndex<Base>)
Added ReversedRandomAccessCollection.index(_: ReversedRandomAccessIndex<Base>, offsetBy: Base.IndexDistance) -> ReversedRandomAccessIndex<Base>
Added ReversedRandomAccessCollection.index(_: ReversedRandomAccessIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: ReversedRandomAccessIndex<Base>) -> ReversedRandomAccessIndex<Base>?
Added ReversedRandomAccessCollection.index(after: ReversedRandomAccessIndex<Base>) -> ReversedRandomAccessIndex<Base>
Added ReversedRandomAccessCollection.index(before: ReversedRandomAccessIndex<Base>) -> ReversedRandomAccessIndex<Base>
Added ReversedRandomAccessCollection.index(of: Base.Iterator.Element) -> ReversedRandomAccessIndex<Base>?
Added ReversedRandomAccessCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> ReversedRandomAccessIndex<Base>?
Added ReversedRandomAccessCollection.indices
Added ReversedRandomAccessCollection.isEmpty
Added ReversedRandomAccessCollection.joined() -> FlattenSequence<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.joined() -> FlattenCollection<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.joined() -> FlattenBidirectionalCollection<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.joined(separator: String) -> String
Added ReversedRandomAccessCollection.last
Added ReversedRandomAccessCollection.lazy
Added ReversedRandomAccessCollection.lazy
Added ReversedRandomAccessCollection.lazy
Added ReversedRandomAccessCollection.lazy
Added ReversedRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added ReversedRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedRandomAccessCollection.makeIterator() -> IndexingIterator<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added ReversedRandomAccessCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added ReversedRandomAccessCollection.max() -> Base.Iterator.Element?
Added ReversedRandomAccessCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedRandomAccessCollection.min() -> Base.Iterator.Element?
Added ReversedRandomAccessCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedRandomAccessCollection.prefix(_: Int) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.prefix(through: ReversedRandomAccessIndex<Base>) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.prefix(upTo: ReversedRandomAccessIndex<Base>) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added ReversedRandomAccessCollection.reversed() -> ReversedRandomAccessCollection<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.sorted() -> [Base.Iterator.Element]
Added ReversedRandomAccessCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added ReversedRandomAccessCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [RandomAccessSlice<ReversedRandomAccessCollection<Base>>]
Added ReversedRandomAccessCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<ReversedRandomAccessCollection<Base>>]
Added ReversedRandomAccessCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added ReversedRandomAccessCollection.startIndex
Added ReversedRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added ReversedRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedRandomAccessCollection.subscript(_: ReversedRandomAccessIndex<Base>) -> Base.Iterator.Element
Added ReversedRandomAccessCollection.subscript(_: ClosedRange<ReversedRandomAccessIndex<Base>>) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.subscript(_: Range<ReversedRandomAccessIndex<Base>>) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.suffix(_: Int) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.suffix(from: ReversedRandomAccessIndex<Base>) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.underestimatedCount
Added ReversedRandomAccessCollection.underestimatedCount
Added ReversedRandomAccessIndex [struct]
Added ReversedRandomAccessIndex.base
Added ReversedRandomAccessIndex.init(_: Base.Index)
Added Sequence
Added Sequence.contains(_: Self.Iterator.Element) -> Bool
Added Sequence.contains(where: (Self.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Sequence.dropFirst(_: Int) -> Self.SubSequence
Added Sequence.dropFirst(_: Int) -> AnySequence<Self.Iterator.Element>
Added Sequence.dropLast(_: Int) -> AnySequence<Self.Iterator.Element>
Added Sequence.dropLast(_: Int) -> Self.SubSequence
Added Sequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_: OtherSequence) -> Bool
Added Sequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_: OtherSequence, by: (Self.Iterator.Element, Self.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Sequence.filter(_: (Self.Iterator.Element) throws -> Bool) rethrows -> [Self.Iterator.Element]
Added Sequence.filter(_: (Self.Iterator.Element) throws -> Bool) rethrows -> [Self.Iterator.Element]
Added Sequence.first(where: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Iterator.Element?
Added Sequence.first(where: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Iterator.Element?
Added Sequence.flatMap<ElementOfResult>(_: (Self.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Sequence.flatMap<SegmentOfResult : Sequence>(_: (Self.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Sequence.forEach(_: (Self.Iterator.Element) throws -> Swift.Void) rethrows
Added Sequence.forEach(_: (Self.Iterator.Element) throws -> Swift.Void) rethrows
Added Sequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_: OtherSequence) -> Bool
Added Sequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_: OtherSequence, by: (Self.Iterator.Element, Self.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Sequence.makeIterator() -> Self.Iterator
Added Sequence.map<T>(_: (Self.Iterator.Element) throws -> T) rethrows -> [T]
Added Sequence.map<T>(_: (Self.Iterator.Element) throws -> T) rethrows -> [T]
Added Sequence.max(by: (Self.Iterator.Element, Self.Iterator.Element) throws -> Bool) rethrows -> Self.Iterator.Element?
Added Sequence.min(by: (Self.Iterator.Element, Self.Iterator.Element) throws -> Bool) rethrows -> Self.Iterator.Element?
Added Sequence.prefix(_: Int) -> Self.SubSequence
Added Sequence.prefix(_: Int) -> AnySequence<Self.Iterator.Element>
Added Sequence.reduce<Result>(_: Result, _: (Result, Self.Iterator.Element) throws -> Result) rethrows -> Result
Added Sequence.sorted(by: (Self.Iterator.Element, Self.Iterator.Element) -> Bool) -> [Self.Iterator.Element]
Added Sequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Self.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Self.Iterator.Element>]
Added Sequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Self.Iterator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Added Sequence.split(separator: Self.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Self.Iterator.Element>]
Added Sequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(with: PossiblePrefix) -> Bool
Added Sequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(with: PossiblePrefix, by: (Self.Iterator.Element, Self.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Sequence.suffix(_: Int) -> Self.SubSequence
Added Sequence.suffix(_: Int) -> AnySequence<Self.Iterator.Element>
Added Sequence.underestimatedCount
Added Sequence.underestimatedCount
Added Set.count
Added Set.distance(from: SetIndex<Element>, to: SetIndex<Element>) -> Int
Added Set.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Set.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Set.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added Set.first
Added Set.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Set.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Set.formIndex(_: SetIndex<Element>, offsetBy: Int)
Added Set.formIndex(_: SetIndex<Element>, offsetBy: Int, limitedBy: SetIndex<Element>) -> Bool
Added Set.formIndex(after: SetIndex<Element>)
Added Set.formIntersection<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Set.formSymmetricDifference<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Set.formUnion<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Set.index(_: SetIndex<Element>, offsetBy: Int) -> SetIndex<Element>
Added Set.index(_: SetIndex<Element>, offsetBy: Int, limitedBy: SetIndex<Element>) -> SetIndex<Element>?
Added Set.index(after: SetIndex<Element>) -> SetIndex<Element>
Added Set.index(of: Element) -> SetIndex<Element>?
Added Set.index(where: (Element) throws -> Bool) rethrows -> SetIndex<Element>?
Added Set.indices
Added Set.init<Source : Sequence where Source.Iterator.Element == Element>(_: Source)
Added Set.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Set.init(arrayLiteral: Element)
Added Set.insert<ConcreteElement : Hashable>(_: ConcreteElement) -> (inserted: Bool, memberAfterInsert: ConcreteElement)
Added Set.intersection<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>
Added Set.isDisjoint<S : Sequence where S.Iterator.Element == Element>(with: S) -> Bool
Added Set.isEmpty
Added Set.isEmpty
Added Set.isStrictSubset<S : Sequence where S.Iterator.Element == Element>(of: S) -> Bool
Added Set.isStrictSuperset<S : Sequence where S.Iterator.Element == Element>(of: S) -> Bool
Added Set.isSubset<S : Sequence where S.Iterator.Element == Element>(of: S) -> Bool
Added Set.isSuperset<S : Sequence where S.Iterator.Element == Element>(of: S) -> Bool
Added Set.joined() -> FlattenCollection<Set<Element>>
Added Set.joined() -> FlattenSequence<Set<Element>>
Added Set.lazy
Added Set.lazy
Added Set.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Set.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Set.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Set.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Set.remove<ConcreteElement : Hashable>(_: ConcreteElement) -> ConcreteElement?
Added Set.remove(at: SetIndex<Element>) -> Element
Added Set.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added Set.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Set.subscript(_: ClosedRange<SetIndex<Element>>) -> Slice<Set<Element>>
Added Set.subscript(_: Range<SetIndex<Element>>) -> Slice<Set<Element>>
Added Set.subtract<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Set.subtracting<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>
Added Set.symmetricDifference<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>
Added Set.underestimatedCount
Added Set.underestimatedCount
Added Set.union<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>
Added Set.update<ConcreteElement : Hashable>(with: ConcreteElement) -> ConcreteElement?
Added SetAlgebra.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added SetAlgebra.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added SetAlgebra.isDisjoint(with: Self) -> Bool
Added SetAlgebra.isDisjoint(with: Self) -> Bool
Added SetAlgebra.isEmpty
Added SetAlgebra.isEmpty
Added SetAlgebra.isSubset(of: Self) -> Bool
Added SetAlgebra.isSubset(of: Self) -> Bool
Added SetAlgebra.isSuperset(of: Self) -> Bool
Added SetAlgebra.isSuperset(of: Self) -> Bool
Added SetAlgebra.subtract(_: Self)
Added SetAlgebra.subtract(_: Self)
Added SetAlgebra.subtracting(_: Self) -> Self
Added SetAlgebra.subtracting(_: Self) -> Self
Added SignedInteger.advanced(by: Int) -> Self
Added SignedInteger.distance(to: Self) -> Int
Added SignedInteger.init(_: IntMax)
Added SignedInteger.toIntMax() -> IntMax
Added SignedNumber
Added SignedNumber.-(_: Self) -> Self
Added SignedNumber.-(_: Self, _: Self) -> Self
Added Slice.count
Added Slice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added Slice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added Slice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Slice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Slice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added Slice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added Slice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added Slice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added Slice.index(of: Base._Element) -> Base.Index?
Added Slice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added Slice.indices
Added Slice.joined() -> FlattenSequence<Slice<Base>>
Added Slice.joined() -> FlattenCollection<Slice<Base>>
Added Slice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added Slice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added Slice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added Slice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added Slice.removeFirst(_: Int)
Added Slice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added Slice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<Base>]
Added Slice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added Slice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added Slice.subscript(_: Range<Base.Index>) -> Slice<Slice<Base>>
Added Slice.subscript(_: CountableRange<Base.Index>) -> Slice<Base>
Added Slice.subscript(_: ClosedRange<Base.Index>) -> Slice<Base>
Added Slice.subscript(_: CountableClosedRange<Base.Index>) -> Slice<Base>
Added Slice.underestimatedCount
Added Slice.underestimatedCount
Added StrideThrough.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added StrideThrough.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added StrideThrough.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added StrideThrough.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added StrideThrough.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added StrideThrough.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added StrideThrough.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added StrideThrough.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added StrideTo.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added StrideTo.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added StrideTo.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added StrideTo.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added StrideTo.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added StrideTo.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added StrideTo.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added StrideTo.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added String.init<T : UnsignedInteger>(_: T)
Added String.init<T : _SignedInteger>(_: T)
Added String.init(_: String)
Added String.init<T : UnsignedInteger>(_: T, radix: Int, uppercase: Bool)
Added String.init<T : _SignedInteger>(_: T, radix: Int, uppercase: Bool)
Added String.insert(_: Character, at: String.Index)
Added String.remove(at: String.Index) -> Character
Added String.removeSubrange(_: ClosedRange<String.Index>)
Added String.removeSubrange(_: Range<String.Index>)
Added String.replaceSubrange(_: Range<String.Index>, with: String)
Added String.replaceSubrange(_: ClosedRange<String.Index>, with: String)
Added String.replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_: ClosedRange<String.Index>, with: C)
Added String.subscript(_: ClosedRange<String.Index>) -> String
Added String.CharacterView.append<S : Sequence where S.Iterator.Element == Character>(contentsOf: S)
Added String.CharacterView.index(after: String.CharacterView.Index) -> String.CharacterView.Index
Added String.CharacterView.index(before: String.CharacterView.Index) -> String.CharacterView.Index
Added String.CharacterView.init<S : Sequence where S.Iterator.Element == Character>(_: S)
Added String.CharacterView.replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_: Range<String.CharacterView.Index>, with: C)
Added String.CharacterView.Index.customPlaygroundQuickLook
Added String.UnicodeScalarView.contains(_: UnicodeScalar) -> Bool
Added String.UnicodeScalarView.contains(where: (UnicodeScalar) throws -> Bool) rethrows -> Bool
Added String.UnicodeScalarView.distance(from: String.UnicodeScalarView.Index, to: String.UnicodeScalarView.Index) -> Int
Added String.UnicodeScalarView.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_: OtherSequence) -> Bool
Added String.UnicodeScalarView.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_: OtherSequence, by: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
Added String.UnicodeScalarView.filter(_: (UnicodeScalar) throws -> Bool) rethrows -> [UnicodeScalar]
Added String.UnicodeScalarView.first
Added String.UnicodeScalarView.first(where: (UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
Added String.UnicodeScalarView.flatMap<ElementOfResult>(_: (UnicodeScalar) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added String.UnicodeScalarView.flatMap<SegmentOfResult : Sequence>(_: (UnicodeScalar) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added String.UnicodeScalarView.forEach(_: (UnicodeScalar) throws -> Void) rethrows
Added String.UnicodeScalarView.formIndex(_: String.UnicodeScalarView.Index, offsetBy: Int)
Added String.UnicodeScalarView.formIndex(_: String.UnicodeScalarView.Index, offsetBy: Int, limitedBy: String.UnicodeScalarView.Index) -> Bool
Added String.UnicodeScalarView.formIndex(after: String.UnicodeScalarView.Index)
Added String.UnicodeScalarView.formIndex(before: String.UnicodeScalarView.Index)
Added String.UnicodeScalarView.index(_: String.UnicodeScalarView.Index, offsetBy: Int) -> String.UnicodeScalarView.Index
Added String.UnicodeScalarView.index(_: String.UnicodeScalarView.Index, offsetBy: Int, limitedBy: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index?
Added String.UnicodeScalarView.index(of: UnicodeScalar) -> String.UnicodeScalarView.Index?
Added String.UnicodeScalarView.index(where: (UnicodeScalar) throws -> Bool) rethrows -> String.UnicodeScalarView.Index?
Added String.UnicodeScalarView.indices
Added String.UnicodeScalarView.last
Added String.UnicodeScalarView.lazy
Added String.UnicodeScalarView.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_: OtherSequence) -> Bool
Added String.UnicodeScalarView.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_: OtherSequence, by: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
Added String.UnicodeScalarView.map<T>(_: (UnicodeScalar) throws -> T) rethrows -> [T]
Added String.UnicodeScalarView.map<T>(_: (UnicodeScalar) throws -> T) rethrows -> [T]
Added String.UnicodeScalarView.max(by: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
Added String.UnicodeScalarView.min(by: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
Added String.UnicodeScalarView.popFirst() -> UnicodeScalar?
Added String.UnicodeScalarView.popLast() -> UnicodeScalar?
Added String.UnicodeScalarView.reduce<Result>(_: Result, _: (Result, UnicodeScalar) throws -> Result) rethrows -> Result
Added String.UnicodeScalarView.removeFirst() -> UnicodeScalar
Added String.UnicodeScalarView.removeFirst(_: Int)
Added String.UnicodeScalarView.removeLast() -> UnicodeScalar
Added String.UnicodeScalarView.removeLast(_: Int)
Added String.UnicodeScalarView.sorted(by: (UnicodeScalar, UnicodeScalar) -> Bool) -> [UnicodeScalar]
Added String.UnicodeScalarView.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (UnicodeScalar) throws -> Bool) rethrows -> [String.UnicodeScalarView]
Added String.UnicodeScalarView.split(separator: UnicodeScalar, maxSplits: Int, omittingEmptySubsequences: Bool) -> [String.UnicodeScalarView]
Added String.UnicodeScalarView.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UnicodeScalar>(with: PossiblePrefix) -> Bool
Added String.UnicodeScalarView.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UnicodeScalar>(with: PossiblePrefix, by: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
Added String.UnicodeScalarView.subscript(_: ClosedRange<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView
Added String.UnicodeScalarView.underestimatedCount
Added String.UnicodeScalarView.underestimatedCount
Added String.UTF16View.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence) -> Bool
Added String.UTF16View.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added String.UTF16View.flatMap<ElementOfResult>(_: (UInt16) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added String.UTF16View.flatMap<SegmentOfResult : Sequence>(_: (UInt16) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added String.UTF16View.formIndex(_: String.UTF16View.Index, offsetBy: Int)
Added String.UTF16View.formIndex(_: String.UTF16View.Index, offsetBy: Int, limitedBy: String.UTF16View.Index) -> Bool
Added String.UTF16View.formIndex(after: String.UTF16View.Index)
Added String.UTF16View.formIndex(before: String.UTF16View.Index)
Added String.UTF16View.index(of: UInt16) -> String.UTF16View.Index?
Added String.UTF16View.index(where: (UInt16) throws -> Bool) rethrows -> String.UTF16View.Index?
Added String.UTF16View.lazy
Added String.UTF16View.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence) -> Bool
Added String.UTF16View.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added String.UTF16View.map<T>(_: (UInt16) throws -> T) rethrows -> [T]
Added String.UTF16View.map<T>(_: (UInt16) throws -> T) rethrows -> [T]
Added String.UTF16View.popFirst() -> UInt16?
Added String.UTF16View.popLast() -> UInt16?
Added String.UTF16View.removeFirst() -> UInt16
Added String.UTF16View.removeFirst(_: Int)
Added String.UTF16View.removeLast() -> UInt16
Added String.UTF16View.removeLast(_: Int)
Added String.UTF16View.split(separator: UInt16, maxSplits: Int, omittingEmptySubsequences: Bool) -> [String.UTF16View]
Added String.UTF16View.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with: PossiblePrefix) -> Bool
Added String.UTF16View.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with: PossiblePrefix, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added String.UTF16View.subscript(_: ClosedRange<String.UTF16View.Index>) -> String.UTF16View
Added String.UTF16View.underestimatedCount
Added String.UTF16View.underestimatedCount
Added String.UTF16View.Index.samePosition(in: String.UTF8View) -> String.UTF8View.Index?
Added String.UTF16View.Index.samePosition(in: String) -> String.Index?
Added String.UTF16View.Index.samePosition(in: String.UnicodeScalarView) -> String.UnicodeScalarIndex?
Added String.UTF8View.count
Added String.UTF8View.distance(from: String.UTF8View.Index, to: String.UTF8View.Index) -> Int
Added String.UTF8View.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence) -> Bool
Added String.UTF8View.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added String.UTF8View.flatMap<ElementOfResult>(_: (UInt8) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added String.UTF8View.flatMap<SegmentOfResult : Sequence>(_: (UInt8) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added String.UTF8View.formIndex(_: String.UTF8View.Index, offsetBy: Int)
Added String.UTF8View.formIndex(_: String.UTF8View.Index, offsetBy: Int, limitedBy: String.UTF8View.Index) -> Bool
Added String.UTF8View.formIndex(after: String.UTF8View.Index)
Added String.UTF8View.index(_: String.UTF8View.Index, offsetBy: Int) -> String.UTF8View.Index
Added String.UTF8View.index(_: String.UTF8View.Index, offsetBy: Int, limitedBy: String.UTF8View.Index) -> String.UTF8View.Index?
Added String.UTF8View.index(of: UInt8) -> String.UTF8View.Index?
Added String.UTF8View.index(where: (UInt8) throws -> Bool) rethrows -> String.UTF8View.Index?
Added String.UTF8View.indices
Added String.UTF8View.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence) -> Bool
Added String.UTF8View.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added String.UTF8View.map<T>(_: (UInt8) throws -> T) rethrows -> [T]
Added String.UTF8View.map<T>(_: (UInt8) throws -> T) rethrows -> [T]
Added String.UTF8View.popFirst() -> UInt8?
Added String.UTF8View.removeFirst() -> UInt8
Added String.UTF8View.removeFirst(_: Int)
Added String.UTF8View.split(separator: UInt8, maxSplits: Int, omittingEmptySubsequences: Bool) -> [String.UTF8View]
Added String.UTF8View.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with: PossiblePrefix) -> Bool
Added String.UTF8View.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with: PossiblePrefix, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added String.UTF8View.subscript(_: ClosedRange<String.UTF8View.Index>) -> String.UTF8View
Added String.UTF8View.underestimatedCount
Added String.UTF8View.underestimatedCount
Added String.UTF8View.Index.samePosition(in: String.UnicodeScalarView) -> String.UnicodeScalarIndex?
Added String.UTF8View.Index.samePosition(in: String.UTF16View) -> String.UTF16View.Index?
Added String.UTF8View.Index.samePosition(in: String) -> String.Index?
Added UInt.init(exactly: UInt)
Added UInt.init(exactly: UInt16)
Added UInt.init(exactly: UInt8)
Added UInt.init(exactly: Int32)
Added UInt.init(exactly: UInt64)
Added UInt.init(exactly: Int)
Added UInt.init(exactly: Int64)
Added UInt.init(exactly: Int16)
Added UInt.init(exactly: Int8)
Added UInt.init(exactly: UInt32)
Added UInt16.init(exactly: UInt64)
Added UInt16.init(exactly: UInt32)
Added UInt16.init(exactly: Int32)
Added UInt16.init(exactly: Int8)
Added UInt16.init(exactly: UInt8)
Added UInt16.init(exactly: Int64)
Added UInt16.init(exactly: Int)
Added UInt16.init(exactly: Int16)
Added UInt16.init(exactly: UInt)
Added UInt16.init(exactly: UInt16)
Added UInt32.init(exactly: Int16)
Added UInt32.init(exactly: UInt32)
Added UInt32.init(exactly: Int32)
Added UInt32.init(exactly: UInt)
Added UInt32.init(exactly: Int8)
Added UInt32.init(exactly: UInt8)
Added UInt32.init(exactly: UInt16)
Added UInt32.init(exactly: Int)
Added UInt32.init(exactly: UInt64)
Added UInt32.init(exactly: Int64)
Added UInt64.init(exactly: UInt64)
Added UInt64.init(exactly: Int16)
Added UInt64.init(exactly: Int)
Added UInt64.init(exactly: Int32)
Added UInt64.init(exactly: UInt8)
Added UInt64.init(exactly: UInt32)
Added UInt64.init(exactly: Int8)
Added UInt64.init(exactly: UInt16)
Added UInt64.init(exactly: Int64)
Added UInt64.init(exactly: UInt)
Added UInt8.init(exactly: UInt8)
Added UInt8.init(exactly: Int)
Added UInt8.init(exactly: Int16)
Added UInt8.init(exactly: UInt32)
Added UInt8.init(exactly: UInt64)
Added UInt8.init(exactly: Int8)
Added UInt8.init(exactly: Int64)
Added UInt8.init(exactly: UInt)
Added UInt8.init(exactly: UInt16)
Added UInt8.init(exactly: Int32)
Added UnfoldSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnfoldSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnfoldSequence.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added UnfoldSequence.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added UnfoldSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnfoldSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnfoldSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added UnfoldSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnicodeCodec.decode<I : IteratorProtocol where I.Element == CodeUnit>(_: I) -> UnicodeDecodingResult
Added UnicodeCodec.encode(_: UnicodeScalar, into: (Self.CodeUnit) -> Swift.Void) [class]
Added UnicodeDecodingResult.scalarValue
Added UnicodeScalar.customMirror
Added UnicodeScalar.customPlaygroundQuickLook
Added UnicodeScalar.escaped(asASCII: Bool) -> String
Added UnicodeScalar.init(_: String)
Added UnicodeScalar.isASCII
Added UnicodeScalar.write<Target : TextOutputStream>(to: Target)
Added UnicodeScalarIndex.samePosition(in: String.UTF16View) -> String.UTF16View.Index
Added UnicodeScalarIndex.samePosition(in: String) -> String.Index?
Added UnicodeScalarIndex.samePosition(in: String.UTF8View) -> String.UTF8View.Index
Added UnsafeBufferPointer.count
Added UnsafeBufferPointer.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeBufferPointer.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointer.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added UnsafeBufferPointer.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added UnsafeBufferPointer.formIndex(_: Int, offsetBy: Int)
Added UnsafeBufferPointer.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added UnsafeBufferPointer.index(of: Element) -> Int?
Added UnsafeBufferPointer.index(where: (Element) throws -> Bool) rethrows -> Int?
Added UnsafeBufferPointer.joined() -> FlattenCollection<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.joined() -> FlattenSequence<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.joined() -> FlattenBidirectionalCollection<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.joined(separator: String) -> String
Added UnsafeBufferPointer.lazy
Added UnsafeBufferPointer.lazy
Added UnsafeBufferPointer.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeBufferPointer.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointer.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added UnsafeBufferPointer.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added UnsafeBufferPointer.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added UnsafeBufferPointer.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<UnsafeBufferPointer<Element>>]
Added UnsafeBufferPointer.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added UnsafeBufferPointer.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointer.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.subscript(_: Range<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.subscript(_: Range<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.subscript(_: CountableRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.underestimatedCount
Added UnsafeBufferPointer.underestimatedCount
Added UnsafeBufferPointerIterator [struct]
Added UnsafeBufferPointerIterator.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointerIterator.dropFirst() -> AnySequence<Element>
Added UnsafeBufferPointerIterator.dropFirst(_: Int) -> AnySequence<Element>
Added UnsafeBufferPointerIterator.dropLast() -> AnySequence<Element>
Added UnsafeBufferPointerIterator.dropLast(_: Int) -> AnySequence<Element>
Added UnsafeBufferPointerIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeBufferPointerIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointerIterator.enumerated() -> EnumeratedSequence<UnsafeBufferPointerIterator<Element>>
Added UnsafeBufferPointerIterator.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added UnsafeBufferPointerIterator.first(where: (Element) throws -> Bool) rethrows -> Element?
Added UnsafeBufferPointerIterator.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added UnsafeBufferPointerIterator.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added UnsafeBufferPointerIterator.forEach(_: (Element) throws -> Void) rethrows
Added UnsafeBufferPointerIterator.joined() -> FlattenSequence<UnsafeBufferPointerIterator<Element>>
Added UnsafeBufferPointerIterator.joined(separator: String) -> String
Added UnsafeBufferPointerIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<UnsafeBufferPointerIterator<Element>>
Added UnsafeBufferPointerIterator.lazy
Added UnsafeBufferPointerIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeBufferPointerIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointerIterator.makeIterator() -> UnsafeBufferPointerIterator<Element>
Added UnsafeBufferPointerIterator.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added UnsafeBufferPointerIterator.max() -> Element?
Added UnsafeBufferPointerIterator.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added UnsafeBufferPointerIterator.min() -> Element?
Added UnsafeBufferPointerIterator.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added UnsafeBufferPointerIterator.next() -> Element?
Added UnsafeBufferPointerIterator.prefix(_: Int) -> AnySequence<Element>
Added UnsafeBufferPointerIterator.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added UnsafeBufferPointerIterator.reversed() -> [Element]
Added UnsafeBufferPointerIterator.sorted() -> [Element]
Added UnsafeBufferPointerIterator.sorted(by: (Element, Element) -> Bool) -> [Element]
Added UnsafeBufferPointerIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
Added UnsafeBufferPointerIterator.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added UnsafeBufferPointerIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added UnsafeBufferPointerIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointerIterator.suffix(_: Int) -> AnySequence<Element>
Added UnsafeBufferPointerIterator.underestimatedCount
Added UnsafeMutableBufferPointer.count
Added UnsafeMutableBufferPointer.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeMutableBufferPointer.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeMutableBufferPointer.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added UnsafeMutableBufferPointer.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added UnsafeMutableBufferPointer.formIndex(_: Int, offsetBy: Int)
Added UnsafeMutableBufferPointer.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added UnsafeMutableBufferPointer.index(of: Element) -> Int?
Added UnsafeMutableBufferPointer.index(where: (Element) throws -> Bool) rethrows -> Int?
Added UnsafeMutableBufferPointer.joined() -> FlattenCollection<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.joined() -> FlattenSequence<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.joined() -> FlattenBidirectionalCollection<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.joined(separator: String) -> String
Added UnsafeMutableBufferPointer.lazy
Added UnsafeMutableBufferPointer.lazy
Added UnsafeMutableBufferPointer.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeMutableBufferPointer.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeMutableBufferPointer.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added UnsafeMutableBufferPointer.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added UnsafeMutableBufferPointer.partition(by: (Element) throws -> Bool) rethrows -> Int
Added UnsafeMutableBufferPointer.partition(by: (Element) throws -> Bool) rethrows -> Int
Added UnsafeMutableBufferPointer.sorted() -> [Element]
Added UnsafeMutableBufferPointer.sorted() -> [Element]
Added UnsafeMutableBufferPointer.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>]
Added UnsafeMutableBufferPointer.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added UnsafeMutableBufferPointer.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added UnsafeMutableBufferPointer.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeMutableBufferPointer.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: ClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: ClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: Range<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: Range<Int>) -> MutableSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: CountableRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: CountableRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.underestimatedCount
Added UnsafeMutableBufferPointer.underestimatedCount
Added UnsafeMutablePointer.initialize<C : Collection where C.Iterator.Element == Pointee>(from: C)
Added UnsafeMutableRawPointer.initializeMemory<C : Collection>(as: C.Iterator.Element.Type, from: C) -> UnsafeMutablePointer<C.Iterator.Element>
Added UnsignedInteger.advanced(by: Int) -> Self
Added UnsignedInteger.distance(to: Self) -> Int
Added UnsignedInteger.init(_: UIntMax)
Added UnsignedInteger.toUIntMax() -> UIntMax
Added UTF16.decode<I : IteratorProtocol where I.Element == CodeUnit>(_: I) -> UnicodeDecodingResult
Added UTF16.encode(_: UnicodeScalar, into: (UTF16.CodeUnit) -> Swift.Void) [static]
Added UTF16.transcodedLength<Input, Encoding where Input : IteratorProtocol, Encoding : UnicodeCodec, Encoding.CodeUnit == Input.Element>(of: Input, decodedAs: Encoding.Type, repairingIllFormedSequences: Bool) -> (count: Int, isASCII: Bool)? [static]
Added UTF32.decode<I : IteratorProtocol where I.Element == CodeUnit>(_: I) -> UnicodeDecodingResult
Added UTF32.encode(_: UnicodeScalar, into: (UTF32.CodeUnit) -> Swift.Void) [static]
Added UTF8.decode<I : IteratorProtocol where I.Element == CodeUnit>(_: I) -> UnicodeDecodingResult
Added UTF8.encode(_: UnicodeScalar, into: (UTF8.CodeUnit) -> Swift.Void) [static]
Added Zip2Iterator [struct]
Added Zip2Iterator.next() -> (Iterator1.Element, Iterator2.Element)?
Added Zip2Sequence.contains(where: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Zip2Sequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_: OtherSequence, by: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool
Added Zip2Sequence.filter(_: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)]
Added Zip2Sequence.first(where: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)?
Added Zip2Sequence.flatMap<ElementOfResult>(_: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Zip2Sequence.flatMap<SegmentOfResult : Sequence>(_: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Zip2Sequence.forEach(_: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Void) rethrows
Added Zip2Sequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_: OtherSequence, by: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool
Added Zip2Sequence.map<T>(_: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> T) rethrows -> [T]
Added Zip2Sequence.max(by: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)?
Added Zip2Sequence.min(by: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)?
Added Zip2Sequence.reduce<Result>(_: Result, _: (Result, (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Result) rethrows -> Result
Added Zip2Sequence.sorted(by: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) -> Bool) -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)]
Added Zip2Sequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>]
Added Zip2Sequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(with: PossiblePrefix, by: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool
Added !=(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added !=(_: T, _: T) -> Bool
Added !=(_: T, _: T) -> Bool
Added !=(_: T, _: T) -> Bool
Added %(_: T, _: T) -> T
Added %=(_: T, _: T)
Added &*(_: T, _: T) -> T
Added &+(_: T, _: T) -> T
Added &-(_: T, _: T) -> T
Added &=(_: T, _: T)
Added *(_: T, _: T) -> T
Added *(_: T, _: T) -> T
Added *=(_: T, _: T)
Added *=(_: T, _: T)
Added +(_: T) -> T
Added +(_: T) -> T
Added +(_: T, _: T._DisallowMixedSignArithmetic) -> T
Added +(_: C, _: S) -> C
Added +(_: T._DisallowMixedSignArithmetic, _: T) -> T
Added +(_: RRC1, _: RRC2) -> RRC1
Added +(_: T, _: T) -> T
Added +(_: S, _: C) -> C
Added +(_: T, _: T) -> T
Added +=(_: T, _: T)
Added +=(_: ContiguousArray<C.Iterator.Element>, _: C)
Added +=(_: _ContiguousArrayBuffer<Element>, _: C)
Added +=(_: T, _: T)
Added +=(_: [S.Iterator.Element], _: S)
Added +=(_: ArraySlice<S.Iterator.Element>, _: S)
Added +=(_: [C.Iterator.Element], _: C)
Added +=(_: ContiguousArray<S.Iterator.Element>, _: S)
Added +=(_: T, _: T._DisallowMixedSignArithmetic)
Added +=(_: ArraySlice<C.Iterator.Element>, _: C)
Added -(_: T) -> T
Added -(_: T) -> T
Added -(_: T, _: T) -> T
Added -(_: T, _: T) -> T
Added -=(_: T, _: T)
Added -=(_: T, _: T._DisallowMixedSignArithmetic)
Added -=(_: T, _: T)
Added ...(_: Bound, _: Bound) -> CountableClosedRange<Bound>
Added ...(_: Bound, _: Bound) -> ClosedRange<Bound>
Added ..<(_: Bound, _: Bound) -> Range<Bound>
Added ..<(_: Bound, _: Bound) -> CountableRange<Bound>
Added /(_: T, _: T) -> T
Added /(_: T, _: T) -> T
Added /=(_: T, _: T)
Added /=(_: T, _: T)
Added <(_: ClosedRangeIndex<Bound>, _: ClosedRangeIndex<Bound>) -> Bool
Added <(_: String.Index, _: String.Index) -> Bool
Added <(_: UnsafeRawPointer, _: UnsafeRawPointer) -> Bool
Added <(_: T, _: T) -> Bool
Added <(_: ReversedIndex<Base>, _: ReversedIndex<Base>) -> Bool
Added <(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool
Added <(_: UnsafeMutableRawPointer, _: UnsafeMutableRawPointer) -> Bool
Added <(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool
Added <(_: UnicodeScalar, _: UnicodeScalar) -> Bool
Added <(_: FlattenBidirectionalCollectionIndex<BaseElements>, _: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool
Added <(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool
Added <(_: ReversedRandomAccessIndex<Base>, _: ReversedRandomAccessIndex<Base>) -> Bool
Added <(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool
Added <(_: String.UTF8View.Index, _: String.UTF8View.Index) -> Bool
Added <(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added <(_: T, _: T) -> Bool
Added <(_: FlattenCollectionIndex<BaseElements>, _: FlattenCollectionIndex<BaseElements>) -> Bool
Added <(_: T, _: T) -> Bool
Added <=(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added <=(_: T, _: T) -> Bool
Added <=(_: T, _: T) -> Bool
Added <=(_: T, _: T) -> Bool
Added ==(_: UnsafeMutableRawPointer, _: UnsafeMutableRawPointer) -> Bool
Added ==(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool
Added ==(_: String.Index, _: String.Index) -> Bool
Added ==(_: String.UTF8View.Index, _: String.UTF8View.Index) -> Bool
Added ==(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added ==(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool
Added ==(_: ReversedIndex<Base>, _: ReversedIndex<Base>) -> Bool
Added ==(_: CountableClosedRange<Bound>, _: CountableClosedRange<Bound>) -> Bool
Added ==(_: ClosedRangeIndex<Bound>, _: ClosedRangeIndex<Bound>) -> Bool
Added ==(_: UnicodeScalar, _: UnicodeScalar) -> Bool
Added ==(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool
Added ==(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool
Added ==(_: T, _: T) -> Bool
Added ==(_: ManagedBufferPointer<Header, Element>, _: ManagedBufferPointer<Header, Element>) -> Bool
Added ==(_: T, _: T) -> Bool
Added ==(_: FlattenBidirectionalCollectionIndex<BaseElements>, _: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool
Added ==(_: ReversedRandomAccessIndex<Base>, _: ReversedRandomAccessIndex<Base>) -> Bool
Added ==(_: T, _: T) -> Bool
Added ==(_: CountableRange<Bound>, _: CountableRange<Bound>) -> Bool
Added ==(_: UnsafeRawPointer, _: UnsafeRawPointer) -> Bool
Added ==(_: FlattenCollectionIndex<BaseElements>, _: FlattenCollectionIndex<BaseElements>) -> Bool
Added >(_: T, _: T) -> Bool
Added >(_: T, _: T) -> Bool
Added >(_: T, _: T) -> Bool
Added >(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added >=(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added >=(_: T, _: T) -> Bool
Added >=(_: T, _: T) -> Bool
Added >=(_: T, _: T) -> Bool
Added ^=(_: T, _: T)
Added abs<T : SignedNumber>(_: T) -> T
Added AnyBidirectionalCollection.IndexDistance
Added AnyCollection.IndexDistance
Added AnyRandomAccessCollection.IndexDistance
Added BidirectionalSlice.Index
Added BidirectionalSlice.IndexDistance
Added BidirectionalSlice.SubSequence
Added Collection.IndexDistance
Added CountableClosedRange.Element
Added CountableClosedRange.Index
Added CountableClosedRange.IndexDistance
Added CountableClosedRange.Iterator
Added CountableRange.Element
Added CountableRange.Index
Added CountableRange.IndexDistance
Added CountableRange.Indices
Added CountableRange.SubSequence
Added DefaultBidirectionalIndices.Index
Added DefaultBidirectionalIndices.Indices
Added DefaultBidirectionalIndices.SubSequence
Added DefaultRandomAccessIndices.Index
Added DefaultRandomAccessIndices.Indices
Added DefaultRandomAccessIndices.SubSequence
Added EmptyCollection.IndexDistance
Added ExpressibleByArrayLiteral.Element
Added FlattenBidirectionalCollection.IndexDistance
Added FlattenCollection.IndexDistance
Added Indexable.IndexDistance
Added IndexableBase.Index
Added IndexableBase.SubSequence
Added LazyBidirectionalCollection.Elements
Added LazyBidirectionalCollection.Index
Added LazyFilterBidirectionalCollection.Index
Added LazyFilterBidirectionalCollection.IndexDistance
Added LazyFilterCollection.IndexDistance
Added LazyMapBidirectionalCollection.Index
Added LazyMapBidirectionalCollection.IndexDistance
Added LazyMapBidirectionalCollection.Indices
Added LazyMapCollection.IndexDistance
Added LazyMapRandomAccessCollection.Index
Added LazyMapRandomAccessCollection.IndexDistance
Added LazyMapRandomAccessCollection.Indices
Added LazyRandomAccessCollection.Elements
Added LazyRandomAccessCollection.Index
Added MutableBidirectionalSlice.Index
Added MutableBidirectionalSlice.IndexDistance
Added MutableBidirectionalSlice.SubSequence
Added MutableIndexable.SubSequence
Added MutableRandomAccessSlice.Index
Added MutableRandomAccessSlice.IndexDistance
Added MutableRandomAccessSlice.SubSequence
Added MutableRangeReplaceableBidirectionalSlice.Index
Added MutableRangeReplaceableBidirectionalSlice.IndexDistance
Added MutableRangeReplaceableBidirectionalSlice.SubSequence
Added MutableRangeReplaceableRandomAccessSlice.Index
Added MutableRangeReplaceableRandomAccessSlice.IndexDistance
Added MutableRangeReplaceableRandomAccessSlice.SubSequence
Added MutableRangeReplaceableSlice.Index
Added MutableRangeReplaceableSlice.IndexDistance
Added MutableRangeReplaceableSlice.SubSequence
Added MutableSlice.IndexDistance
Added MutableSlice.SubSequence
Added numericCast<T : UnsignedInteger, U : _SignedInteger>(_: T) -> U
Added numericCast<T : UnsignedInteger, U : UnsignedInteger>(_: T) -> U
Added numericCast<T : _SignedInteger, U : _SignedInteger>(_: T) -> U
Added numericCast<T : _SignedInteger, U : UnsignedInteger>(_: T) -> U
Added RandomAccessSlice.Index
Added RandomAccessSlice.IndexDistance
Added RandomAccessSlice.SubSequence
Added RangeReplaceableBidirectionalSlice.Index
Added RangeReplaceableBidirectionalSlice.IndexDistance
Added RangeReplaceableBidirectionalSlice.SubSequence
Added RangeReplaceableRandomAccessSlice.Index
Added RangeReplaceableRandomAccessSlice.IndexDistance
Added RangeReplaceableRandomAccessSlice.SubSequence
Added RangeReplaceableSlice.Index
Added RangeReplaceableSlice.IndexDistance
Added RangeReplaceableSlice.SubSequence
Added ReversedCollection.Index
Added ReversedCollection.IndexDistance
Added ReversedCollection.Iterator
Added ReversedRandomAccessCollection.Index
Added ReversedRandomAccessCollection.IndexDistance
Added ReversedRandomAccessCollection.Iterator
Added Slice.IndexDistance
Added Streamable
Added String.CharacterView.IndexDistance
Added String.UTF16View.IndexDistance
Added String.UTF16View.Indices.IndexDistance
Added String.UTF8View.IndexDistance
Added transcode<Input, InputEncoding, OutputEncoding where Input : IteratorProtocol, InputEncoding : UnicodeCodec, OutputEncoding : UnicodeCodec, InputEncoding.CodeUnit == Input.Element>(_: Input, from: InputEncoding.Type, to: OutputEncoding.Type, stoppingOnError: Bool, into: (OutputEncoding.CodeUnit) -> Swift.Void) -> Bool
Added UnicodeCodec.CodeUnit
Added UnsafeBufferPointer.IndexDistance
Added UnsafeBufferPointer.Iterator
Added UnsafeMutableBufferPointer.IndexDistance
Added Zip2Iterator.Element
Added Zip2Sequence.Iterator
Added |=(_: T, _: T)
Added ~=(_: ClosedRange<Bound>, _: Bound) -> Bool
Added ~=(_: CountableClosedRange<Bound>, _: Bound) -> Bool
Added ~=(_: CountableRange<Bound>, _: Bound) -> Bool
Modified _Incrementable
Declaration
From
protocol _Incrementable : Equatable {
    @warn_unused_result
    func successor() -> Self
}
To
protocol _Incrementable : Equatable {
}

Modified AbsoluteValuable
DeclarationProtocols
From
protocol AbsoluteValuable : SignedNumberType {
    @warn_unused_result
    static func abs(_ x: Self) -> Self
}
SignedNumberType
To
protocol AbsoluteValuable : SignedNumber {
    static func abs(_ x: Self) -> Self
}
SignedNumber

Modified AbsoluteValuable.abs(_: Self) -> Self [class]
Declaration
From
@warn_unused_result
    static func abs(_ x: Self) -> Self
To
static func abs(_ x: Self) -> Self

DeclarationProtocols
From
struct AnyBidirectionalCollection<Element> : AnyCollectionType {
    typealias T = Element
    init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyBidirectionalCollection<Element>)
    init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyRandomAccessCollection<Element>)
    init?(_ other: AnyForwardCollection<Element>)
    func generate() -> AnyGenerator<Element>
    var startIndex: AnyBidirectionalIndex { get }
    var endIndex: AnyBidirectionalIndex { get }
    subscript (_ position: AnyBidirectionalIndex) -> Element { get }
    var count: IntMax { get }
}
extension AnyBidirectionalCollection {
    func underestimateCount() -> Int
}
AnyCollectionType
To
struct AnyBidirectionalCollection<Element> : BidirectionalCollection {
    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>(_ base: C)
    init(_ other: AnyBidirectionalCollection<Element>)
    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>(_ base: C)
    init(_ other: AnyRandomAccessCollection<Element>)
    init?(_ other: AnyCollection<Element>)
    typealias Index = AnyIndex
    typealias IndexDistance = IntMax
    var startIndex: AnyIndex { get }
    var endIndex: AnyIndex { get }
    subscript(_ position: AnyIndex) -> Element { get }
    subscript(_ bounds: Range<AnyIndex>) -> AnyBidirectionalCollection<Element> { get }
    func index(after i: AnyIndex) -> AnyIndex
    func formIndex(after i: inout AnyIndex)
    func index(_ i: AnyIndex, offsetBy n: IntMax) -> AnyIndex
    func index(_ i: AnyIndex, offsetBy n: IntMax, limitedBy limit: AnyIndex) -> AnyIndex?
    func formIndex(_ i: inout AnyIndex, offsetBy n: IntMax)
    func formIndex(_ i: inout AnyIndex, offsetBy n: IntMax, limitedBy limit: AnyIndex) -> Bool
    func distance(from start: AnyIndex, to end: AnyIndex) -> IntMax
    var count: IntMax { get }
    var first: Element? { get }
    func index(before i: AnyIndex) -> AnyIndex
    func formIndex(before i: inout AnyIndex)
    var last: Element? { get }
    func makeIterator() -> AnyIterator<Element>
    var underestimatedCount: Int { get }
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    func forEach(_ body: (Element) throws -> Swift.Void) rethrows
    func dropFirst(_ n: Int) -> AnyBidirectionalCollection<Element>
    func dropLast(_ n: Int) -> AnyBidirectionalCollection<Element>
    func prefix(_ maxLength: Int) -> AnyBidirectionalCollection<Element>
    func suffix(_ maxLength: Int) -> AnyBidirectionalCollection<Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnyBidirectionalCollection<Element>]
    func underestimateCount() -> Int
    mutating func popLast() -> Element?
    mutating func removeLast() -> Element
    mutating func removeLast(_ n: Int)
    mutating func popFirst() -> Element?
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func prefix(upTo end: AnyIndex) -> AnyBidirectionalCollection<Element>
    func suffix(from start: AnyIndex) -> AnyBidirectionalCollection<Element>
    func prefix(through position: AnyIndex) -> AnyBidirectionalCollection<Element>
    mutating func removeFirst() -> Element
    mutating func removeFirst(_ n: Int)
    typealias Generator = AnyIterator<Element>
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnyBidirectionalCollection<Element>]
    var last: Element? { get }
    func index(where predicate: (Element) throws -> Bool) rethrows -> AnyIndex?
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    subscript(_ bounds: ClosedRange<AnyIndex>) -> AnyBidirectionalCollection<Element> { get }
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> AnyIndex?
    var indices: DefaultBidirectionalIndices<AnyBidirectionalCollection<Element>> { get }
    var lazy: LazySequence<AnyBidirectionalCollection<Element>> { get }
    func reversed() -> ReversedCollection<AnyBidirectionalCollection<Element>>
    func reverse() -> ReversedCollection<AnyBidirectionalCollection<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    var underestimatedCount: Int { get }
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> AnyBidirectionalCollection<Element>
    func dropLast() -> AnyBidirectionalCollection<Element>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnyBidirectionalCollection<Element>]
    func enumerated() -> EnumeratedSequence<AnyBidirectionalCollection<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<AnyBidirectionalCollection<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension AnyBidirectionalCollection {
    var lazy: LazyBidirectionalCollection<AnyBidirectionalCollection<Element>> { get }
}
extension AnyBidirectionalCollection {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Int64 { get }
}
extension AnyBidirectionalCollection {
    var lazy: LazyCollection<AnyBidirectionalCollection<Element>> { get }
}
extension AnyBidirectionalCollection where Element : Collection {
    func joined() -> FlattenCollection<AnyBidirectionalCollection<Element>>
    func flatten() -> FlattenCollection<AnyBidirectionalCollection<Element>>
}
extension AnyBidirectionalCollection where Element : Comparable {
    func sorted() -> [Element]
    func sort() -> [Element]
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension AnyBidirectionalCollection where Element : Sequence {
    func joined() -> FlattenSequence<AnyBidirectionalCollection<Element>>
    func flatten() -> FlattenSequence<AnyBidirectionalCollection<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<AnyBidirectionalCollection<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<AnyBidirectionalCollection<Element>>
}
extension AnyBidirectionalCollection where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension AnyBidirectionalCollection where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnyBidirectionalCollection<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnyBidirectionalCollection<Element>]
    func index(of element: Element) -> AnyIndex?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension AnyBidirectionalCollection where Element : BidirectionalCollection {
    func joined() -> FlattenBidirectionalCollection<AnyBidirectionalCollection<Element>>
    func flatten() -> FlattenBidirectionalCollection<AnyBidirectionalCollection<Element>>
}
BidirectionalCollection

Declaration
From
var endIndex: AnyBidirectionalIndex { get }
To
var endIndex: AnyIndex { get }

Declaration
From
var startIndex: AnyBidirectionalIndex { get }
To
var startIndex: AnyIndex { get }

DeclarationProtocols
From
struct AnyRandomAccessCollection<Element> : AnyCollectionType {
    typealias T = Element
    init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyRandomAccessCollection<Element>)
    init?(_ other: AnyForwardCollection<Element>)
    init?(_ other: AnyBidirectionalCollection<Element>)
    func generate() -> AnyGenerator<Element>
    var startIndex: AnyRandomAccessIndex { get }
    var endIndex: AnyRandomAccessIndex { get }
    subscript (_ position: AnyRandomAccessIndex) -> Element { get }
    var count: IntMax { get }
}
extension AnyRandomAccessCollection {
    func underestimateCount() -> Int
}
AnyCollectionType
To
struct AnyRandomAccessCollection<Element> : RandomAccessCollection {
    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>(_ base: C)
    init(_ other: AnyRandomAccessCollection<Element>)
    init?(_ other: AnyCollection<Element>)
    init?(_ other: AnyBidirectionalCollection<Element>)
    typealias Index = AnyIndex
    typealias IndexDistance = IntMax
    var startIndex: AnyIndex { get }
    var endIndex: AnyIndex { get }
    subscript(_ position: AnyIndex) -> Element { get }
    subscript(_ bounds: Range<AnyIndex>) -> AnyRandomAccessCollection<Element> { get }
    func index(after i: AnyIndex) -> AnyIndex
    func formIndex(after i: inout AnyIndex)
    func index(_ i: AnyIndex, offsetBy n: IntMax) -> AnyIndex
    func index(_ i: AnyIndex, offsetBy n: IntMax, limitedBy limit: AnyIndex) -> AnyIndex?
    func formIndex(_ i: inout AnyIndex, offsetBy n: IntMax)
    func formIndex(_ i: inout AnyIndex, offsetBy n: IntMax, limitedBy limit: AnyIndex) -> Bool
    func distance(from start: AnyIndex, to end: AnyIndex) -> IntMax
    var count: IntMax { get }
    var first: Element? { get }
    func index(before i: AnyIndex) -> AnyIndex
    func formIndex(before i: inout AnyIndex)
    var last: Element? { get }
    func makeIterator() -> AnyIterator<Element>
    var underestimatedCount: Int { get }
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    func forEach(_ body: (Element) throws -> Swift.Void) rethrows
    func dropFirst(_ n: Int) -> AnyRandomAccessCollection<Element>
    func dropLast(_ n: Int) -> AnyRandomAccessCollection<Element>
    func prefix(_ maxLength: Int) -> AnyRandomAccessCollection<Element>
    func suffix(_ maxLength: Int) -> AnyRandomAccessCollection<Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnyRandomAccessCollection<Element>]
    func underestimateCount() -> Int
    mutating func popLast() -> Element?
    mutating func removeLast() -> Element
    mutating func removeLast(_ n: Int)
    mutating func popFirst() -> Element?
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func prefix(upTo end: AnyIndex) -> AnyRandomAccessCollection<Element>
    func suffix(from start: AnyIndex) -> AnyRandomAccessCollection<Element>
    func prefix(through position: AnyIndex) -> AnyRandomAccessCollection<Element>
    mutating func removeFirst() -> Element
    mutating func removeFirst(_ n: Int)
    typealias Generator = AnyIterator<Element>
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnyRandomAccessCollection<Element>]
    var last: Element? { get }
    func index(where predicate: (Element) throws -> Bool) rethrows -> AnyIndex?
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    subscript(_ bounds: ClosedRange<AnyIndex>) -> AnyRandomAccessCollection<Element> { get }
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> AnyIndex?
    var indices: DefaultRandomAccessIndices<AnyRandomAccessCollection<Element>> { get }
    var lazy: LazySequence<AnyRandomAccessCollection<Element>> { get }
    func reversed() -> ReversedRandomAccessCollection<AnyRandomAccessCollection<Element>>
    func reverse() -> ReversedRandomAccessCollection<AnyRandomAccessCollection<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    var underestimatedCount: Int { get }
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> AnyRandomAccessCollection<Element>
    func dropLast() -> AnyRandomAccessCollection<Element>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnyRandomAccessCollection<Element>]
    func enumerated() -> EnumeratedSequence<AnyRandomAccessCollection<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<AnyRandomAccessCollection<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension AnyRandomAccessCollection {
    var lazy: LazyRandomAccessCollection<AnyRandomAccessCollection<Element>> { get }
}
extension AnyRandomAccessCollection {
    var lazy: LazyBidirectionalCollection<AnyRandomAccessCollection<Element>> { get }
}
extension AnyRandomAccessCollection {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Int64 { get }
}
extension AnyRandomAccessCollection {
    var lazy: LazyCollection<AnyRandomAccessCollection<Element>> { get }
}
extension AnyRandomAccessCollection where Element : Comparable {
    func sorted() -> [Element]
    func sort() -> [Element]
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension AnyRandomAccessCollection where Element : Sequence {
    func joined() -> FlattenSequence<AnyRandomAccessCollection<Element>>
    func flatten() -> FlattenSequence<AnyRandomAccessCollection<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<AnyRandomAccessCollection<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<AnyRandomAccessCollection<Element>>
}
extension AnyRandomAccessCollection where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension AnyRandomAccessCollection where Element : Collection {
    func joined() -> FlattenCollection<AnyRandomAccessCollection<Element>>
    func flatten() -> FlattenCollection<AnyRandomAccessCollection<Element>>
}
extension AnyRandomAccessCollection where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnyRandomAccessCollection<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnyRandomAccessCollection<Element>]
    func index(of element: Element) -> AnyIndex?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension AnyRandomAccessCollection where Element : BidirectionalCollection {
    func joined() -> FlattenBidirectionalCollection<AnyRandomAccessCollection<Element>>
    func flatten() -> FlattenBidirectionalCollection<AnyRandomAccessCollection<Element>>
}
RandomAccessCollection

Declaration
From
var endIndex: AnyRandomAccessIndex { get }
To
var endIndex: AnyIndex { get }

Declaration
From
var startIndex: AnyRandomAccessIndex { get }
To
var startIndex: AnyIndex { get }

DeclarationProtocols
From
struct AnySequence<Element> : SequenceType {
    typealias T = Element
    init<S : SequenceType where S.Generator.Element == Element, S.SubSequence : SequenceType, S.SubSequence.Generator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_ base: S)
    init<G : GeneratorType where G.Element == Element>(_ makeUnderlyingGenerator: () -> G)
    func generate() -> AnyGenerator<Element>
}
extension AnySequence {
    @warn_unused_result
    func dropFirst(_ n: Int) -> AnySequence<Element>
    @warn_unused_result
    func prefix(_ maxLength: Int) -> AnySequence<Element>
}
extension AnySequence {
    func underestimateCount() -> Int
}
SequenceType
To
struct AnySequence<Element> : Sequence {
    init<S : Sequence where S.Iterator.Element == Element, S.SubSequence : Sequence, S.SubSequence.Iterator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_ base: S)
    init<I : IteratorProtocol where I.Element == Element>(_ makeUnderlyingIterator: @escaping () -> I)
    func makeIterator() -> AnyIterator<Element>
    var underestimatedCount: Int { get }
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    func forEach(_ body: (Element) throws -> Swift.Void) rethrows
    func dropFirst(_ n: Int) -> AnySequence<Element>
    func dropLast(_ n: Int) -> AnySequence<Element>
    func prefix(_ maxLength: Int) -> AnySequence<Element>
    func suffix(_ maxLength: Int) -> AnySequence<Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
    func underestimateCount() -> Int
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    var lazy: LazySequence<AnySequence<Element>> { get }
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    var underestimatedCount: Int { get }
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> AnySequence<Element>
    func dropLast() -> AnySequence<Element>
    func generate() -> AnyIterator<Element>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
    func enumerated() -> EnumeratedSequence<AnySequence<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func reversed() -> [Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<AnySequence<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func reverse() -> [Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension AnySequence where Element : Comparable {
    func sorted() -> [Element]
    func sort() -> [Element]
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension AnySequence where Element : Sequence {
    func joined() -> FlattenSequence<AnySequence<Element>>
    func flatten() -> FlattenSequence<AnySequence<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<AnySequence<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<AnySequence<Element>>
}
extension AnySequence where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension AnySequence where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
Sequence

Declaration
From
@warn_unused_result
    func dropFirst(_ n: Int) -> AnySequence<Element>
To
func dropFirst(_ n: Int) -> AnySequence<Element>

Declaration
From
@warn_unused_result
    func prefix(_ maxLength: Int) -> AnySequence<Element>
To
func prefix(_ maxLength: Int) -> AnySequence<Element>

DeclarationProtocols
From
struct Array<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ index: Int) -> Element
    subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
}
extension Array : _ObjectiveCBridgeable {
}
extension Array : ArrayLiteralConvertible {
    init(arrayLiteral elements: Element...)
}
extension Array : _ArrayType {
    init()
    init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: Element)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S)
    mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C)
    mutating func removeLast() -> Element
    mutating func insert(_ newElement: Element, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
}
extension Array : _Reflectable {
}
extension Array : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Array {
    func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension Array {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
}
extension Array {
    mutating func popLast() -> Element?
}
ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, MutableCollectionType
To
struct Array<Element> : RandomAccessCollection, MutableCollection {
    typealias Index = Int
    typealias Iterator = IndexingIterator<[Element]>
    var startIndex: Int { get }
    var endIndex: Int { get }
    func index(after i: Int) -> Int
    func formIndex(after i: inout Int)
    func index(before i: Int) -> Int
    func formIndex(before i: inout Int)
    func index(_ i: Int, offsetBy n: Int) -> Int
    func index(_ i: Int, offsetBy n: Int, limitedBy limit: Int) -> Int?
    func distance(from start: Int, to end: Int) -> Int
    typealias Indices = CountableRange<Int>
    subscript(_ index: Int) -> Element
    subscript(_ bounds: Range<Int>) -> ArraySlice<Element>
    func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subrange: Range<Int>, with newElements: C)
    mutating func popLast() -> Element?
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func replaceRange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
    mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Element>(_ newElements: S)
    func dropLast(_ n: Int) -> ArraySlice<Element>
    func suffix(_ maxLength: Int) -> ArraySlice<Element>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> ArraySlice<Element>
    func prefix(_ maxLength: Int) -> ArraySlice<Element>
    func prefix(upTo end: Int) -> ArraySlice<Element>
    func suffix(from start: Int) -> ArraySlice<Element>
    func prefix(through position: Int) -> ArraySlice<Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<Element>]
    typealias Generator = IndexingIterator<Array<Element>>
    func generate() -> IndexingIterator<Array<Element>>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<Element>]
    var last: Element? { get }
    func index(where predicate: (Element) throws -> Bool) rethrows -> Int?
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    mutating func sort(by areInIncreasingOrder: (Element, Element) -> Bool)
    subscript(_ bounds: ClosedRange<Int>) -> ArraySlice<Element> { get }
    subscript(_ bounds: CountableRange<Int>) -> ArraySlice<Element> { get }
    subscript(_ bounds: CountableClosedRange<Int>) -> ArraySlice<Element> { get }
    subscript(_ bounds: ClosedRange<Int>) -> ArraySlice<Element>
    subscript(_ bounds: CountableRange<Int>) -> ArraySlice<Element>
    subscript(_ bounds: CountableClosedRange<Int>) -> ArraySlice<Element>
    mutating func partition(isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    mutating func partition(_ range: Range<Int>, isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    mutating func sortInPlace(_ isOrderedBefore: (Element, Element) -> Bool)
    func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Int?
    var lazy: LazySequence<Array<Element>> { get }
    subscript(_ bounds: Range<Int>) -> MutableSlice<Array<Element>>
    var indices: CountableRange<Int> { get }
    func reversed() -> ReversedRandomAccessCollection<Array<Element>>
    func reverse() -> ReversedRandomAccessCollection<Array<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> ArraySlice<Element>
    func dropLast() -> ArraySlice<Element>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<Element>]
    func enumerated() -> EnumeratedSequence<Array<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<Array<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension Array : CVarArg {
}
extension Array {
}
extension Array {
    func makeIterator() -> IndexingIterator<Array<Element>>
}
extension Array {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension Array {
    var lazy: LazyBidirectionalCollection<Array<Element>> { get }
}
extension Array {
    var lazy: LazyCollection<Array<Element>> { get }
}
extension Array {
    var lazy: LazyRandomAccessCollection<Array<Element>> { get }
}
extension Array {
    func formIndex(_ i: inout Int, offsetBy n: Int)
    func formIndex(_ i: inout Int, offsetBy n: Int, limitedBy limit: Int) -> Bool
}
extension Array : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Array : RangeReplaceableCollection {
    init()
    init<S : Sequence where S.Iterator.Element == Element>(_ s: S)
    init(repeating repeatedValue: Element, count count: Int)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func append<S : Sequence where S.Iterator.Element == Element>(contentsOf newElements: S)
    mutating func append<C : Collection where C.Iterator.Element == Element>(contentsOf newElements: C)
    mutating func insert(_ newElement: Element, at i: Int)
    mutating func remove(at index: Int) -> Element
    mutating func removeAll(keepingCapacity keepCapacity: Bool = default)
}
extension Array : ExpressibleByArrayLiteral {
    init(arrayLiteral elements: Element...)
}
extension Array : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Array where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [ArraySlice<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [ArraySlice<Element>]
    func index(of element: Element) -> Int?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension Array where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension Array where Element : Collection {
    func joined() -> FlattenCollection<Array<Element>>
    func flatten() -> FlattenCollection<Array<Element>>
}
extension Array where Element : BidirectionalCollection {
    func joined() -> FlattenBidirectionalCollection<Array<Element>>
    func flatten() -> FlattenBidirectionalCollection<Array<Element>>
}
extension Array where Element : Sequence {
    func joined() -> FlattenSequence<Array<Element>>
    func flatten() -> FlattenSequence<Array<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<Array<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<Array<Element>>
}
extension Array where Element : Comparable {
    func sorted() -> [Element]
    func sorted() -> [Element]
    mutating func sort()
    mutating func partition() -> Int
    mutating func partition(_ range: Range<Int>) -> Int
    func sort() -> [Element]
    mutating func sortInPlace()
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
CVarArg, CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, ExpressibleByArrayLiteral, MutableCollection, RandomAccessCollection, RangeReplaceableCollection

Declaration
From
subscript (_ index: Int) -> Element
To
subscript(_ index: Int) -> Element

Modified Array.subscript(_: Range<Int>) -> ArraySlice<Element>
Declaration
From
subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
To
subscript(_ bounds: Range<Int>) -> ArraySlice<Element>

Modified Array.withUnsafeBufferPointer<R>(_: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
Declaration
From
func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
To
func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

Modified Array.withUnsafeMutableBufferPointer<R>(_: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
Declaration
From
mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
To
mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

DeclarationProtocols
From
struct ArraySlice<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ index: Int) -> Element
    subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
}
extension ArraySlice : ArrayLiteralConvertible {
    init(arrayLiteral elements: Element...)
}
extension ArraySlice : _ArrayType {
    init()
    init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: Element)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S)
    mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C)
    mutating func removeLast() -> Element
    mutating func insert(_ newElement: Element, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> ArraySlice<Element>
}
extension ArraySlice : _Reflectable {
}
extension ArraySlice : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension ArraySlice {
    func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension ArraySlice {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
}
ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, MutableCollectionType
To
struct ArraySlice<Element> : RandomAccessCollection, MutableCollection {
    typealias Index = Int
    typealias Iterator = IndexingIterator<ArraySlice<Element>>
    var startIndex: Int { get }
    var endIndex: Int { get }
    func index(after i: Int) -> Int
    func formIndex(after i: inout Int)
    func index(before i: Int) -> Int
    func formIndex(before i: inout Int)
    func index(_ i: Int, offsetBy n: Int) -> Int
    func index(_ i: Int, offsetBy n: Int, limitedBy limit: Int) -> Int?
    func distance(from start: Int, to end: Int) -> Int
    typealias Indices = CountableRange<Int>
    subscript(_ index: Int) -> Element
    subscript(_ bounds: Range<Int>) -> ArraySlice<Element>
    func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subrange: Range<Int>, with newElements: C)
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func replaceRange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
    mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Element>(_ newElements: S)
    mutating func popLast() -> Element?
    mutating func removeLast() -> Element
    mutating func removeLast(_ n: Int)
    func dropLast(_ n: Int) -> ArraySlice<Element>
    func suffix(_ maxLength: Int) -> ArraySlice<Element>
    mutating func popFirst() -> Element?
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> ArraySlice<Element>
    func prefix(_ maxLength: Int) -> ArraySlice<Element>
    func prefix(upTo end: Int) -> ArraySlice<Element>
    func suffix(from start: Int) -> ArraySlice<Element>
    func prefix(through position: Int) -> ArraySlice<Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<Element>]
    mutating func removeFirst() -> Element
    mutating func removeFirst(_ n: Int)
    typealias Generator = IndexingIterator<ArraySlice<Element>>
    func generate() -> IndexingIterator<ArraySlice<Element>>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<Element>]
    var last: Element? { get }
    func index(where predicate: (Element) throws -> Bool) rethrows -> Int?
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    mutating func sort(by areInIncreasingOrder: (Element, Element) -> Bool)
    subscript(_ bounds: ClosedRange<Int>) -> ArraySlice<Element> { get }
    subscript(_ bounds: CountableRange<Int>) -> ArraySlice<Element> { get }
    subscript(_ bounds: CountableClosedRange<Int>) -> ArraySlice<Element> { get }
    subscript(_ bounds: ClosedRange<Int>) -> ArraySlice<Element>
    subscript(_ bounds: CountableRange<Int>) -> ArraySlice<Element>
    subscript(_ bounds: CountableClosedRange<Int>) -> ArraySlice<Element>
    mutating func partition(isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    mutating func partition(_ range: Range<Int>, isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    mutating func sortInPlace(_ isOrderedBefore: (Element, Element) -> Bool)
    func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Int?
    var lazy: LazySequence<ArraySlice<Element>> { get }
    subscript(_ bounds: Range<Int>) -> MutableSlice<ArraySlice<Element>>
    var indices: CountableRange<Int> { get }
    func reversed() -> ReversedRandomAccessCollection<ArraySlice<Element>>
    func reverse() -> ReversedRandomAccessCollection<ArraySlice<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> ArraySlice<Element>
    func dropLast() -> ArraySlice<Element>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<Element>]
    func enumerated() -> EnumeratedSequence<ArraySlice<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<ArraySlice<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension ArraySlice {
    func makeIterator() -> IndexingIterator<ArraySlice<Element>>
}
extension ArraySlice {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension ArraySlice {
    var lazy: LazyBidirectionalCollection<ArraySlice<Element>> { get }
}
extension ArraySlice {
    var lazy: LazyCollection<ArraySlice<Element>> { get }
}
extension ArraySlice {
    var lazy: LazyRandomAccessCollection<ArraySlice<Element>> { get }
}
extension ArraySlice {
    func formIndex(_ i: inout Int, offsetBy n: Int)
    func formIndex(_ i: inout Int, offsetBy n: Int, limitedBy limit: Int) -> Bool
}
extension ArraySlice : CustomReflectable {
    var customMirror: Mirror { get }
}
extension ArraySlice : RangeReplaceableCollection {
    init()
    init<S : Sequence where S.Iterator.Element == Element>(_ s: S)
    init(repeating repeatedValue: Element, count count: Int)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func append<S : Sequence where S.Iterator.Element == Element>(contentsOf newElements: S)
    mutating func append<C : Collection where C.Iterator.Element == Element>(contentsOf newElements: C)
    mutating func insert(_ newElement: Element, at i: Int)
    mutating func remove(at index: Int) -> Element
    mutating func removeAll(keepingCapacity keepCapacity: Bool = default)
}
extension ArraySlice : ExpressibleByArrayLiteral {
    init(arrayLiteral elements: Element...)
}
extension ArraySlice : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension ArraySlice where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [ArraySlice<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [ArraySlice<Element>]
    func index(of element: Element) -> Int?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension ArraySlice where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension ArraySlice where Element : Collection {
    func joined() -> FlattenCollection<ArraySlice<Element>>
    func flatten() -> FlattenCollection<ArraySlice<Element>>
}
extension ArraySlice where Element : BidirectionalCollection {
    func joined() -> FlattenBidirectionalCollection<ArraySlice<Element>>
    func flatten() -> FlattenBidirectionalCollection<ArraySlice<Element>>
}
extension ArraySlice where Element : Sequence {
    func joined() -> FlattenSequence<ArraySlice<Element>>
    func flatten() -> FlattenSequence<ArraySlice<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<ArraySlice<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<ArraySlice<Element>>
}
extension ArraySlice where Element : Comparable {
    func sorted() -> [Element]
    func sorted() -> [Element]
    mutating func sort()
    mutating func partition() -> Int
    mutating func partition(_ range: Range<Int>) -> Int
    func sort() -> [Element]
    mutating func sortInPlace()
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, ExpressibleByArrayLiteral, MutableCollection, RandomAccessCollection, RangeReplaceableCollection

Modified ArraySlice.subscript(_: Range<Int>) -> ArraySlice<Element>
Declaration
From
subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
To
subscript(_ bounds: Range<Int>) -> ArraySlice<Element>

Declaration
From
subscript (_ index: Int) -> Element
To
subscript(_ index: Int) -> Element

Modified ArraySlice.withUnsafeBufferPointer<R>(_: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
Declaration
From
func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
To
func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

Modified ArraySlice.withUnsafeMutableBufferPointer<R>(_: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
Declaration
From
mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
To
mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

DeclarationProtocolsGenerics[Parameters]
From
struct AutoreleasingUnsafeMutablePointer<Memory> : Equatable, NilLiteralConvertible, _PointerType {
    typealias T = Memory
    var memory: Memory { get nonmutating set }
    subscript (_ i: Int) -> Memory { get }
    init(nilLiteral nilLiteral: ())
    init()
    init<U>(_ ptr: UnsafeMutablePointer<U>)
}
extension AutoreleasingUnsafeMutablePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension AutoreleasingUnsafeMutablePointer : CVarArgType {
}
CVarArgType, CustomDebugStringConvertible, Equatable, NilLiteralConvertibleMemory
To
struct AutoreleasingUnsafeMutablePointer<Pointee> : Equatable {
    var pointee: Pointee { get nonmutating set }
    subscript(_ i: Int) -> Pointee { get }
    init<U>(_ from: UnsafeMutablePointer<U>)
    init?<U>(_ from: UnsafeMutablePointer<U>?)
    typealias Memory = Pointee
    var memory: Pointee { get }
    init()
}
extension AutoreleasingUnsafeMutablePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension AutoreleasingUnsafeMutablePointer : CVarArg {
}
CVarArg, CustomDebugStringConvertible, EquatablePointee

Declaration
From
subscript (_ i: Int) -> Memory { get }
To
subscript(_ i: Int) -> Pointee { get }

Modified Bool [struct]
DeclarationProtocols
From
struct Bool {
    init()
}
extension Bool : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Bool : BooleanLiteralConvertible {
    init(_builtinBooleanLiteral value: Builtin.Int1)
    init(booleanLiteral value: Bool)
}
extension Bool : BooleanType {
    var boolValue: Bool { get }
    init<T : BooleanType>(_ value: T)
}
extension Bool : CustomStringConvertible {
    var description: String { get }
}
extension Bool : Equatable, Hashable {
    var hashValue: Int { get }
}
extension Bool : _Reflectable {
}
BooleanLiteralConvertible, BooleanType, CustomStringConvertible, Equatable, Hashable
To
struct Bool {
    init()
    init(_ value: Bool)
    prefix static func !(_ a: Bool) -> Bool
    static func &&(_ lhs: Bool, _ rhs: @autoclosure () throws -> Bool) rethrows -> Bool
    static func ||(_ lhs: Bool, _ rhs: @autoclosure () throws -> Bool) rethrows -> Bool
}
extension Bool {
    init(_ number: NSNumber)
}
extension Bool : CustomStringConvertible {
    var description: String { get }
}
extension Bool : LosslessStringConvertible {
    init?(_ description: String)
}
extension Bool : ExpressibleByBooleanLiteral {
    init(booleanLiteral value: Bool)
}
extension Bool : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Bool : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension Bool : Equatable, Hashable {
    var hashValue: Int { get }
    static func ==(_ lhs: Bool, _ rhs: Bool) -> Bool
}
CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, ExpressibleByBooleanLiteral, Hashable, LosslessStringConvertible

DeclarationProtocols
From
struct Character : ExtendedGraphemeClusterLiteralConvertible, Equatable, Hashable, Comparable {
    init(_ scalar: UnicodeScalar)
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
    init(unicodeScalarLiteral value: Character)
    init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    init(extendedGraphemeClusterLiteral value: Character)
    init(_ s: String)
    var hashValue: Int { get }
}
extension Character : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Character : _Reflectable {
}
extension Character : Streamable {
    func writeTo<Target : OutputStreamType>(inout _ target: Target)
}
Comparable, CustomDebugStringConvertible, Equatable, ExtendedGraphemeClusterLiteralConvertible, Hashable, Streamable
To
struct Character : ExpressibleByExtendedGraphemeClusterLiteral, Hashable {
    init(_ scalar: UnicodeScalar)
    init(unicodeScalarLiteral value: Character)
    init(extendedGraphemeClusterLiteral value: Character)
    init(_ s: String)
    var hashValue: Int { get }
}
extension Character : CustomStringConvertible {
    var description: String { get }
}
extension Character : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Character : Equatable {
    static func ==(_ lhs: Character, _ rhs: Character) -> Bool
}
extension Character : Comparable {
    static func <(_ lhs: Character, _ rhs: Character) -> Bool
}
extension Character : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Character : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension Character : TextOutputStreamable {
    func write<Target : TextOutputStream>(to target: inout Target)
}
Comparable, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, ExpressibleByExtendedGraphemeClusterLiteral, Hashable, TextOutputStreamable

DeclarationProtocols
From
struct CollectionOfOne<Element> : CollectionType {
    typealias T = Element
    typealias Index = Bit
    init(_ element: Element)
    var startIndex: Index { get }
    var endIndex: Index { get }
    func generate() -> GeneratorOfOne<Element>
    subscript (_ position: Index) -> Element { get }
    var count: Int { get }
}
extension CollectionOfOne : _Reflectable {
}
CollectionType
To
struct CollectionOfOne<Element> : MutableCollection, RandomAccessCollection {
    init(_ element: Element)
    typealias Index = Int
    var startIndex: Int { get }
    var endIndex: Int { get }
    func index(after i: Int) -> Int
    func index(before i: Int) -> Int
    typealias Indices = CountableRange<Int>
    func makeIterator() -> IteratorOverOne<Element>
    subscript(_ position: Int) -> Element
    subscript(_ bounds: Range<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    var count: Int { get }
    func dropLast(_ n: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    func suffix(_ maxLength: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    func prefix(_ maxLength: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    func prefix(upTo end: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    func suffix(from start: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    func prefix(through position: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<CollectionOfOne<Element>>]
    typealias Generator = IteratorOverOne<Element>
    func generate() -> IteratorOverOne<Element>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<CollectionOfOne<Element>>]
    var last: Element? { get }
    func index(where predicate: (Element) throws -> Bool) rethrows -> Int?
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    mutating func sort(by areInIncreasingOrder: (Element, Element) -> Bool)
    subscript(_ bounds: ClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>> { get }
    subscript(_ bounds: CountableRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>> { get }
    subscript(_ bounds: CountableClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>> { get }
    subscript(_ bounds: ClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    subscript(_ bounds: CountableRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    subscript(_ bounds: CountableClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    mutating func partition(isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    mutating func partition(_ range: Range<Int>, isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    mutating func sortInPlace(_ isOrderedBefore: (Element, Element) -> Bool)
    func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Int?
    var lazy: LazySequence<CollectionOfOne<Element>> { get }
    subscript(_ bounds: Range<Int>) -> MutableSlice<CollectionOfOne<Element>>
    var indices: CountableRange<Int> { get }
    func index(_ i: Int, offsetBy n: Int) -> Int
    func distance(from start: Int, to end: Int) -> Int
    func reversed() -> ReversedRandomAccessCollection<CollectionOfOne<Element>>
    func reverse() -> ReversedRandomAccessCollection<CollectionOfOne<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    func dropLast() -> MutableRandomAccessSlice<CollectionOfOne<Element>>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<CollectionOfOne<Element>>]
    func enumerated() -> EnumeratedSequence<CollectionOfOne<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<CollectionOfOne<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension CollectionOfOne {
    var lazy: LazyRandomAccessCollection<CollectionOfOne<Element>> { get }
}
extension CollectionOfOne {
    func index(_ i: Int, offsetBy n: Int, limitedBy limit: Int) -> Int?
}
extension CollectionOfOne {
    var lazy: LazyBidirectionalCollection<CollectionOfOne<Element>> { get }
}
extension CollectionOfOne {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension CollectionOfOne {
    func formIndex(before i: inout Int)
}
extension CollectionOfOne {
    func formIndex(after i: inout Int)
    func formIndex(_ i: inout Int, offsetBy n: Int)
    func formIndex(_ i: inout Int, offsetBy n: Int, limitedBy limit: Int) -> Bool
}
extension CollectionOfOne {
    var lazy: LazyCollection<CollectionOfOne<Element>> { get }
}
extension CollectionOfOne : CustomReflectable {
    var customMirror: Mirror { get }
}
extension CollectionOfOne : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension CollectionOfOne where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension CollectionOfOne where Element : Collection {
    func joined() -> FlattenCollection<CollectionOfOne<Element>>
    func flatten() -> FlattenCollection<CollectionOfOne<Element>>
}
extension CollectionOfOne where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [MutableRandomAccessSlice<CollectionOfOne<Element>>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [MutableRandomAccessSlice<CollectionOfOne<Element>>]
    func index(of element: Element) -> Int?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension CollectionOfOne where Element : BidirectionalCollection {
    func joined() -> FlattenBidirectionalCollection<CollectionOfOne<Element>>
    func flatten() -> FlattenBidirectionalCollection<CollectionOfOne<Element>>
}
extension CollectionOfOne where Element : Sequence {
    func joined() -> FlattenSequence<CollectionOfOne<Element>>
    func flatten() -> FlattenSequence<CollectionOfOne<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<CollectionOfOne<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<CollectionOfOne<Element>>
}
extension CollectionOfOne where Element : Comparable {
    func sorted() -> [Element]
    func sorted() -> [Element]
    mutating func sort()
    mutating func partition() -> Int
    mutating func partition(_ range: Range<Int>) -> Int
    func sort() -> [Element]
    mutating func sortInPlace()
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
CustomDebugStringConvertible, CustomReflectable, MutableCollection, RandomAccessCollection

Declaration
From
var endIndex: Index { get }
To
var endIndex: Int { get }

Declaration
From
var startIndex: Index { get }
To
var startIndex: Int { get }

Modified Comparable
Declaration
From
protocol Comparable : Equatable {
    @warn_unused_result
    func <(_ lhs: Self, _ rhs: Self) -> Bool
    @warn_unused_result
    func <=(_ lhs: Self, _ rhs: Self) -> Bool
    @warn_unused_result
    func >=(_ lhs: Self, _ rhs: Self) -> Bool
    @warn_unused_result
    func >(_ lhs: Self, _ rhs: Self) -> Bool
}
To
protocol Comparable : Equatable {
    static func <(_ lhs: Self, _ rhs: Self) -> Bool
    static func <=(_ lhs: Self, _ rhs: Self) -> Bool
    static func >=(_ lhs: Self, _ rhs: Self) -> Bool
    static func >(_ lhs: Self, _ rhs: Self) -> Bool
}

Declaration
From
@warn_unused_result
    func <(_ lhs: Self, _ rhs: Self) -> Bool
To
static func <(_ lhs: Self, _ rhs: Self) -> Bool

Modified Comparable.<=(_: Self, _: Self) -> Bool
Declaration
From
@warn_unused_result
    func <=(_ lhs: Self, _ rhs: Self) -> Bool
To
static func <=(_ lhs: Self, _ rhs: Self) -> Bool

Modified Comparable.>(_: Self, _: Self) -> Bool
Declaration
From
@warn_unused_result
    func >(_ lhs: Self, _ rhs: Self) -> Bool
To
static func >(_ lhs: Self, _ rhs: Self) -> Bool

Modified Comparable.>=(_: Self, _: Self) -> Bool
Declaration
From
@warn_unused_result
    func >=(_ lhs: Self, _ rhs: Self) -> Bool
To
static func >=(_ lhs: Self, _ rhs: Self) -> Bool

DeclarationProtocols
From
struct ContiguousArray<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ index: Int) -> Element
    subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
}
extension ContiguousArray : ArrayLiteralConvertible {
    init(arrayLiteral elements: Element...)
}
extension ContiguousArray : _ArrayType {
    init()
    init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: Element)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S)
    mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C)
    mutating func removeLast() -> Element
    mutating func insert(_ newElement: Element, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> ContiguousArray<Element>
}
extension ContiguousArray : _Reflectable {
}
extension ContiguousArray : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension ContiguousArray {
    func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension ContiguousArray {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
}
extension ContiguousArray {
    mutating func popLast() -> Element?
}
ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, MutableCollectionType
To
struct ContiguousArray<Element> : RandomAccessCollection, MutableCollection {
    typealias Index = Int
    typealias Iterator = IndexingIterator<ContiguousArray<Element>>
    var startIndex: Int { get }
    var endIndex: Int { get }
    func index(after i: Int) -> Int
    func formIndex(after i: inout Int)
    func index(before i: Int) -> Int
    func formIndex(before i: inout Int)
    func index(_ i: Int, offsetBy n: Int) -> Int
    func index(_ i: Int, offsetBy n: Int, limitedBy limit: Int) -> Int?
    func distance(from start: Int, to end: Int) -> Int
    typealias Indices = CountableRange<Int>
    subscript(_ index: Int) -> Element
    subscript(_ bounds: Range<Int>) -> ArraySlice<Element>
    func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subrange: Range<Int>, with newElements: C)
    mutating func popLast() -> Element?
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func replaceRange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
    mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Element>(_ newElements: S)
    func dropLast(_ n: Int) -> ArraySlice<Element>
    func suffix(_ maxLength: Int) -> ArraySlice<Element>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> ArraySlice<Element>
    func prefix(_ maxLength: Int) -> ArraySlice<Element>
    func prefix(upTo end: Int) -> ArraySlice<Element>
    func suffix(from start: Int) -> ArraySlice<Element>
    func prefix(through position: Int) -> ArraySlice<Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<Element>]
    typealias Generator = IndexingIterator<ContiguousArray<Element>>
    func generate() -> IndexingIterator<ContiguousArray<Element>>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<Element>]
    var last: Element? { get }
    func index(where predicate: (Element) throws -> Bool) rethrows -> Int?
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    mutating func sort(by areInIncreasingOrder: (Element, Element) -> Bool)
    subscript(_ bounds: ClosedRange<Int>) -> ArraySlice<Element> { get }
    subscript(_ bounds: CountableRange<Int>) -> ArraySlice<Element> { get }
    subscript(_ bounds: CountableClosedRange<Int>) -> ArraySlice<Element> { get }
    subscript(_ bounds: ClosedRange<Int>) -> ArraySlice<Element>
    subscript(_ bounds: CountableRange<Int>) -> ArraySlice<Element>
    subscript(_ bounds: CountableClosedRange<Int>) -> ArraySlice<Element>
    mutating func partition(isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    mutating func partition(_ range: Range<Int>, isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    mutating func sortInPlace(_ isOrderedBefore: (Element, Element) -> Bool)
    func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Int?
    var lazy: LazySequence<ContiguousArray<Element>> { get }
    subscript(_ bounds: Range<Int>) -> MutableSlice<ContiguousArray<Element>>
    var indices: CountableRange<Int> { get }
    func reversed() -> ReversedRandomAccessCollection<ContiguousArray<Element>>
    func reverse() -> ReversedRandomAccessCollection<ContiguousArray<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> ArraySlice<Element>
    func dropLast() -> ArraySlice<Element>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<Element>]
    func enumerated() -> EnumeratedSequence<ContiguousArray<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<ContiguousArray<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension ContiguousArray {
    func makeIterator() -> IndexingIterator<ContiguousArray<Element>>
}
extension ContiguousArray {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension ContiguousArray {
    var lazy: LazyBidirectionalCollection<ContiguousArray<Element>> { get }
}
extension ContiguousArray {
    var lazy: LazyCollection<ContiguousArray<Element>> { get }
}
extension ContiguousArray {
    var lazy: LazyRandomAccessCollection<ContiguousArray<Element>> { get }
}
extension ContiguousArray {
    func formIndex(_ i: inout Int, offsetBy n: Int)
    func formIndex(_ i: inout Int, offsetBy n: Int, limitedBy limit: Int) -> Bool
}
extension ContiguousArray : CustomReflectable {
    var customMirror: Mirror { get }
}
extension ContiguousArray : RangeReplaceableCollection {
    init()
    init<S : Sequence where S.Iterator.Element == Element>(_ s: S)
    init(repeating repeatedValue: Element, count count: Int)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func append<S : Sequence where S.Iterator.Element == Element>(contentsOf newElements: S)
    mutating func append<C : Collection where C.Iterator.Element == Element>(contentsOf newElements: C)
    mutating func insert(_ newElement: Element, at i: Int)
    mutating func remove(at index: Int) -> Element
    mutating func removeAll(keepingCapacity keepCapacity: Bool = default)
}
extension ContiguousArray : ExpressibleByArrayLiteral {
    init(arrayLiteral elements: Element...)
}
extension ContiguousArray : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension ContiguousArray where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [ArraySlice<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [ArraySlice<Element>]
    func index(of element: Element) -> Int?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension ContiguousArray where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension ContiguousArray where Element : Collection {
    func joined() -> FlattenCollection<ContiguousArray<Element>>
    func flatten() -> FlattenCollection<ContiguousArray<Element>>
}
extension ContiguousArray where Element : BidirectionalCollection {
    func joined() -> FlattenBidirectionalCollection<ContiguousArray<Element>>
    func flatten() -> FlattenBidirectionalCollection<ContiguousArray<Element>>
}
extension ContiguousArray where Element : Sequence {
    func joined() -> FlattenSequence<ContiguousArray<Element>>
    func flatten() -> FlattenSequence<ContiguousArray<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<ContiguousArray<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<ContiguousArray<Element>>
}
extension ContiguousArray where Element : Comparable {
    func sorted() -> [Element]
    func sorted() -> [Element]
    mutating func sort()
    mutating func partition() -> Int
    mutating func partition(_ range: Range<Int>) -> Int
    func sort() -> [Element]
    mutating func sortInPlace()
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, ExpressibleByArrayLiteral, MutableCollection, RandomAccessCollection, RangeReplaceableCollection

Modified ContiguousArray.subscript(_: Range<Int>) -> ArraySlice<Element>
Declaration
From
subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
To
subscript(_ bounds: Range<Int>) -> ArraySlice<Element>

Declaration
From
subscript (_ index: Int) -> Element
To
subscript(_ index: Int) -> Element

Modified ContiguousArray.withUnsafeBufferPointer<R>(_: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
Declaration
From
func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
To
func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

Modified ContiguousArray.withUnsafeMutableBufferPointer<R>(_: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
Declaration
From
mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
To
mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

Declaration
From
protocol CustomPlaygroundQuickLookable {
    @warn_unused_result
    func customPlaygroundQuickLook() -> PlaygroundQuickLook
}
To
protocol CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}

Declaration
From
protocol CustomReflectable {
    @warn_unused_result
    func customMirror() -> Mirror
}
To
protocol CustomReflectable {
    var customMirror: Mirror { get }
}

Declaration
From
struct CVaListPointer {
    init(_fromUnsafeMutablePointer from: UnsafeMutablePointer<Void>)
}
extension CVaListPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
To
struct CVaListPointer {
}
extension CVaListPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}

DeclarationProtocols
From
struct Dictionary<Key : Hashable, Value> : CollectionType, DictionaryLiteralConvertible {
    typealias Element = (Key, Value)
    typealias Index = DictionaryIndex<Key, Value>
    init()
    init(minimumCapacity minimumCapacity: Int)
    var startIndex: DictionaryIndex<Key, Value> { get }
    var endIndex: DictionaryIndex<Key, Value> { get }
    @warn_unused_result
    func indexForKey(_ key: Key) -> DictionaryIndex<Key, Value>?
    subscript (_ position: DictionaryIndex<Key, Value>) -> (Key, Value) { get }
    subscript (_ key: Key) -> Value?
    mutating func updateValue(_ value: Value, forKey key: Key) -> Value?
    mutating func removeAtIndex(_ index: DictionaryIndex<Key, Value>) -> (Key, Value)
    mutating func removeValueForKey(_ key: Key) -> Value?
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    var count: Int { get }
    func generate() -> DictionaryGenerator<Key, Value>
    init(dictionaryLiteral elements: (Key, Value)...)
    var keys: LazyMapCollection<[Key : Value], Key> { get }
    var values: LazyMapCollection<[Key : Value], Value> { get }
    var isEmpty: Bool { get }
}
extension Dictionary : _ObjectiveCBridgeable {
}
extension Dictionary : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Dictionary : _Reflectable {
}
extension Dictionary {
    mutating func popFirst() -> (Key, Value)?
}
CollectionType, CustomDebugStringConvertible, CustomStringConvertible, DictionaryLiteralConvertible
To
struct Dictionary<Key : Hashable, Value> : Collection, ExpressibleByDictionaryLiteral {
    typealias Element = (key: Key, value: Value)
    typealias Index = DictionaryIndex<Key, Value>
    init()
    init(minimumCapacity minimumCapacity: Int)
    var startIndex: DictionaryIndex<Key, Value> { get }
    var endIndex: DictionaryIndex<Key, Value> { get }
    func index(after i: DictionaryIndex<Key, Value>) -> DictionaryIndex<Key, Value>
    func index(forKey key: Key) -> DictionaryIndex<Key, Value>?
    subscript(_ position: DictionaryIndex<Key, Value>) -> (key: Key, value: Value) { get }
    subscript(_ key: Key) -> Value?
    mutating func updateValue(_ value: Value, forKey key: Key) -> Value?
    mutating func remove(at index: DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
    mutating func removeValue(forKey key: Key) -> Value?
    mutating func removeAll(keepingCapacity keepCapacity: Bool = default)
    var count: Int { get }
    func makeIterator() -> DictionaryIterator<Key, Value>
    init(dictionaryLiteral elements: (Key, Value)...)
    var keys: LazyMapCollection<[Key : Value], Key> { get }
    var values: LazyMapCollection<[Key : Value], Value> { get }
    var isEmpty: Bool { get }
    mutating func popFirst() -> (key: Key, value: Value)?
    mutating func removeAtIndex(_ index: DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
    func indexForKey(_ key: Key) -> DictionaryIndex<Key, Value>?
    mutating func removeValueForKey(_ key: Key) -> Value?
    func generate() -> DictionaryIterator<Key, Value>
    func map<T>(_ transform: (Key, Value) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> Slice<Dictionary<Key, Value>>
    func dropLast(_ n: Int) -> Slice<Dictionary<Key, Value>>
    func prefix(_ maxLength: Int) -> Slice<Dictionary<Key, Value>>
    func suffix(_ maxLength: Int) -> Slice<Dictionary<Key, Value>>
    func prefix(upTo end: DictionaryIndex<Key, Value>) -> Slice<Dictionary<Key, Value>>
    func suffix(from start: DictionaryIndex<Key, Value>) -> Slice<Dictionary<Key, Value>>
    func prefix(through position: DictionaryIndex<Key, Value>) -> Slice<Dictionary<Key, Value>>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Key, Value) throws -> Bool) rethrows -> [Slice<Dictionary<Key, Value>>]
    typealias Generator = DictionaryIterator<Key, Value>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Key, Value) throws -> Bool) rethrows -> [Slice<Dictionary<Key, Value>>]
    func index(where predicate: (Key, Value) throws -> Bool) rethrows -> DictionaryIndex<Key, Value>?
    func sorted(by areInIncreasingOrder: ((key: Key, value: Value), (key: Key, value: Value)) -> Bool) -> [(key: Key, value: Value)]
    subscript(_ bounds: ClosedRange<DictionaryIndex<Key, Value>>) -> Slice<Dictionary<Key, Value>> { get }
    func sort(_ isOrderedBefore: ((key: Key, value: Value), (key: Key, value: Value)) -> Bool) -> [(key: Key, value: Value)]
    func indexOf(_ predicate: (Key, Value) throws -> Bool) rethrows -> DictionaryIndex<Key, Value>?
    var indices: DefaultIndices<Dictionary<Key, Value>> { get }
    var lazy: LazySequence<Dictionary<Key, Value>> { get }
    func map<T>(_ transform: (Key, Value) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Key, Value) throws -> Bool) rethrows -> [(key: Key, value: Value)]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Key, Value) throws -> Void) rethrows
    func first(where predicate: (Key, Value) throws -> Bool) rethrows -> (key: Key, value: Value)?
    func dropFirst() -> Slice<Dictionary<Key, Value>>
    func dropLast() -> Slice<Dictionary<Key, Value>>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Key, Value) throws -> Bool) rethrows -> [Slice<Dictionary<Key, Value>>]
    func enumerated() -> EnumeratedSequence<Dictionary<Key, Value>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> (key: Key, value: Value)?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> (key: Key, value: Value)?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (key: Key, value: Value)>(with possiblePrefix: PossiblePrefix, by areEquivalent: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (key: Key, value: Value)>(_ other: OtherSequence, by areEquivalent: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (key: Key, value: Value)>(_ other: OtherSequence, by areInIncreasingOrder: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Key, Value) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, (key: Key, value: Value)) throws -> Result) rethrows -> Result
    func reversed() -> [(key: Key, value: Value)]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Key, Value) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Key, Value) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<Dictionary<Key, Value>>
    func minElement(_ isOrderedBefore: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> (key: Key, value: Value)?
    func maxElement(_ isOrderedBefore: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> (key: Key, value: Value)?
    func reverse() -> [(key: Key, value: Value)]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (key: Key, value: Value)>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (key: Key, value: Value)>(_ other: OtherSequence, isEquivalent isEquivalent: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (key: Key, value: Value)>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Key, Value) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, (key: Key, value: Value)) throws -> Result) rethrows -> Result
}
extension Dictionary {
}
extension Dictionary : CVarArg {
}
extension Dictionary {
    subscript(_ bounds: Range<DictionaryIndex<Key, Value>>) -> Slice<Dictionary<Key, Value>> { get }
}
extension Dictionary {
    var isEmpty: Bool { get }
    var first: (key: Key, value: Value)? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension Dictionary {
    var lazy: LazyCollection<Dictionary<Key, Value>> { get }
}
extension Dictionary {
    func formIndex(after i: inout DictionaryIndex<Key, Value>)
    func index(_ i: DictionaryIndex<Key, Value>, offsetBy n: Int) -> DictionaryIndex<Key, Value>
    func index(_ i: DictionaryIndex<Key, Value>, offsetBy n: Int, limitedBy limit: DictionaryIndex<Key, Value>) -> DictionaryIndex<Key, Value>?
    func formIndex(_ i: inout DictionaryIndex<Key, Value>, offsetBy n: Int)
    func formIndex(_ i: inout DictionaryIndex<Key, Value>, offsetBy n: Int, limitedBy limit: DictionaryIndex<Key, Value>) -> Bool
    func distance(from start: DictionaryIndex<Key, Value>, to end: DictionaryIndex<Key, Value>) -> Int
}
extension Dictionary : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Dictionary : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Dictionary where Key : Equatable, Value : Equatable {
    static func ==(_ lhs: [Key : Value], _ rhs: [Key : Value]) -> Bool
    static func !=(_ lhs: [Key : Value], _ rhs: [Key : Value]) -> Bool
}
extension Dictionary where Key : _AnyHashableProtocol {
    subscript(_ key: _Hashable) -> Value?
    mutating func updateValue<ConcreteKey : Hashable>(_ value: Value, forKey key: ConcreteKey) -> Value?
    mutating func removeValue<ConcreteKey : Hashable>(forKey key: ConcreteKey) -> Value?
}
CVarArg, Collection, CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, ExpressibleByDictionaryLiteral

Modified Dictionary.subscript(_: Key) -> Value?
Declaration
From
subscript (_ key: Key) -> Value?
To
subscript(_ key: Key) -> Value?

Modified DictionaryIndex [struct]
DeclarationProtocols
From
struct DictionaryIndex<Key : Hashable, Value> : ForwardIndexType, Comparable {
    func successor() -> DictionaryIndex<Key, Value>
}
Comparable, ForwardIndexType
To
struct DictionaryIndex<Key : Hashable, Value> : Comparable {
    static func ==(_ lhs: DictionaryIndex<Key, Value>, _ rhs: DictionaryIndex<Key, Value>) -> Bool
    static func <(_ lhs: DictionaryIndex<Key, Value>, _ rhs: DictionaryIndex<Key, Value>) -> Bool
}
Comparable

DeclarationProtocols
From
struct DictionaryLiteral<Key, Value> : DictionaryLiteralConvertible {
    init(dictionaryLiteral elements: (Key, Value)...)
}
extension DictionaryLiteral : CollectionType {
    var startIndex: Int { get }
    var endIndex: Int { get }
    typealias Element = (Key, Value)
    subscript (_ position: Int) -> (Key, Value) { get }
}
CollectionType, DictionaryLiteralConvertible
To
struct DictionaryLiteral<Key, Value> : ExpressibleByDictionaryLiteral {
    init(dictionaryLiteral elements: (Key, Value)...)
}
extension DictionaryLiteral : RandomAccessCollection {
    typealias Indices = CountableRange<Int>
    var startIndex: Int { get }
    var endIndex: Int { get }
    typealias Element = (key: Key, value: Value)
    subscript(_ position: Int) -> (key: Key, value: Value) { get }
}
ExpressibleByDictionaryLiteral, RandomAccessCollection

DeclarationProtocols
From
struct Double {
    init()
    init(_bits v: Builtin.FPIEEE64)
    init(_ value: Double)
}
extension Double {
    init(_ value: CGFloat)
}
extension Double : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Double : CustomStringConvertible {
    var description: String { get }
}
extension Double : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Double : FloatingPointType {
    static var infinity: Double { get }
    static var NaN: Double { get }
    static var quietNaN: Double { get }
    var isSignMinus: Bool { get }
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignaling: Bool { get }
}
extension Double {
    var floatingPointClass: FloatingPointClassification { get }
}
extension Double : IntegerLiteralConvertible {
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
}
extension Double {
    init(_builtinFloatLiteral value: Builtin.FPIEEE64)
}
extension Double : FloatLiteralConvertible {
    init(floatLiteral value: Double)
}
extension Double : Comparable, Equatable {
}
extension Double : Hashable {
    var hashValue: Int { get }
}
extension Double : AbsoluteValuable {
    @warn_unused_result
    static func abs(_ x: Double) -> Double
}
extension Double {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
}
extension Double {
    init(_ other: Float)
}
extension Double : Strideable {
    func distanceTo(_ other: Double) -> Double
    func advancedBy(_ amount: Double) -> Double
}
extension Double {
    init?(_ text: String)
}
extension Double : _Reflectable {
}
extension Double : _CVarArgPassedAsDouble, _CVarArgAlignedType {
}
AbsoluteValuable, Comparable, CustomDebugStringConvertible, CustomStringConvertible, Equatable, FloatLiteralConvertible, FloatingPointType, Hashable, IntegerLiteralConvertible, Strideable
To
struct Double {
    init()
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
    init(_ other: Float)
    init?(exactly other: Float)
    init(_ other: Double)
    init?(exactly other: Double)
}
extension Double {
    init(_ value: CGFloat)
}
extension Double {
    init(_ number: NSNumber)
}
extension Double : CustomStringConvertible {
    var description: String { get }
}
extension Double : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Double : BinaryFloatingPoint {
    typealias Exponent = Int
    typealias RawSignificand = UInt64
    static var exponentBitCount: Int { get }
    static var significandBitCount: Int { get }
    var bitPattern: UInt64 { get }
    init(bitPattern bitPattern: UInt64)
    var sign: FloatingPointSign { get }
    var isSignMinus: Bool { get }
    var exponentBitPattern: UInt { get }
    var significandBitPattern: UInt64 { get }
    init(sign sign: FloatingPointSign, exponentBitPattern exponentBitPattern: UInt, significandBitPattern significandBitPattern: UInt64)
    var isCanonical: Bool { get }
    static var infinity: Double { get }
    static var nan: Double { get }
    static var signalingNaN: Double { get }
    static var quietNaN: Double { get }
    static var greatestFiniteMagnitude: Double { get }
    static var pi: Double { get }
    var ulp: Double { get }
    static var leastNormalMagnitude: Double { get }
    static var leastNonzeroMagnitude: Double { get }
    var exponent: Int { get }
    var significand: Double { get }
    init(sign sign: FloatingPointSign, exponent exponent: Int, significand significand: Double)
    init(nan payload: Double.RawSignificand, signaling signaling: Bool)
    var nextUp: Double { get }
    mutating func round(_ rule: FloatingPointRoundingRule)
    mutating func negate()
    mutating func add(_ other: Double)
    mutating func subtract(_ other: Double)
    mutating func multiply(by other: Double)
    mutating func divide(by other: Double)
    mutating func formRemainder(dividingBy other: Double)
    mutating func formTruncatingRemainder(dividingBy other: Double)
    mutating func formSquareRoot()
    mutating func addProduct(_ lhs: Double, _ rhs: Double)
    func isEqual(to other: Double) -> Bool
    func isLess(than other: Double) -> Bool
    func isLessThanOrEqualTo(_ other: Double) -> Bool
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignalingNaN: Bool { get }
    var binade: Double { get }
    var significandWidth: Int { get }
    init(floatLiteral value: Double)
}
extension Double : ExpressibleByIntegerLiteral {
    init(integerLiteral value: Int64)
}
extension Double : LosslessStringConvertible {
    init?(_ text: String)
}
extension Double : Hashable {
    var hashValue: Int { get }
}
extension Double : AbsoluteValuable {
    static func abs(_ x: Double) -> Double
}
extension Double : Strideable {
    func distance(to other: Double) -> Double
    func advanced(by amount: Double) -> Double
}
extension Double : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Double : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
AbsoluteValuable, BinaryFloatingPoint, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, ExpressibleByIntegerLiteral, Hashable, LosslessStringConvertible, Strideable

Modified Double.abs(_: Double) -> Double [static]
Declaration
From
@warn_unused_result
    static func abs(_ x: Double) -> Double
To
static func abs(_ x: Double) -> Double

DeclarationProtocols
From
struct EmptyCollection<Element> : CollectionType {
    typealias T = Element
    typealias Index = Int
    init()
    var startIndex: Index { get }
    var endIndex: Index { get }
    func generate() -> EmptyGenerator<Element>
    subscript (_ position: Index) -> Element { get }
    var count: Int { get }
}
extension EmptyCollection : _Reflectable {
}
CollectionType
To
struct EmptyCollection<Element> : RandomAccessCollection, MutableCollection {
    typealias Index = Int
    typealias IndexDistance = Int
    typealias SubSequence = EmptyCollection<Element>
    init()
    var startIndex: EmptyCollection.Index { get }
    var endIndex: EmptyCollection.Index { get }
    func index(after i: EmptyCollection.Index) -> EmptyCollection.Index
    func index(before i: EmptyCollection.Index) -> EmptyCollection.Index
    func makeIterator() -> EmptyIterator<Element>
    subscript(_ position: EmptyCollection.Index) -> Element
    subscript(_ bounds: Range<EmptyCollection.Index>) -> EmptyCollection<Element>
    var count: Int { get }
    func index(_ i: EmptyCollection.Index, offsetBy n: EmptyCollection.IndexDistance) -> EmptyCollection.Index
    func index(_ i: EmptyCollection.Index, offsetBy n: EmptyCollection.IndexDistance, limitedBy limit: EmptyCollection.Index) -> EmptyCollection.Index?
    func distance(from start: EmptyCollection.Index, to end: EmptyCollection.Index) -> EmptyCollection.IndexDistance
    typealias Indices = CountableRange<Int>
    mutating func popLast() -> Element?
    mutating func removeLast() -> Element
    mutating func removeLast(_ n: Int)
    func dropLast(_ n: Int) -> EmptyCollection<Element>
    func suffix(_ maxLength: Int) -> EmptyCollection<Element>
    mutating func popFirst() -> Element?
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> EmptyCollection<Element>
    func prefix(_ maxLength: Int) -> EmptyCollection<Element>
    func prefix(upTo end: Int) -> EmptyCollection<Element>
    func suffix(from start: Int) -> EmptyCollection<Element>
    func prefix(through position: Int) -> EmptyCollection<Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [EmptyCollection<Element>]
    mutating func removeFirst() -> Element
    mutating func removeFirst(_ n: Int)
    typealias Generator = EmptyIterator<Element>
    func generate() -> EmptyIterator<Element>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [EmptyCollection<Element>]
    var last: Element? { get }
    func index(where predicate: (Element) throws -> Bool) rethrows -> Int?
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    mutating func sort(by areInIncreasingOrder: (Element, Element) -> Bool)
    subscript(_ bounds: ClosedRange<Int>) -> EmptyCollection<Element> { get }
    subscript(_ bounds: CountableRange<Int>) -> EmptyCollection<Element> { get }
    subscript(_ bounds: CountableClosedRange<Int>) -> EmptyCollection<Element> { get }
    subscript(_ bounds: ClosedRange<Int>) -> EmptyCollection<Element>
    subscript(_ bounds: CountableRange<Int>) -> EmptyCollection<Element>
    subscript(_ bounds: CountableClosedRange<Int>) -> EmptyCollection<Element>
    mutating func partition(isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    mutating func partition(_ range: Range<Int>, isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    mutating func sortInPlace(_ isOrderedBefore: (Element, Element) -> Bool)
    func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Int?
    var lazy: LazySequence<EmptyCollection<Element>> { get }
    subscript(_ bounds: Range<Int>) -> MutableSlice<EmptyCollection<Element>>
    var indices: CountableRange<Int> { get }
    func reversed() -> ReversedRandomAccessCollection<EmptyCollection<Element>>
    func reverse() -> ReversedRandomAccessCollection<EmptyCollection<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> EmptyCollection<Element>
    func dropLast() -> EmptyCollection<Element>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [EmptyCollection<Element>]
    func enumerated() -> EnumeratedSequence<EmptyCollection<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<EmptyCollection<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension EmptyCollection {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension EmptyCollection {
    func formIndex(before i: inout Int)
}
extension EmptyCollection {
    var lazy: LazyBidirectionalCollection<EmptyCollection<Element>> { get }
}
extension EmptyCollection {
    var lazy: LazyCollection<EmptyCollection<Element>> { get }
}
extension EmptyCollection {
    var lazy: LazyRandomAccessCollection<EmptyCollection<Element>> { get }
}
extension EmptyCollection {
    func formIndex(after i: inout Int)
    func formIndex(_ i: inout Int, offsetBy n: Int)
    func formIndex(_ i: inout Int, offsetBy n: Int, limitedBy limit: Int) -> Bool
}
extension EmptyCollection : Equatable {
    static func ==(_ lhs: EmptyCollection<Element>, _ rhs: EmptyCollection<Element>) -> Bool
}
extension EmptyCollection where Element : Sequence {
    func joined() -> FlattenSequence<EmptyCollection<Element>>
    func flatten() -> FlattenSequence<EmptyCollection<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<EmptyCollection<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<EmptyCollection<Element>>
}
extension EmptyCollection where Element : BidirectionalCollection {
    func joined() -> FlattenBidirectionalCollection<EmptyCollection<Element>>
    func flatten() -> FlattenBidirectionalCollection<EmptyCollection<Element>>
}
extension EmptyCollection where Element : Collection {
    func joined() -> FlattenCollection<EmptyCollection<Element>>
    func flatten() -> FlattenCollection<EmptyCollection<Element>>
}
extension EmptyCollection where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [EmptyCollection<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [EmptyCollection<Element>]
    func index(of element: Element) -> Int?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension EmptyCollection where Element : Comparable {
    func sorted() -> [Element]
    func sorted() -> [Element]
    mutating func sort()
    mutating func partition() -> Int
    mutating func partition(_ range: Range<Int>) -> Int
    func sort() -> [Element]
    mutating func sortInPlace()
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension EmptyCollection where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
Equatable, MutableCollection, RandomAccessCollection

Declaration
From
var endIndex: Index { get }
To
var endIndex: EmptyCollection.Index { get }

Declaration
From
var startIndex: Index { get }
To
var startIndex: EmptyCollection.Index { get }

Declaration
From
subscript (_ position: Index) -> Element { get }
To
subscript(_ position: EmptyCollection.Index) -> Element

Modified Equatable
Declaration
From
protocol Equatable {
    @warn_unused_result
    func ==(_ lhs: Self, _ rhs: Self) -> Bool
}
To
protocol Equatable {
    static func ==(_ lhs: Self, _ rhs: Self) -> Bool
}

Declaration
From
@warn_unused_result
    func ==(_ lhs: Self, _ rhs: Self) -> Bool
To
static func ==(_ lhs: Self, _ rhs: Self) -> Bool

Modified FlattenBidirectionalCollection [struct]
DeclarationProtocolsGenerics[Constraints]
From
struct FlattenBidirectionalCollection<Base : CollectionType where Base.Generator.Element : CollectionType, Base.Index : BidirectionalIndexType, Base.Generator.Element.Index : BidirectionalIndexType> : CollectionType {
    typealias Index = FlattenBidirectionalCollectionIndex<Base>
    init(_ base: Base)
    func generate() -> FlattenGenerator<Base.Generator>
    var startIndex: FlattenBidirectionalCollectionIndex<Base> { get }
    var endIndex: FlattenBidirectionalCollectionIndex<Base> { get }
    subscript (_ position: FlattenBidirectionalCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element { get }
    func underestimateCount() -> Int
}
CollectionType
Base : CollectionType, Base.Generator.Element : CollectionType, Base.Index : BidirectionalIndexType, Base.Generator.Element.Index : BidirectionalIndexType
To
struct FlattenBidirectionalCollection<Base where Base : BidirectionalCollection, Base.Iterator.Element : BidirectionalCollection> : BidirectionalCollection {
    typealias Index = FlattenBidirectionalCollectionIndex<Base>
    typealias IndexDistance = Base.IndexDistance
    init(_ base: Base)
    func makeIterator() -> FlattenIterator<Base.Iterator>
    var startIndex: FlattenBidirectionalCollectionIndex<Base> { get }
    var endIndex: FlattenBidirectionalCollectionIndex<Base> { get }
    func index(after i: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>
    func index(before i: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>
    subscript(_ position: FlattenBidirectionalCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element { get }
    subscript(_ bounds: Range<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> { get }
    var underestimatedCount: Int { get }
    func forEach(_ body: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows
    func underestimateCount() -> Int
    func dropLast(_ n: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
    func suffix(_ maxLength: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
    func map<T>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
    func prefix(_ maxLength: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
    func prefix(upTo end: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
    func suffix(from start: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
    func prefix(through position: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>]
    typealias Generator = FlattenIterator<Base.Iterator>
    func generate() -> FlattenIterator<Base.Iterator>
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>]
    var last: Base.Iterator.Element.Iterator.Element? { get }
    func index(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenBidirectionalCollectionIndex<Base>?
    func sorted(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
    subscript(_ bounds: ClosedRange<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> { get }
    func sort(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
    func indexOf(_ predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenBidirectionalCollectionIndex<Base>?
    var indices: DefaultBidirectionalIndices<FlattenBidirectionalCollection<Base>> { get }
    var lazy: LazySequence<FlattenBidirectionalCollection<Base>> { get }
    func reversed() -> ReversedCollection<FlattenBidirectionalCollection<Base>>
    func reverse() -> ReversedCollection<FlattenBidirectionalCollection<Base>>
    func map<T>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
    var underestimatedCount: Int { get }
    func first(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func dropFirst() -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
    func dropLast() -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>]
    func enumerated() -> EnumeratedSequence<FlattenBidirectionalCollection<Base>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<FlattenBidirectionalCollection<Base>>
    func minElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func maxElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
}
extension FlattenBidirectionalCollection {
    subscript(_ bounds: Range<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> { get }
}
extension FlattenBidirectionalCollection {
    func formIndex(after i: inout FlattenBidirectionalCollectionIndex<Base>)
    func formIndex(_ i: inout FlattenBidirectionalCollectionIndex<Base>, offsetBy n: Base.IndexDistance)
    func formIndex(_ i: inout FlattenBidirectionalCollectionIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: FlattenBidirectionalCollectionIndex<Base>) -> Bool
}
extension FlattenBidirectionalCollection {
    var lazy: LazyBidirectionalCollection<FlattenBidirectionalCollection<Base>> { get }
}
extension FlattenBidirectionalCollection {
    var isEmpty: Bool { get }
    var first: Base.Iterator.Element.Iterator.Element? { get }
    var underestimatedCount: Int { get }
    var count: Base.IndexDistance { get }
}
extension FlattenBidirectionalCollection {
    var lazy: LazyCollection<FlattenBidirectionalCollection<Base>> { get }
}
extension FlattenBidirectionalCollection {
    func formIndex(before i: inout FlattenBidirectionalCollectionIndex<Base>)
    func index(_ i: FlattenBidirectionalCollectionIndex<Base>, offsetBy n: Base.IndexDistance) -> FlattenBidirectionalCollectionIndex<Base>
    func index(_ i: FlattenBidirectionalCollectionIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>?
    func distance(from start: FlattenBidirectionalCollectionIndex<Base>, to end: FlattenBidirectionalCollectionIndex<Base>) -> Base.IndexDistance
}
extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element : Equatable {
    func split(separator separator: Base.Iterator.Element.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>]
    func split(_ separator: Base.Iterator.Element.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>]
    func index(of element: Base.Iterator.Element.Iterator.Element) -> FlattenBidirectionalCollectionIndex<Base>?
    func split(separator separator: Base.Iterator.Element.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
    func split(_ separator: Base.Iterator.Element.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element : Comparable {
    func sorted() -> [Base.Iterator.Element.Iterator.Element]
    func sort() -> [Base.Iterator.Element.Iterator.Element]
    @warn_unqualified_access
    func min() -> Base.Iterator.Element.Iterator.Element?
    @warn_unqualified_access
    func max() -> Base.Iterator.Element.Iterator.Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Base.Iterator.Element.Iterator.Element?
    func maxElement() -> Base.Iterator.Element.Iterator.Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element : Sequence {
    func joined() -> FlattenSequence<FlattenBidirectionalCollection<Base>>
    func flatten() -> FlattenSequence<FlattenBidirectionalCollection<Base>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<FlattenBidirectionalCollection<Base>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<FlattenBidirectionalCollection<Base>>
}
extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element : BidirectionalCollection {
    func joined() -> FlattenBidirectionalCollection<FlattenBidirectionalCollection<Base>>
    func flatten() -> FlattenBidirectionalCollection<FlattenBidirectionalCollection<Base>>
}
extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element : Collection {
    func joined() -> FlattenCollection<FlattenBidirectionalCollection<Base>>
    func flatten() -> FlattenCollection<FlattenBidirectionalCollection<Base>>
}
BidirectionalCollection
Base : BidirectionalCollection, Base.Iterator.Element : BidirectionalCollection

Modified FlattenBidirectionalCollectionIndex [struct]
DeclarationProtocolsGenerics[Constraints]
From
struct FlattenBidirectionalCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType, BaseElements.Index : BidirectionalIndexType, BaseElements.Generator.Element.Index : BidirectionalIndexType> : BidirectionalIndexType {
    func successor() -> FlattenBidirectionalCollectionIndex<BaseElements>
    func predecessor() -> FlattenBidirectionalCollectionIndex<BaseElements>
}
BidirectionalIndexType
BaseElements : CollectionType, BaseElements.Generator.Element : CollectionType, BaseElements.Index : BidirectionalIndexType, BaseElements.Generator.Element.Index : BidirectionalIndexType
To
struct FlattenBidirectionalCollectionIndex<BaseElements where BaseElements : BidirectionalCollection, BaseElements.Iterator.Element : BidirectionalCollection> {
}
extension FlattenBidirectionalCollectionIndex : Comparable {
    static func ==(_ lhs: FlattenBidirectionalCollectionIndex<BaseElements>, _ rhs: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool
    static func <(_ lhs: FlattenBidirectionalCollectionIndex<BaseElements>, _ rhs: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool
}
Comparable
BaseElements : BidirectionalCollection, BaseElements.Iterator.Element : BidirectionalCollection

DeclarationProtocolsGenerics[Constraints]
From
struct FlattenCollection<Base : CollectionType where Base.Generator.Element : CollectionType> : CollectionType {
    typealias Index = FlattenCollectionIndex<Base>
    init(_ base: Base)
    func generate() -> FlattenGenerator<Base.Generator>
    var startIndex: FlattenCollectionIndex<Base> { get }
    var endIndex: FlattenCollectionIndex<Base> { get }
    subscript (_ position: FlattenCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element { get }
    func underestimateCount() -> Int
}
CollectionType
Base : CollectionType, Base.Generator.Element : CollectionType
To
struct FlattenCollection<Base where Base : Collection, Base.Iterator.Element : Collection> : Collection {
    typealias Index = FlattenCollectionIndex<Base>
    typealias IndexDistance = Base.IndexDistance
    init(_ base: Base)
    func makeIterator() -> FlattenIterator<Base.Iterator>
    var startIndex: FlattenCollectionIndex<Base> { get }
    var endIndex: FlattenCollectionIndex<Base> { get }
    func index(after i: FlattenCollectionIndex<Base>) -> FlattenCollectionIndex<Base>
    subscript(_ position: FlattenCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element { get }
    subscript(_ bounds: Range<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>> { get }
    var underestimatedCount: Int { get }
    func forEach(_ body: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows
    func underestimateCount() -> Int
    func map<T>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> Slice<FlattenCollection<Base>>
    func dropLast(_ n: Int) -> Slice<FlattenCollection<Base>>
    func prefix(_ maxLength: Int) -> Slice<FlattenCollection<Base>>
    func suffix(_ maxLength: Int) -> Slice<FlattenCollection<Base>>
    func prefix(upTo end: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>>
    func suffix(from start: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>>
    func prefix(through position: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Slice<FlattenCollection<Base>>]
    typealias Generator = FlattenIterator<Base.Iterator>
    func generate() -> FlattenIterator<Base.Iterator>
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Slice<FlattenCollection<Base>>]
    func index(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenCollectionIndex<Base>?
    func sorted(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
    subscript(_ bounds: ClosedRange<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>> { get }
    func sort(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
    func indexOf(_ predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenCollectionIndex<Base>?
    var indices: DefaultIndices<FlattenCollection<Base>> { get }
    var lazy: LazySequence<FlattenCollection<Base>> { get }
    func map<T>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
    var underestimatedCount: Int { get }
    func first(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func dropFirst() -> Slice<FlattenCollection<Base>>
    func dropLast() -> Slice<FlattenCollection<Base>>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Slice<FlattenCollection<Base>>]
    func enumerated() -> EnumeratedSequence<FlattenCollection<Base>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
    func reversed() -> [Base.Iterator.Element.Iterator.Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<FlattenCollection<Base>>
    func minElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func maxElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func reverse() -> [Base.Iterator.Element.Iterator.Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
}
extension FlattenCollection {
    subscript(_ bounds: Range<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>> { get }
}
extension FlattenCollection {
    var isEmpty: Bool { get }
    var first: Base.Iterator.Element.Iterator.Element? { get }
    var underestimatedCount: Int { get }
    var count: Base.IndexDistance { get }
}
extension FlattenCollection {
    func formIndex(after i: inout FlattenCollectionIndex<Base>)
    func index(_ i: FlattenCollectionIndex<Base>, offsetBy n: Base.IndexDistance) -> FlattenCollectionIndex<Base>
    func index(_ i: FlattenCollectionIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: FlattenCollectionIndex<Base>) -> FlattenCollectionIndex<Base>?
    func formIndex(_ i: inout FlattenCollectionIndex<Base>, offsetBy n: Base.IndexDistance)
    func formIndex(_ i: inout FlattenCollectionIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: FlattenCollectionIndex<Base>) -> Bool
    func distance(from start: FlattenCollectionIndex<Base>, to end: FlattenCollectionIndex<Base>) -> Base.IndexDistance
}
extension FlattenCollection {
    var lazy: LazyCollection<FlattenCollection<Base>> { get }
}
extension FlattenCollection where Base.Iterator.Element.Iterator.Element : Collection {
    func joined() -> FlattenCollection<FlattenCollection<Base>>
    func flatten() -> FlattenCollection<FlattenCollection<Base>>
}
extension FlattenCollection where Base.Iterator.Element.Iterator.Element : Comparable {
    func sorted() -> [Base.Iterator.Element.Iterator.Element]
    func sort() -> [Base.Iterator.Element.Iterator.Element]
    @warn_unqualified_access
    func min() -> Base.Iterator.Element.Iterator.Element?
    @warn_unqualified_access
    func max() -> Base.Iterator.Element.Iterator.Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Base.Iterator.Element.Iterator.Element?
    func maxElement() -> Base.Iterator.Element.Iterator.Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension FlattenCollection where Base.Iterator.Element.Iterator.Element : Sequence {
    func joined() -> FlattenSequence<FlattenCollection<Base>>
    func flatten() -> FlattenSequence<FlattenCollection<Base>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<FlattenCollection<Base>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<FlattenCollection<Base>>
}
extension FlattenCollection where Base.Iterator.Element.Iterator.Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension FlattenCollection where Base.Iterator.Element.Iterator.Element : Equatable {
    func split(separator separator: Base.Iterator.Element.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [Slice<FlattenCollection<Base>>]
    func split(_ separator: Base.Iterator.Element.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [Slice<FlattenCollection<Base>>]
    func index(of element: Base.Iterator.Element.Iterator.Element) -> FlattenCollectionIndex<Base>?
    func split(separator separator: Base.Iterator.Element.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
    func split(_ separator: Base.Iterator.Element.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool
}
Collection
Base : Collection, Base.Iterator.Element : Collection

Modified FlattenCollectionIndex [struct]
DeclarationProtocolsGenerics[Constraints]
From
struct FlattenCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType> : ForwardIndexType {
    func successor() -> FlattenCollectionIndex<BaseElements>
}
ForwardIndexType
BaseElements : CollectionType, BaseElements.Generator.Element : CollectionType
To
struct FlattenCollectionIndex<BaseElements where BaseElements : Collection, BaseElements.Iterator.Element : Collection> {
}
extension FlattenCollectionIndex : Comparable {
    static func ==(_ lhs: FlattenCollectionIndex<BaseElements>, _ rhs: FlattenCollectionIndex<BaseElements>) -> Bool
    static func <(_ lhs: FlattenCollectionIndex<BaseElements>, _ rhs: FlattenCollectionIndex<BaseElements>) -> Bool
}
Comparable
BaseElements : Collection, BaseElements.Iterator.Element : Collection

DeclarationProtocolsGenerics[Constraints]
From
struct FlattenSequence<Base : SequenceType where Base.Generator.Element : SequenceType> : SequenceType {
    init(_ base: Base)
    func generate() -> FlattenGenerator<Base.Generator>
}
SequenceType
Base : SequenceType, Base.Generator.Element : SequenceType
To
struct FlattenSequence<Base : Sequence where Base.Iterator.Element : Sequence> : Sequence {
    func makeIterator() -> FlattenIterator<Base.Iterator>
    func generate() -> FlattenIterator<Base.Iterator>
    func sorted(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
    func sort(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
    var lazy: LazySequence<FlattenSequence<Base>> { get }
    func map<T>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
    func suffix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Base.Iterator.Element.Iterator.Element) throws -> Void) rethrows
    func first(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func dropFirst(_ n: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>
    func dropLast(_ n: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>
    func prefix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>
    func dropFirst() -> AnySequence<Base.Iterator.Element.Iterator.Element>
    func dropLast() -> AnySequence<Base.Iterator.Element.Iterator.Element>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
    func enumerated() -> EnumeratedSequence<FlattenSequence<Base>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
    func reversed() -> [Base.Iterator.Element.Iterator.Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<FlattenSequence<Base>>
    func minElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func maxElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
    func reverse() -> [Base.Iterator.Element.Iterator.Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
}
extension FlattenSequence where Base.Iterator.Element.Iterator.Element : Comparable {
    func sorted() -> [Base.Iterator.Element.Iterator.Element]
    func sort() -> [Base.Iterator.Element.Iterator.Element]
    @warn_unqualified_access
    func min() -> Base.Iterator.Element.Iterator.Element?
    @warn_unqualified_access
    func max() -> Base.Iterator.Element.Iterator.Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Base.Iterator.Element.Iterator.Element?
    func maxElement() -> Base.Iterator.Element.Iterator.Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension FlattenSequence where Base.Iterator.Element.Iterator.Element : Sequence {
    func joined() -> FlattenSequence<FlattenSequence<Base>>
    func flatten() -> FlattenSequence<FlattenSequence<Base>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<FlattenSequence<Base>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<FlattenSequence<Base>>
}
extension FlattenSequence where Base.Iterator.Element.Iterator.Element : Equatable {
    func split(separator separator: Base.Iterator.Element.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
    func split(_ separator: Base.Iterator.Element.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension FlattenSequence where Base.Iterator.Element.Iterator.Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
Sequence
Base : Sequence, Base.Iterator.Element : Sequence

DeclarationProtocols
From
struct Float {
    init()
    init(_bits v: Builtin.FPIEEE32)
    init(_ value: Float)
}
extension Float {
    init(_ value: CGFloat)
}
extension Float : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Float : CustomStringConvertible {
    var description: String { get }
}
extension Float : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Float : FloatingPointType {
    static var infinity: Float { get }
    static var NaN: Float { get }
    static var quietNaN: Float { get }
    var isSignMinus: Bool { get }
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignaling: Bool { get }
}
extension Float {
    var floatingPointClass: FloatingPointClassification { get }
}
extension Float : IntegerLiteralConvertible {
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
}
extension Float {
    init(_builtinFloatLiteral value: Builtin.FPIEEE64)
}
extension Float : FloatLiteralConvertible {
    init(floatLiteral value: Float)
}
extension Float : Comparable, Equatable {
}
extension Float : Hashable {
    var hashValue: Int { get }
}
extension Float : AbsoluteValuable {
    @warn_unused_result
    static func abs(_ x: Float) -> Float
}
extension Float {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
}
extension Float {
    init(_ other: Double)
}
extension Float : Strideable {
    func distanceTo(_ other: Float) -> Float
    func advancedBy(_ amount: Float) -> Float
}
extension Float {
    init?(_ text: String)
}
extension Float : _Reflectable {
}
extension Float : _CVarArgPassedAsDouble, _CVarArgAlignedType {
}
AbsoluteValuable, Comparable, CustomDebugStringConvertible, CustomStringConvertible, Equatable, FloatLiteralConvertible, FloatingPointType, Hashable, IntegerLiteralConvertible, Strideable
To
struct Float {
    init()
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
    init(_ other: Float)
    init?(exactly other: Float)
    init(_ other: Double)
    init?(exactly other: Double)
}
extension Float {
    init(_ value: CGFloat)
}
extension Float {
    init(_ number: NSNumber)
}
extension Float : CustomStringConvertible {
    var description: String { get }
}
extension Float : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Float : BinaryFloatingPoint {
    typealias Exponent = Int
    typealias RawSignificand = UInt32
    static var exponentBitCount: Int { get }
    static var significandBitCount: Int { get }
    var bitPattern: UInt32 { get }
    init(bitPattern bitPattern: UInt32)
    var sign: FloatingPointSign { get }
    var isSignMinus: Bool { get }
    var exponentBitPattern: UInt { get }
    var significandBitPattern: UInt32 { get }
    init(sign sign: FloatingPointSign, exponentBitPattern exponentBitPattern: UInt, significandBitPattern significandBitPattern: UInt32)
    var isCanonical: Bool { get }
    static var infinity: Float { get }
    static var nan: Float { get }
    static var signalingNaN: Float { get }
    static var quietNaN: Float { get }
    static var greatestFiniteMagnitude: Float { get }
    static var pi: Float { get }
    var ulp: Float { get }
    static var leastNormalMagnitude: Float { get }
    static var leastNonzeroMagnitude: Float { get }
    var exponent: Int { get }
    var significand: Float { get }
    init(sign sign: FloatingPointSign, exponent exponent: Int, significand significand: Float)
    init(nan payload: Float.RawSignificand, signaling signaling: Bool)
    var nextUp: Float { get }
    mutating func round(_ rule: FloatingPointRoundingRule)
    mutating func negate()
    mutating func add(_ other: Float)
    mutating func subtract(_ other: Float)
    mutating func multiply(by other: Float)
    mutating func divide(by other: Float)
    mutating func formRemainder(dividingBy other: Float)
    mutating func formTruncatingRemainder(dividingBy other: Float)
    mutating func formSquareRoot()
    mutating func addProduct(_ lhs: Float, _ rhs: Float)
    func isEqual(to other: Float) -> Bool
    func isLess(than other: Float) -> Bool
    func isLessThanOrEqualTo(_ other: Float) -> Bool
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignalingNaN: Bool { get }
    var binade: Float { get }
    var significandWidth: Int { get }
    init(floatLiteral value: Float)
}
extension Float : ExpressibleByIntegerLiteral {
    init(integerLiteral value: Int64)
}
extension Float : LosslessStringConvertible {
    init?(_ text: String)
}
extension Float : Hashable {
    var hashValue: Int { get }
}
extension Float : AbsoluteValuable {
    static func abs(_ x: Float) -> Float
}
extension Float : Strideable {
    func distance(to other: Float) -> Float
    func advanced(by amount: Float) -> Float
}
extension Float : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Float : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
AbsoluteValuable, BinaryFloatingPoint, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, ExpressibleByIntegerLiteral, Hashable, LosslessStringConvertible, Strideable

Modified Float.abs(_: Float) -> Float [static]
Declaration
From
@warn_unused_result
    static func abs(_ x: Float) -> Float
To
static func abs(_ x: Float) -> Float

Declaration
From
enum FloatingPointClassification {
    case SignalingNaN
    case QuietNaN
    case NegativeInfinity
    case NegativeNormal
    case NegativeSubnormal
    case NegativeZero
    case PositiveZero
    case PositiveSubnormal
    case PositiveNormal
    case PositiveInfinity
}
To
enum FloatingPointClassification {
    case signalingNaN
    case quietNaN
    case negativeInfinity
    case negativeNormal
    case negativeSubnormal
    case negativeZero
    case positiveZero
    case positiveSubnormal
    case positiveNormal
    case positiveInfinity
}

Modified ImplicitlyUnwrappedOptional [enum]
DeclarationProtocols
From
enum ImplicitlyUnwrappedOptional<Wrapped> : _Reflectable, NilLiteralConvertible {
    case None
    case Some(Wrapped)
    typealias T = Wrapped
    init()
    init(_ some: Wrapped)
    init(_ v: Wrapped?)
    init(nilLiteral nilLiteral: ())
    @warn_unused_result
    func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U!
    @warn_unused_result
    func flatMap<U>(@noescape _ f: (Wrapped) throws -> U!) rethrows -> U!
}
extension ImplicitlyUnwrappedOptional : CustomStringConvertible {
    var description: String { get }
}
extension ImplicitlyUnwrappedOptional : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension ImplicitlyUnwrappedOptional : _ObjectiveCBridgeable {
}
CustomDebugStringConvertible, CustomStringConvertible, NilLiteralConvertible
To
enum ImplicitlyUnwrappedOptional<Wrapped> : ExpressibleByNilLiteral {
    case none
    case some(Wrapped)
    init(_ some: Wrapped)
    init(nilLiteral nilLiteral: ())
    init()
    func map<U>(_ f: (Wrapped) throws -> U) rethrows -> U!
    func flatMap<U>(_ f: (Wrapped) throws -> U!) rethrows -> U!
}
extension ImplicitlyUnwrappedOptional : CustomStringConvertible {
    var description: String { get }
}
extension ImplicitlyUnwrappedOptional : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
CustomDebugStringConvertible, CustomStringConvertible, ExpressibleByNilLiteral

Modified Index.init(_: String.UnicodeScalarIndex, within: String)
Declaration
From
init?(_ unicodeScalarIndex: UnicodeScalarIndex, within characters: String)
To
init?(_ unicodeScalarIndex: String.UnicodeScalarIndex, within other: String)

Modified Index.init(_: String.UTF16Index, within: String)
Declaration
From
init?(_ utf16Index: UTF16Index, within characters: String)
To
init?(_ utf16Index: String.UTF16Index, within other: String)

Modified Index.init(_: String.UTF8Index, within: String)
Declaration
From
init?(_ utf8Index: UTF8Index, within characters: String)
To
init?(_ utf8Index: String.UTF8Index, within other: String)

Modified Indexable
DeclarationProtocolsDeprecation
From
protocol Indexable {
    associatedtype Index : ForwardIndexType
    var startIndex: Self.Index { get }
    var endIndex: Self.Index { get }
    subscript (_ position: Self.Index) -> Self._Element { get }
}
----
To
protocol Indexable : IndexableBase {
    associatedtype IndexDistance : SignedInteger = Int
    func index(_ i: Self.Index, offsetBy n: Self.IndexDistance) -> Self.Index
    func index(_ i: Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Self.Index?
    func formIndex(_ i: inout Self.Index, offsetBy n: Self.IndexDistance)
    func formIndex(_ i: inout Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Bool
    func distance(from start: Self.Index, to end: Self.Index) -> Self.IndexDistance
}
IndexableBasetvOS 10.0

Modified Int [struct]
DeclarationProtocols
From
struct Int : SignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ v: Builtin.Word)
    init(_ value: Int)
    init(bigEndian value: Int)
    init(littleEndian value: Int)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int)
    var bigEndian: Int { get }
    var littleEndian: Int { get }
    var byteSwapped: Int { get }
    static var max: Int { get }
    static var min: Int { get }
}
extension Int {
    init(_ value: CGFloat)
}
extension Int : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Int : RandomAccessIndexType {
    func successor() -> Int
    func predecessor() -> Int
    func distanceTo(_ other: Int) -> Distance
    func advancedBy(_ n: Distance) -> Int
}
extension Int : Hashable {
    var hashValue: Int { get }
}
extension Int : CustomStringConvertible {
    var description: String { get }
}
extension Int {
    static func addWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int : SignedNumberType {
}
extension Int {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(bitPattern bitPattern: UInt)
}
extension Int : BitwiseOperationsType {
    static var allZeros: Int { get }
}
extension Int {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int {
    init?(_ text: String, radix radix: Int = default)
}
extension Int : _Reflectable {
}
extension Int : MirrorPathType {
}
extension Int : CVarArgType {
}
BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, MirrorPathType, RandomAccessIndexType, SignedIntegerType, SignedNumberType
To
struct Int : SignedInteger, Comparable, Equatable {
    init()
    init(bigEndian value: Int)
    init(littleEndian value: Int)
    init(integerLiteral value: Int)
    var bigEndian: Int { get }
    var littleEndian: Int { get }
    var byteSwapped: Int { get }
    static var max: Int { get }
    static var min: Int { get }
    init(bitPattern pointer: OpaquePointer?)
    static func addWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    func toIntMax() -> IntMax
    init(_ value: UInt8)
    init?(exactly value: UInt8)
    init(_ value: Int8)
    init?(exactly value: Int8)
    init(_ value: UInt16)
    init?(exactly value: UInt16)
    init(_ value: Int16)
    init?(exactly value: Int16)
    init(_ value: UInt32)
    init?(exactly value: UInt32)
    init(_ value: Int32)
    init?(exactly value: Int32)
    init(_ value: UInt64)
    init?(exactly value: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ value: Int64)
    init?(exactly value: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ value: UInt)
    init?(exactly value: UInt)
    init(_ value: Int)
    init?(exactly value: Int)
    init(bitPattern bitPattern: UInt)
    init(_ other: Float)
    init(_ other: Double)
    init?(_ text: String, radix radix: Int = default)
    init(bitPattern objectID: ObjectIdentifier)
    init(_ objectID: ObjectIdentifier)
    init<U>(bitPattern bitPattern: UnsafeMutablePointer<U>?)
    init<U>(bitPattern bitPattern: UnsafePointer<U>?)
    init(bitPattern bitPattern: UnsafeMutableRawPointer?)
    init(bitPattern bitPattern: UnsafeRawPointer?)
    func distance(to other: Int) -> Int
    func advanced(by n: Int) -> Int
}
extension Int {
    init(_ value: CGFloat)
}
extension Int {
    init(_ number: NSNumber)
}
extension Int : Hashable {
    var hashValue: Int { get }
}
extension Int : CustomStringConvertible {
    var description: String { get }
}
extension Int : BitwiseOperations {
    static var allZeros: Int { get }
}
extension Int : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Int : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension Int : CVarArg {
}
BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, SignedInteger

DeclarationProtocols
From
struct Int16 : SignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: Int16)
    init(bigEndian value: Int16)
    init(littleEndian value: Int16)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int16)
    var bigEndian: Int16 { get }
    var littleEndian: Int16 { get }
    var byteSwapped: Int16 { get }
    static var max: Int16 { get }
    static var min: Int16 { get }
}
extension Int16 {
    init(_ value: CGFloat)
}
extension Int16 : Hashable {
    var hashValue: Int { get }
}
extension Int16 : CustomStringConvertible {
    var description: String { get }
}
extension Int16 : RandomAccessIndexType {
    func successor() -> Int16
    func predecessor() -> Int16
    func distanceTo(_ other: Int16) -> Distance
    func advancedBy(_ n: Distance) -> Int16
}
extension Int16 {
    static func addWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int16 : SignedNumberType {
}
extension Int16 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt16)
}
extension Int16 : BitwiseOperationsType {
    static var allZeros: Int16 { get }
}
extension Int16 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int16 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int16 : _Reflectable {
}
extension Int16 : CVarArgType {
}
BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, SignedIntegerType, SignedNumberType
To
struct Int16 : SignedInteger, Comparable, Equatable {
    init()
    init(bigEndian value: Int16)
    init(littleEndian value: Int16)
    init(integerLiteral value: Int16)
    var bigEndian: Int16 { get }
    var littleEndian: Int16 { get }
    var byteSwapped: Int16 { get }
    static var max: Int16 { get }
    static var min: Int16 { get }
    static func addWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    func toIntMax() -> IntMax
    init(_ value: UInt8)
    init?(exactly value: UInt8)
    init(_ value: Int8)
    init?(exactly value: Int8)
    init(_ value: UInt16)
    init?(exactly value: UInt16)
    init(_ value: Int16)
    init?(exactly value: Int16)
    init(_ value: UInt32)
    init?(exactly value: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ value: Int32)
    init?(exactly value: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ value: UInt64)
    init?(exactly value: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ value: Int64)
    init?(exactly value: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ value: UInt)
    init?(exactly value: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ value: Int)
    init?(exactly value: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt16)
    init(_ other: Float)
    init(_ other: Double)
    init?(_ text: String, radix radix: Int = default)
    func distance(to other: Int16) -> Int
    func advanced(by n: Int) -> Int16
}
extension Int16 {
    init(_ value: CGFloat)
}
extension Int16 : Hashable {
    var hashValue: Int { get }
}
extension Int16 : CustomStringConvertible {
    var description: String { get }
}
extension Int16 : BitwiseOperations {
    static var allZeros: Int16 { get }
}
extension Int16 : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Int16 : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension Int16 : CVarArg {
}
BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, SignedInteger

DeclarationProtocols
From
struct Int32 : SignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: Int32)
    init(bigEndian value: Int32)
    init(littleEndian value: Int32)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int32)
    var bigEndian: Int32 { get }
    var littleEndian: Int32 { get }
    var byteSwapped: Int32 { get }
    static var max: Int32 { get }
    static var min: Int32 { get }
}
extension Int32 {
    init(_ value: CGFloat)
}
extension Int32 : Hashable {
    var hashValue: Int { get }
}
extension Int32 : CustomStringConvertible {
    var description: String { get }
}
extension Int32 : RandomAccessIndexType {
    func successor() -> Int32
    func predecessor() -> Int32
    func distanceTo(_ other: Int32) -> Distance
    func advancedBy(_ n: Distance) -> Int32
}
extension Int32 {
    static func addWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int32 : SignedNumberType {
}
extension Int32 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt32)
}
extension Int32 : BitwiseOperationsType {
    static var allZeros: Int32 { get }
}
extension Int32 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int32 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int32 : _Reflectable {
}
extension Int32 : CVarArgType {
}
BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, SignedIntegerType, SignedNumberType
To
struct Int32 : SignedInteger, Comparable, Equatable {
    init()
    init(bigEndian value: Int32)
    init(littleEndian value: Int32)
    init(integerLiteral value: Int32)
    var bigEndian: Int32 { get }
    var littleEndian: Int32 { get }
    var byteSwapped: Int32 { get }
    static var max: Int32 { get }
    static var min: Int32 { get }
    static func addWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    func toIntMax() -> IntMax
    init(_ value: UInt8)
    init?(exactly value: UInt8)
    init(_ value: Int8)
    init?(exactly value: Int8)
    init(_ value: UInt16)
    init?(exactly value: UInt16)
    init(_ value: Int16)
    init?(exactly value: Int16)
    init(_ value: UInt32)
    init?(exactly value: UInt32)
    init(_ value: Int32)
    init?(exactly value: Int32)
    init(_ value: UInt64)
    init?(exactly value: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ value: Int64)
    init?(exactly value: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ value: UInt)
    init?(exactly value: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ value: Int)
    init?(exactly value: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt32)
    init(_ other: Float)
    init(_ other: Double)
    init?(_ text: String, radix radix: Int = default)
    func distance(to other: Int32) -> Int
    func advanced(by n: Int) -> Int32
}
extension Int32 {
    init(_ value: CGFloat)
}
extension Int32 : Hashable {
    var hashValue: Int { get }
}
extension Int32 : CustomStringConvertible {
    var description: String { get }
}
extension Int32 : BitwiseOperations {
    static var allZeros: Int32 { get }
}
extension Int32 : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Int32 : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension Int32 : CVarArg {
}
BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, SignedInteger

DeclarationProtocols
From
struct Int64 : SignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: Int64)
    init(bigEndian value: Int64)
    init(littleEndian value: Int64)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
    var bigEndian: Int64 { get }
    var littleEndian: Int64 { get }
    var byteSwapped: Int64 { get }
    static var max: Int64 { get }
    static var min: Int64 { get }
}
extension Int64 {
    init(_ value: CGFloat)
}
extension Int64 : Hashable {
    var hashValue: Int { get }
}
extension Int64 : CustomStringConvertible {
    var description: String { get }
}
extension Int64 : RandomAccessIndexType {
    func successor() -> Int64
    func predecessor() -> Int64
    func distanceTo(_ other: Int64) -> Distance
    func advancedBy(_ n: Distance) -> Int64
}
extension Int64 {
    static func addWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int64 : SignedNumberType {
}
extension Int64 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: UInt)
    init(_ v: Int)
    init(bitPattern bitPattern: UInt64)
}
extension Int64 : BitwiseOperationsType {
    static var allZeros: Int64 { get }
}
extension Int64 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int64 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int64 : _Reflectable {
}
extension Int64 : CVarArgType, _CVarArgAlignedType {
}
BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, SignedIntegerType, SignedNumberType
To
struct Int64 : SignedInteger, Comparable, Equatable {
    init()
    init(bigEndian value: Int64)
    init(littleEndian value: Int64)
    init(integerLiteral value: Int64)
    var bigEndian: Int64 { get }
    var littleEndian: Int64 { get }
    var byteSwapped: Int64 { get }
    static var max: Int64 { get }
    static var min: Int64 { get }
    static func addWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    func toIntMax() -> IntMax
    init(_ value: UInt8)
    init?(exactly value: UInt8)
    init(_ value: Int8)
    init?(exactly value: Int8)
    init(_ value: UInt16)
    init?(exactly value: UInt16)
    init(_ value: Int16)
    init?(exactly value: Int16)
    init(_ value: UInt32)
    init?(exactly value: UInt32)
    init(_ value: Int32)
    init?(exactly value: Int32)
    init(_ value: UInt64)
    init?(exactly value: UInt64)
    init(_ value: Int64)
    init?(exactly value: Int64)
    init(_ value: UInt)
    init?(exactly value: UInt)
    init(_ value: Int)
    init?(exactly value: Int)
    init(bitPattern bitPattern: UInt64)
    init(_ other: Float)
    init(_ other: Double)
    init?(_ text: String, radix radix: Int = default)
    func distance(to other: Int64) -> Int
    func advanced(by n: Int) -> Int64
}
extension Int64 {
    init(_ value: CGFloat)
}
extension Int64 : Hashable {
    var hashValue: Int { get }
}
extension Int64 : CustomStringConvertible {
    var description: String { get }
}
extension Int64 : BitwiseOperations {
    static var allZeros: Int64 { get }
}
extension Int64 : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Int64 : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension Int64 : CVarArg {
}
BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, SignedInteger

Modified Int8 [struct]
DeclarationProtocols
From
struct Int8 : SignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: Int8)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int8)
    static var max: Int8 { get }
    static var min: Int8 { get }
}
extension Int8 {
    init(_ value: CGFloat)
}
extension Int8 : Hashable {
    var hashValue: Int { get }
}
extension Int8 : CustomStringConvertible {
    var description: String { get }
}
extension Int8 : RandomAccessIndexType {
    func successor() -> Int8
    func predecessor() -> Int8
    func distanceTo(_ other: Int8) -> Distance
    func advancedBy(_ n: Distance) -> Int8
}
extension Int8 {
    static func addWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int8 : SignedNumberType {
}
extension Int8 {
    init(_ v: UInt8)
    init(_ v: UInt16)
    init(truncatingBitPattern truncatingBitPattern: UInt16)
    init(_ v: Int16)
    init(truncatingBitPattern truncatingBitPattern: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt8)
}
extension Int8 : BitwiseOperationsType {
    static var allZeros: Int8 { get }
}
extension Int8 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int8 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int8 : _Reflectable {
}
extension Int8 : CVarArgType {
}
BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, SignedIntegerType, SignedNumberType
To
struct Int8 : SignedInteger, Comparable, Equatable {
    init()
    init(integerLiteral value: Int8)
    static var max: Int8 { get }
    static var min: Int8 { get }
    static func addWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    func toIntMax() -> IntMax
    init(_ value: UInt8)
    init?(exactly value: UInt8)
    init(_ value: Int8)
    init?(exactly value: Int8)
    init(_ value: UInt16)
    init?(exactly value: UInt16)
    init(truncatingBitPattern truncatingBitPattern: UInt16)
    init(_ value: Int16)
    init?(exactly value: Int16)
    init(truncatingBitPattern truncatingBitPattern: Int16)
    init(_ value: UInt32)
    init?(exactly value: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ value: Int32)
    init?(exactly value: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ value: UInt64)
    init?(exactly value: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ value: Int64)
    init?(exactly value: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ value: UInt)
    init?(exactly value: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ value: Int)
    init?(exactly value: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt8)
    init(_ other: Float)
    init(_ other: Double)
    init?(_ text: String, radix radix: Int = default)
    func distance(to other: Int8) -> Int
    func advanced(by n: Int) -> Int8
}
extension Int8 {
    init(_ value: CGFloat)
}
extension Int8 : Hashable {
    var hashValue: Int { get }
}
extension Int8 : CustomStringConvertible {
    var description: String { get }
}
extension Int8 : BitwiseOperations {
    static var allZeros: Int8 { get }
}
extension Int8 : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Int8 : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension Int8 : CVarArg {
}
BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, SignedInteger

DeclarationProtocolsGenerics[Constraints]
From
struct LazyCollection<Base : CollectionType> : LazyCollectionType {
    typealias Elements = Base
    var elements: Base { get }
    typealias Index = Base.Index
    init(_ base: Base)
}
extension LazyCollection : SequenceType {
    func generate() -> Base.Generator
    func underestimateCount() -> Int
}
extension LazyCollection : CollectionType {
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (_ position: Base.Index) -> Base.Generator.Element { get }
    subscript (_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get }
    var isEmpty: Bool { get }
    var count: Base.Index.Distance { get }
    var first: Base.Generator.Element? { get }
    typealias S = Void
}
CollectionType, LazyCollectionType, SequenceType
Base : CollectionType
To
struct LazyCollection<Base : Collection> : LazyCollectionProtocol {
    typealias Elements = Base
    var elements: Base { get }
    typealias Index = Base.Index
    func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> LazyCollection<Slice<Base>>
    func dropLast(_ n: Int) -> LazyCollection<Slice<Base>>
    func prefix(_ maxLength: Int) -> LazyCollection<Slice<Base>>
    func suffix(_ maxLength: Int) -> LazyCollection<Slice<Base>>
    func prefix(upTo end: Base.Index) -> LazyCollection<Slice<Base>>
    func suffix(from start: Base.Index) -> LazyCollection<Slice<Base>>
    func prefix(through position: Base.Index) -> LazyCollection<Slice<Base>>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyCollection<Slice<Base>>]
    typealias Generator = Base.Iterator
    func generate() -> Base.Iterator
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyCollection<Slice<Base>>]
    func index(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Index?
    func sorted(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
    subscript(_ bounds: ClosedRange<Base.Index>) -> LazyCollection<Slice<Base>> { get }
    func sort(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
    func indexOf(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Index?
    func filter(_ isIncluded: @escaping (Base.Iterator.Element) -> Bool) -> LazyFilterCollection<Base>
    func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>>
    func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult>
    func flatMap<SegmentOfResult : Collection>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<Base, SegmentOfResult>>>
    func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<Base, ElementOfResult?>>, ElementOfResult>
    var lazy: LazyCollection<Base> { get }
    var lazy: LazySequence<LazyCollection<Base>> { get }
    var array: [Base.Iterator.Element] { get }
    func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>
    func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapCollection<Base, U>
    func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Base.Iterator.Element) throws -> Void) rethrows
    func first(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func dropFirst() -> LazyCollection<Slice<Base>>
    func dropLast() -> LazyCollection<Slice<Base>>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyCollection<Slice<Base>>]
    func enumerated() -> EnumeratedSequence<LazyCollection<Base>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
    func reversed() -> [Base.Iterator.Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<LazyCollection<Base>>
    func minElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func maxElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func reverse() -> [Base.Iterator.Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
}
extension LazyCollection {
    func formIndex(after i: inout Base.Index)
    func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance)
    func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Bool
}
extension LazyCollection {
    var lazy: LazyCollection<LazyCollection<Base>> { get }
}
extension LazyCollection {
    var isEmpty: Bool { get }
    var first: Base.Iterator.Element? { get }
    var underestimatedCount: Int { get }
    var count: Base.IndexDistance { get }
}
extension LazyCollection {
    var lazy: LazyCollection<Base> { get }
}
extension LazyCollection : Collection {
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    var indices: Base.Indices { get }
    func index(after i: Base.Index) -> Base.Index
    subscript(_ position: Base.Index) -> Base.Iterator.Element { get }
    subscript(_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get }
    var isEmpty: Bool { get }
    var count: Base.IndexDistance { get }
    var first: Base.Iterator.Element? { get }
    func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
    func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
    func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
}
extension LazyCollection : Sequence {
    func makeIterator() -> Base.Iterator
    var underestimatedCount: Int { get }
}
extension LazyCollection where Base.Iterator.Element : Equatable {
    func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [LazyCollection<Slice<Base>>]
    func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [LazyCollection<Slice<Base>>]
    func index(of element: Base.Iterator.Element) -> Base.Index?
    func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element>]
    func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension LazyCollection where Base.Indices == DefaultIndices<Self> {
    var indices: DefaultIndices<LazyCollection<Base>> { get }
}
extension LazyCollection where Base == LazyCollection<Base> {
    var elements: LazyCollection<Base> { get }
}
extension LazyCollection where LazyCollection<Slice<Base>> == LazyCollection<Base> {
    mutating func popFirst() -> Base.Iterator.Element?
    mutating func removeFirst() -> Base.Iterator.Element
    mutating func removeFirst(_ n: Int)
}
extension LazyCollection where Base.Iterator.Element : Sequence {
    func joined() -> FlattenSequence<LazyCollection<Base>>
    func flatten() -> FlattenSequence<LazyCollection<Base>>
    func joined() -> LazySequence<FlattenSequence<Base>>
    func flatten() -> LazySequence<FlattenSequence<Base>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazyCollection<Base>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazyCollection<Base>>
}
extension LazyCollection where Base.Iterator.Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension LazyCollection where Base == LazyCollection<Base> {
    var elements: LazyCollection<Base> { get }
}
extension LazyCollection where Base.Iterator.Element : Collection {
    func joined() -> FlattenCollection<LazyCollection<Base>>
    func flatten() -> FlattenCollection<LazyCollection<Base>>
    func joined() -> LazyCollection<FlattenCollection<Base>>
    func flatten() -> LazyCollection<FlattenCollection<Base>>
}
extension LazyCollection where Base.Index : Strideable, Index.Stride : SignedInteger {
    subscript(_ bounds: CountableRange<Base.Index>) -> LazyCollection<Slice<Base>> { get }
    subscript(_ bounds: CountableClosedRange<Base.Index>) -> LazyCollection<Slice<Base>> { get }
}
extension LazyCollection where Base.Iterator.Element : Comparable {
    func sorted() -> [Base.Iterator.Element]
    func sort() -> [Base.Iterator.Element]
    @warn_unqualified_access
    func min() -> Base.Iterator.Element?
    @warn_unqualified_access
    func max() -> Base.Iterator.Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Base.Iterator.Element?
    func maxElement() -> Base.Iterator.Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
}
Collection, LazyCollectionProtocol, Sequence
Base : Collection

Modified LazyCollection.first
Declaration
From
var first: Base.Generator.Element? { get }
To
var first: Base.Iterator.Element? { get }

Declaration
From
subscript (_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get }
To
subscript(_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get }

DeclarationProtocolsGenerics[Constraints]
From
struct LazyFilterCollection<Base : CollectionType> : LazyCollectionType {
    typealias Index = LazyFilterIndex<Base>
    init(_ base: Base, whereElementsSatisfy predicate: (Base.Generator.Element) -> Bool)
    var startIndex: LazyFilterIndex<Base> { get }
    var endIndex: LazyFilterIndex<Base> { get }
    subscript (_ position: LazyFilterIndex<Base>) -> Base.Generator.Element { get }
    func generate() -> LazyFilterGenerator<Base.Generator>
}
LazyCollectionType
Base : CollectionType
To
struct LazyFilterCollection<Base : Collection> : LazyCollectionProtocol, Collection {
    typealias Index = LazyFilterIndex<Base>
    typealias IndexDistance = Base.IndexDistance
    var startIndex: LazyFilterIndex<Base> { get }
    var endIndex: LazyFilterIndex<Base> { get }
    func index(after i: LazyFilterIndex<Base>) -> LazyFilterIndex<Base>
    func formIndex(after i: inout LazyFilterIndex<Base>)
    subscript(_ position: LazyFilterIndex<Base>) -> Base.Iterator.Element { get }
    subscript(_ bounds: Range<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>> { get }
    func makeIterator() -> LazyFilterIterator<Base.Iterator>
    init(_ base: Base, whereElementsSatisfy predicate: (Base.Iterator.Element) -> Bool)
    func generate() -> LazyFilterIterator<Base.Iterator>
    func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> Slice<LazyFilterCollection<Base>>
    func dropLast(_ n: Int) -> Slice<LazyFilterCollection<Base>>
    func prefix(_ maxLength: Int) -> Slice<LazyFilterCollection<Base>>
    func suffix(_ maxLength: Int) -> Slice<LazyFilterCollection<Base>>
    func prefix(upTo end: LazyFilterIndex<Base>) -> Slice<LazyFilterCollection<Base>>
    func suffix(from start: LazyFilterIndex<Base>) -> Slice<LazyFilterCollection<Base>>
    func prefix(through position: LazyFilterIndex<Base>) -> Slice<LazyFilterCollection<Base>>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [Slice<LazyFilterCollection<Base>>]
    typealias Generator = LazyFilterIterator<Base.Iterator>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [Slice<LazyFilterCollection<Base>>]
    func index(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> LazyFilterIndex<Base>?
    func sorted(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
    subscript(_ bounds: ClosedRange<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>> { get }
    func sort(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
    func indexOf(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> LazyFilterIndex<Base>?
    func filter(_ isIncluded: @escaping (Base.Iterator.Element) -> Bool) -> LazyFilterCollection<LazyFilterCollection<Base>>
    func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyFilterCollection<Base>, SegmentOfResult>>>
    func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyFilterCollection<Base>, ElementOfResult?>>, ElementOfResult>
    func flatMap<SegmentOfResult : Collection>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyFilterCollection<Base>, SegmentOfResult>>>
    func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyFilterCollection<Base>, ElementOfResult?>>, ElementOfResult>
    var indices: DefaultIndices<LazyFilterCollection<Base>> { get }
    var lazy: LazyFilterCollection<Base> { get }
    var lazy: LazySequence<LazyFilterCollection<Base>> { get }
    var array: [Base.Iterator.Element] { get }
    func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterCollection<Base>, U>
    func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapCollection<LazyFilterCollection<Base>, U>
    func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Base.Iterator.Element) throws -> Void) rethrows
    func first(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func dropFirst() -> Slice<LazyFilterCollection<Base>>
    func dropLast() -> Slice<LazyFilterCollection<Base>>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [Slice<LazyFilterCollection<Base>>]
    func enumerated() -> EnumeratedSequence<LazyFilterCollection<Base>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
    func reversed() -> [Base.Iterator.Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<LazyFilterCollection<Base>>
    func minElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func maxElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func reverse() -> [Base.Iterator.Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
}
extension LazyFilterCollection {
    subscript(_ bounds: Range<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>> { get }
}
extension LazyFilterCollection {
    var isEmpty: Bool { get }
    var first: Base.Iterator.Element? { get }
    var underestimatedCount: Int { get }
    var count: Base.IndexDistance { get }
}
extension LazyFilterCollection {
    var elements: LazyFilterCollection<Base> { get }
}
extension LazyFilterCollection {
    var elements: LazyFilterCollection<Base> { get }
}
extension LazyFilterCollection {
    var lazy: LazyCollection<LazyFilterCollection<Base>> { get }
}
extension LazyFilterCollection {
    var lazy: LazyFilterCollection<Base> { get }
}
extension LazyFilterCollection {
    func index(_ i: LazyFilterIndex<Base>, offsetBy n: Base.IndexDistance) -> LazyFilterIndex<Base>
    func index(_ i: LazyFilterIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: LazyFilterIndex<Base>) -> LazyFilterIndex<Base>?
    func formIndex(_ i: inout LazyFilterIndex<Base>, offsetBy n: Base.IndexDistance)
    func formIndex(_ i: inout LazyFilterIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: LazyFilterIndex<Base>) -> Bool
    func distance(from start: LazyFilterIndex<Base>, to end: LazyFilterIndex<Base>) -> Base.IndexDistance
}
extension LazyFilterCollection where Base.Iterator.Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension LazyFilterCollection where Base.Iterator.Element : Sequence {
    func joined() -> FlattenSequence<LazyFilterCollection<Base>>
    func flatten() -> FlattenSequence<LazyFilterCollection<Base>>
    func joined() -> LazySequence<FlattenSequence<LazyFilterCollection<Base>>>
    func flatten() -> LazySequence<FlattenSequence<LazyFilterCollection<Base>>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazyFilterCollection<Base>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazyFilterCollection<Base>>
}
extension LazyFilterCollection where Base.Iterator.Element : Collection {
    func joined() -> FlattenCollection<LazyFilterCollection<Base>>
    func flatten() -> FlattenCollection<LazyFilterCollection<Base>>
    func joined() -> LazyCollection<FlattenCollection<LazyFilterCollection<Base>>>
    func flatten() -> LazyCollection<FlattenCollection<LazyFilterCollection<Base>>>
}
extension LazyFilterCollection where Base.Iterator.Element : Equatable {
    func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [Slice<LazyFilterCollection<Base>>]
    func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [Slice<LazyFilterCollection<Base>>]
    func index(of element: Base.Iterator.Element) -> LazyFilterIndex<Base>?
    func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element>]
    func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension LazyFilterCollection where Base.Iterator.Element : Comparable {
    func sorted() -> [Base.Iterator.Element]
    func sort() -> [Base.Iterator.Element]
    @warn_unqualified_access
    func min() -> Base.Iterator.Element?
    @warn_unqualified_access
    func max() -> Base.Iterator.Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Base.Iterator.Element?
    func maxElement() -> Base.Iterator.Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
}
Collection, LazyCollectionProtocol
Base : Collection

Modified LazyFilterIndex [struct]
DeclarationProtocolsGenerics[Constraints]Generics[Parameters]
From
struct LazyFilterIndex<BaseElements : CollectionType> : ForwardIndexType {
    func successor() -> LazyFilterIndex<BaseElements>
    let base: BaseElements.Index
    typealias Base = BaseElements
}
ForwardIndexType
BaseElements : CollectionType
BaseElements
To
struct LazyFilterIndex<Base : Collection> {
    let base: Base.Index
}
extension LazyFilterIndex : Comparable {
    static func ==(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool
    static func !=(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool
    static func <(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool
    static func <=(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool
    static func >=(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool
    static func >(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool
}
Comparable
Base : Collection
Base

Modified LazyFilterIndex.base
Declaration
From
let base: BaseElements.Index
To
let base: Base.Index

DeclarationProtocolsGenerics[Constraints]
From
struct LazyFilterSequence<Base : SequenceType> : LazySequenceType {
    func generate() -> LazyFilterGenerator<Base.Generator>
    init(_ base: Base, whereElementsSatisfy predicate: (Base.Generator.Element) -> Bool)
    let base: Base
}
LazySequenceType
Base : SequenceType
To
struct LazyFilterSequence<Base : Sequence> : LazySequenceProtocol {
    func makeIterator() -> LazyFilterIterator<Base.Iterator>
    let base: Base
    init(_ base: Base, whereElementsSatisfy predicate: (Base.Iterator.Element) -> Bool)
    func generate() -> LazyFilterIterator<Base.Iterator>
    func sorted(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
    func sort(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
    func filter(_ isIncluded: @escaping (Base.Iterator.Element) -> Bool) -> LazyFilterSequence<LazyFilterSequence<Base>>
    func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyFilterSequence<Base>, SegmentOfResult>>>
    func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyFilterSequence<Base>, ElementOfResult?>>, ElementOfResult>
    var lazy: LazySequence<LazyFilterSequence<Base>> { get }
    var array: [Base.Iterator.Element] { get }
    func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterSequence<Base>, U>
    func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T]
    func suffix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Base.Iterator.Element) throws -> Void) rethrows
    func first(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func dropFirst(_ n: Int) -> AnySequence<Base.Iterator.Element>
    func dropLast(_ n: Int) -> AnySequence<Base.Iterator.Element>
    func prefix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element>
    func dropFirst() -> AnySequence<Base.Iterator.Element>
    func dropLast() -> AnySequence<Base.Iterator.Element>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>]
    func enumerated() -> EnumeratedSequence<LazyFilterSequence<Base>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
    func reversed() -> [Base.Iterator.Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<LazyFilterSequence<Base>>
    func minElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func maxElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func reverse() -> [Base.Iterator.Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
}
extension LazyFilterSequence {
    var lazy: LazyFilterSequence<Base> { get }
}
extension LazyFilterSequence {
    var elements: LazyFilterSequence<Base> { get }
}
extension LazyFilterSequence where Base.Iterator.Element : Sequence {
    func joined() -> FlattenSequence<LazyFilterSequence<Base>>
    func flatten() -> FlattenSequence<LazyFilterSequence<Base>>
    func joined() -> LazySequence<FlattenSequence<LazyFilterSequence<Base>>>
    func flatten() -> LazySequence<FlattenSequence<LazyFilterSequence<Base>>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazyFilterSequence<Base>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazyFilterSequence<Base>>
}
extension LazyFilterSequence where Base.Iterator.Element : Comparable {
    func sorted() -> [Base.Iterator.Element]
    func sort() -> [Base.Iterator.Element]
    @warn_unqualified_access
    func min() -> Base.Iterator.Element?
    @warn_unqualified_access
    func max() -> Base.Iterator.Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Base.Iterator.Element?
    func maxElement() -> Base.Iterator.Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension LazyFilterSequence where Base.Iterator.Element : Equatable {
    func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element>]
    func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension LazyFilterSequence where Base.Iterator.Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
LazySequenceProtocol
Base : Sequence

DeclarationProtocolsGenerics[Constraints]
From
struct LazyMapCollection<Base : CollectionType, Element> : LazyCollectionType {
    typealias Index = Base.Index
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (_ position: Base.Index) -> Element { get }
    var isEmpty: Bool { get }
    var first: Element? { get }
    func generate() -> LazyMapGenerator<Base.Generator, Element>
    func underestimateCount() -> Int
    var count: Base.Index.Distance { get }
    init(_ base: Base, transform transform: (Base.Generator.Element) -> Element)
    typealias T = Element
}
LazyCollectionType
Base : CollectionType
To
struct LazyMapCollection<Base : Collection, Element> : LazyCollectionProtocol, Collection {
    typealias Index = Base.Index
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    func index(after i: Base.Index) -> Base.Index
    func formIndex(after i: inout Base.Index)
    subscript(_ position: Base.Index) -> Element { get }
    subscript(_ bounds: Range<Base.Index>) -> Slice<LazyMapCollection<Base, Element>> { get }
    typealias IndexDistance = Base.IndexDistance
    typealias Indices = Base.Indices
    var indices: Base.Indices { get }
    var isEmpty: Bool { get }
    var count: Base.IndexDistance { get }
    var first: Element? { get }
    func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
    func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
    func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
    func makeIterator() -> LazyMapIterator<Base.Iterator, Element>
    var underestimatedCount: Int { get }
    init(_ base: Base, transform transform: (Base.Iterator.Element) -> Element)
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> Slice<LazyMapCollection<Base, Element>>
    func dropLast(_ n: Int) -> Slice<LazyMapCollection<Base, Element>>
    func prefix(_ maxLength: Int) -> Slice<LazyMapCollection<Base, Element>>
    func suffix(_ maxLength: Int) -> Slice<LazyMapCollection<Base, Element>>
    func prefix(upTo end: Base.Index) -> Slice<LazyMapCollection<Base, Element>>
    func suffix(from start: Base.Index) -> Slice<LazyMapCollection<Base, Element>>
    func prefix(through position: Base.Index) -> Slice<LazyMapCollection<Base, Element>>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<LazyMapCollection<Base, Element>>]
    typealias Generator = LazyMapIterator<Base.Iterator, Element>
    func generate() -> LazyMapIterator<Base.Iterator, Element>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<LazyMapCollection<Base, Element>>]
    func index(where predicate: (Element) throws -> Bool) rethrows -> Base.Index?
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    subscript(_ bounds: ClosedRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>> { get }
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Base.Index?
    func filter(_ isIncluded: @escaping (Element) -> Bool) -> LazyFilterCollection<LazyMapCollection<Base, Element>>
    func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapCollection<Base, Element>, SegmentOfResult>>>
    func flatMap<ElementOfResult>(_ transform: @escaping (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
    func flatMap<SegmentOfResult : Collection>(_ transform: @escaping (Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyMapCollection<Base, Element>, SegmentOfResult>>>
    func flatMap<ElementOfResult>(_ transform: @escaping (Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyMapCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
    var lazy: LazyMapCollection<Base, Element> { get }
    var lazy: LazySequence<LazyMapCollection<Base, Element>> { get }
    var array: [Element] { get }
    func map<U>(_ transform: @escaping (Element) -> U) -> LazyMapSequence<LazyMapCollection<Base, Element>, U>
    func map<U>(_ transform: @escaping (Element) -> U) -> LazyMapCollection<LazyMapCollection<Base, Element>, U>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> Slice<LazyMapCollection<Base, Element>>
    func dropLast() -> Slice<LazyMapCollection<Base, Element>>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<LazyMapCollection<Base, Element>>]
    func enumerated() -> EnumeratedSequence<LazyMapCollection<Base, Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func reversed() -> [Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<LazyMapCollection<Base, Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func reverse() -> [Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension LazyMapCollection {
    subscript(_ bounds: Range<Base.Index>) -> Slice<LazyMapCollection<Base, Element>> { get }
}
extension LazyMapCollection {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Base.IndexDistance { get }
}
extension LazyMapCollection {
    var elements: LazyMapCollection<Base, Element> { get }
}
extension LazyMapCollection {
    var elements: LazyMapCollection<Base, Element> { get }
}
extension LazyMapCollection {
    func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance)
    func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Bool
}
extension LazyMapCollection {
    var lazy: LazyCollection<LazyMapCollection<Base, Element>> { get }
}
extension LazyMapCollection {
    var lazy: LazyMapCollection<Base, Element> { get }
}
extension LazyMapCollection where Element : Sequence {
    func joined() -> FlattenSequence<LazyMapCollection<Base, Element>>
    func flatten() -> FlattenSequence<LazyMapCollection<Base, Element>>
    func joined() -> LazySequence<FlattenSequence<LazyMapCollection<Base, Element>>>
    func flatten() -> LazySequence<FlattenSequence<LazyMapCollection<Base, Element>>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazyMapCollection<Base, Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazyMapCollection<Base, Element>>
}
extension LazyMapCollection where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension LazyMapCollection where Base.Indices == DefaultIndices<Self> {
    var indices: DefaultIndices<LazyMapCollection<Base, Element>> { get }
}
extension LazyMapCollection where Base.Index : Strideable, Index.Stride : SignedInteger {
    subscript(_ bounds: CountableRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>> { get }
    subscript(_ bounds: CountableClosedRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>> { get }
}
extension LazyMapCollection where Element : Collection {
    func joined() -> FlattenCollection<LazyMapCollection<Base, Element>>
    func flatten() -> FlattenCollection<LazyMapCollection<Base, Element>>
    func joined() -> LazyCollection<FlattenCollection<LazyMapCollection<Base, Element>>>
    func flatten() -> LazyCollection<FlattenCollection<LazyMapCollection<Base, Element>>>
}
extension LazyMapCollection where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [Slice<LazyMapCollection<Base, Element>>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [Slice<LazyMapCollection<Base, Element>>]
    func index(of element: Element) -> Base.Index?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension LazyMapCollection where Element : Comparable {
    func sorted() -> [Element]
    func sort() -> [Element]
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
Collection, LazyCollectionProtocol
Base : Collection

Declaration
From
subscript (_ position: Base.Index) -> Element { get }
To
subscript(_ position: Base.Index) -> Element { get }

DeclarationProtocolsGenerics[Constraints]
From
struct LazyMapSequence<Base : SequenceType, Element> : LazySequenceType {
    typealias Elements = LazyMapSequence<Base, Element>
    func generate() -> LazyMapGenerator<Base.Generator, Element>
    func underestimateCount() -> Int
    init(_ base: Base, transform transform: (Base.Generator.Element) -> Element)
    typealias T = Element
}
LazySequenceType
Base : SequenceType
To
struct LazyMapSequence<Base : Sequence, Element> : LazySequenceProtocol {
    typealias Elements = LazyMapSequence<Base, Element>
    func makeIterator() -> LazyMapIterator<Base.Iterator, Element>
    var underestimatedCount: Int { get }
    init(_ base: Base, transform transform: (Base.Iterator.Element) -> Element)
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    func filter(_ isIncluded: @escaping (Element) -> Bool) -> LazyFilterSequence<LazyMapSequence<Base, Element>>
    func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapSequence<Base, Element>, SegmentOfResult>>>
    func flatMap<ElementOfResult>(_ transform: @escaping (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapSequence<Base, Element>, ElementOfResult?>>, ElementOfResult>
    var lazy: LazySequence<LazyMapSequence<Base, Element>> { get }
    var array: [Element] { get }
    func map<U>(_ transform: @escaping (Element) -> U) -> LazyMapSequence<LazyMapSequence<Base, Element>, U>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func suffix(_ maxLength: Int) -> AnySequence<Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst(_ n: Int) -> AnySequence<Element>
    func dropLast(_ n: Int) -> AnySequence<Element>
    func prefix(_ maxLength: Int) -> AnySequence<Element>
    func dropFirst() -> AnySequence<Element>
    func dropLast() -> AnySequence<Element>
    func generate() -> LazyMapIterator<Base.Iterator, Element>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
    func enumerated() -> EnumeratedSequence<LazyMapSequence<Base, Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func reversed() -> [Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<LazyMapSequence<Base, Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func reverse() -> [Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension LazyMapSequence {
    var lazy: LazyMapSequence<Base, Element> { get }
}
extension LazyMapSequence {
    var elements: LazyMapSequence<Base, Element> { get }
}
extension LazyMapSequence where Element : Sequence {
    func joined() -> FlattenSequence<LazyMapSequence<Base, Element>>
    func flatten() -> FlattenSequence<LazyMapSequence<Base, Element>>
    func joined() -> LazySequence<FlattenSequence<LazyMapSequence<Base, Element>>>
    func flatten() -> LazySequence<FlattenSequence<LazyMapSequence<Base, Element>>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazyMapSequence<Base, Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazyMapSequence<Base, Element>>
}
extension LazyMapSequence where Element : Comparable {
    func sorted() -> [Element]
    func sort() -> [Element]
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension LazyMapSequence where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension LazyMapSequence where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
LazySequenceProtocol
Base : Sequence

DeclarationProtocolsGenerics[Constraints]
From
struct LazySequence<Base : SequenceType> : LazySequenceType, _SequenceWrapperType {
    init(_ base: Base)
    var elements: Base { get }
    typealias S = Void
}
LazySequenceType
Base : SequenceType
To
struct LazySequence<Base : Sequence> : LazySequenceProtocol, _SequenceWrapper {
    var elements: Base { get }
    func sorted(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
    func sort(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
    func filter(_ isIncluded: @escaping (Base.Iterator.Element) -> Bool) -> LazyFilterSequence<Base>
    func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>>
    func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult>
    var lazy: LazySequence<LazySequence<Base>> { get }
    var array: [Base.Iterator.Element] { get }
    func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>
    func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T]
    func suffix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Base.Iterator.Element) throws -> Void) rethrows
    func first(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func dropFirst(_ n: Int) -> AnySequence<Base.Iterator.Element>
    func dropLast(_ n: Int) -> AnySequence<Base.Iterator.Element>
    func prefix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element>
    func dropFirst() -> AnySequence<Base.Iterator.Element>
    func dropLast() -> AnySequence<Base.Iterator.Element>
    func generate() -> Base.Iterator
    func underestimateCount() -> Int
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>]
    func enumerated() -> EnumeratedSequence<LazySequence<Base>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
    func reversed() -> [Base.Iterator.Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<LazySequence<Base>>
    func minElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func maxElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
    func reverse() -> [Base.Iterator.Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
    var underestimatedCount: Int { get }
    func makeIterator() -> Base.Iterator
    func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T]
}
extension LazySequence {
    var lazy: LazySequence<Base> { get }
}
extension LazySequence where Base == LazySequence<Base> {
    var elements: LazySequence<Base> { get }
}
extension LazySequence where Base.Iterator.Element : Sequence {
    func joined() -> FlattenSequence<LazySequence<Base>>
    func flatten() -> FlattenSequence<LazySequence<Base>>
    func joined() -> LazySequence<FlattenSequence<Base>>
    func flatten() -> LazySequence<FlattenSequence<Base>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazySequence<Base>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazySequence<Base>>
}
extension LazySequence where Base.Iterator.Element : Comparable {
    func sorted() -> [Base.Iterator.Element]
    func sort() -> [Base.Iterator.Element]
    @warn_unqualified_access
    func min() -> Base.Iterator.Element?
    @warn_unqualified_access
    func max() -> Base.Iterator.Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Base.Iterator.Element?
    func maxElement() -> Base.Iterator.Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension LazySequence where Base.Iterator.Element : Equatable {
    func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element>]
    func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool
}
extension LazySequence where Base.Iterator.Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
LazySequenceProtocol
Base : Sequence

Modified ManagedBuffer
DeclarationSuperclassesGenerics[Parameters]
From
class ManagedBuffer<Value, Element> : ManagedProtoBuffer<Value, Element> {
    final class func create(_ minimumCapacity: Int, initialValue initialValue: (ManagedProtoBuffer<Value, Element>) -> Value) -> ManagedBuffer<Value, Element>
    final var value: Value
}
ManagedProtoBufferValue, Element
To
class ManagedBuffer<Header, Element> {
    final class func create(minimumCapacity minimumCapacity: Int, makingHeaderWith factory: (ManagedBuffer<Header, Element>) throws -> Header) rethrows -> ManagedBuffer<Header, Element>
    final var capacity: Int { get }
    final func withUnsafeMutablePointerToHeader<R>(_ body: (UnsafeMutablePointer<Header>) throws -> R) rethrows -> R
    final func withUnsafeMutablePointerToElements<R>(_ body: (UnsafeMutablePointer<Element>) throws -> R) rethrows -> R
    final func withUnsafeMutablePointers<R>(_ body: (UnsafeMutablePointer<Header>, UnsafeMutablePointer<Element>) throws -> R) rethrows -> R
    final var header: Header
    final class func create(_ minimumCapacity: Int, initialValue initialValue: (ManagedBuffer<Header, Element>) -> Header) -> ManagedBuffer<Header, Element>
}
--Header, Element

DeclarationGenerics[Parameters]
From
struct ManagedBufferPointer<Value, Element> : Equatable {
    init(bufferClass bufferClass: AnyClass, minimumCapacity minimumCapacity: Int, initialValue initialValue: (buffer: AnyObject, allocatedCount: (AnyObject) -> Int) -> Value)
    init(unsafeBufferObject buffer: AnyObject)
    var value: Value
    var buffer: AnyObject { get }
    var allocatedElementCount: Int { get }
    func withUnsafeMutablePointerToValue<R>(_ body: (UnsafeMutablePointer<Value>) -> R) -> R
    func withUnsafeMutablePointerToElements<R>(_ body: (UnsafeMutablePointer<Element>) -> R) -> R
    func withUnsafeMutablePointers<R>(_ body: (UnsafeMutablePointer<Value>, UnsafeMutablePointer<Element>) -> R) -> R
    mutating func holdsUniqueReference() -> Bool
    mutating func holdsUniqueOrPinnedReference() -> Bool
}
Value, Element
To
struct ManagedBufferPointer<Header, Element> : Equatable {
    init(bufferClass bufferClass: Swift.AnyClass, minimumCapacity minimumCapacity: Int, makingHeaderWith factory: (AnyObject, (AnyObject) -> Int) throws -> Header) rethrows
    init(unsafeBufferObject buffer: AnyObject)
    var header: Header
    var buffer: AnyObject { get }
    var capacity: Int { get }
    func withUnsafeMutablePointerToHeader<R>(_ body: (UnsafeMutablePointer<Header>) throws -> R) rethrows -> R
    func withUnsafeMutablePointerToElements<R>(_ body: (UnsafeMutablePointer<Element>) throws -> R) rethrows -> R
    func withUnsafeMutablePointers<R>(_ body: (UnsafeMutablePointer<Header>, UnsafeMutablePointer<Element>) throws -> R) rethrows -> R
    mutating func isUniqueReference() -> Bool
    init(bufferClass bufferClass: Swift.AnyClass, minimumCapacity minimumCapacity: Int, initialValue initialValue: (AnyObject, (AnyObject) -> Int) -> Header)
    var allocatedElementCount: Int { get }
    mutating func holdsUniqueReference() -> Bool
    mutating func holdsUniqueOrPinnedReference() -> Bool
}
Header, Element

Declaration
From
struct Mirror {
    enum AncestorRepresentation {
        case Generated
        case Customized(() -> Mirror)
        case Suppressed
    }
    init(reflecting subject: Any)
    typealias Child = (label: String?, value: Any)
    typealias Children = AnyForwardCollection<Child>
    enum DisplayStyle {
        case Struct
        case Class
        case Enum
        case Tuple
        case Optional
        case Collection
        case Dictionary
        case Set
    }
    init<T, C : CollectionType where C.Generator.Element == Child>(_ subject: T, children children: C, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default)
    init<T, C : CollectionType>(_ subject: T, unlabeledChildren unlabeledChildren: C, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default)
    init<T>(_ subject: T, children children: DictionaryLiteral<String, Any>, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default)
    let subjectType: Any.Type
    let children: Children
    let displayStyle: Mirror.DisplayStyle?
    @warn_unused_result
    func superclassMirror() -> Mirror?
}
extension Mirror {
    @warn_unused_result
    func descendant(_ first: MirrorPathType, _ rest: MirrorPathType...) -> Any?
}
extension Mirror : CustomStringConvertible {
    var description: String { get }
}
extension Mirror : CustomReflectable {
    @warn_unused_result
    func customMirror() -> Mirror
}
To
struct Mirror {
    enum AncestorRepresentation {
        case generated
        case customized(() -> Mirror)
        case suppressed
    }
    init(reflecting subject: Any)
    typealias Child = (label: String?, value: Any)
    typealias Children = AnyCollection<Mirror.Child>
    enum DisplayStyle {
        case `struct`
        case `class`
        case `enum`
        case tuple
        case optional
        case collection
        case dictionary
        case set
    }
    init<Subject, C : Collection where C.Iterator.Element == Child, C.SubSequence : Collection, C.SubSequence.Iterator.Element == Child, 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>(_ subject: Subject, children children: C, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default)
    init<Subject, C : Collection where C.SubSequence : Collection, C.SubSequence.SubSequence == C.SubSequence, C.Indices : Collection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ subject: Subject, unlabeledChildren unlabeledChildren: C, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default)
    init<Subject>(_ subject: Subject, children children: DictionaryLiteral<String, Any>, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default)
    let subjectType: Any.Type
    let children: Mirror.Children
    let displayStyle: Mirror.DisplayStyle?
    var superclassMirror: Mirror? { get }
    func descendant(_ first: MirrorPath, _ rest: MirrorPath...) -> Any?
}
extension Mirror : CustomStringConvertible {
    var description: String { get }
}
extension Mirror : CustomReflectable {
    var customMirror: Mirror { get }
}

Declaration
From
let children: Children
To
let children: Mirror.Children

DeclarationGenerics[Parameters]
From
init<T>(_ subject: T, children children: DictionaryLiteral<String, Any>, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default)
T
To
init<Subject>(_ subject: Subject, children children: DictionaryLiteral<String, Any>, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default)
Subject

Declaration
From
enum AncestorRepresentation {
        case Generated
        case Customized(() -> Mirror)
        case Suppressed
    }
To
enum AncestorRepresentation {
        case generated
        case customized(() -> Mirror)
        case suppressed
    }

Declaration
From
enum DisplayStyle {
        case Struct
        case Class
        case Enum
        case Tuple
        case Optional
        case Collection
        case Dictionary
        case Set
    }
To
enum DisplayStyle {
        case `struct`
        case `class`
        case `enum`
        case tuple
        case optional
        case collection
        case dictionary
        case set
    }

Modified MutableIndexable
DeclarationProtocolsDeprecation
From
protocol MutableIndexable {
    associatedtype Index : ForwardIndexType
    var startIndex: Self.Index { get }
    var endIndex: Self.Index { get }
    subscript (_ position: Self.Index) -> Self._Element { get set }
}
----
To
protocol MutableIndexable : Indexable {
    associatedtype Index : Comparable
    var startIndex: Self.Index { get }
    var endIndex: Self.Index { get }
    subscript(_ position: Self.Index) -> Self._Element { get set }
    associatedtype SubSequence
    subscript(_ bounds: Range<Self.Index>) -> Self.SubSequence { get set }
    func index(after i: Self.Index) -> Self.Index
    func formIndex(after i: inout Self.Index)
}
IndexabletvOS 10.0

Modified MutableIndexable.endIndex
Deprecation
From--
TotvOS 10.0

Modified MutableIndexable.startIndex
Deprecation
From--
TotvOS 10.0

Modified MutableIndexable.subscript(_: Self.Index) -> Self._Element
DeclarationDeprecation
From
subscript (_ position: Self.Index) -> Self._Element { get set }
--
To
subscript(_ position: Self.Index) -> Self._Element { get set }
tvOS 10.0

Modified MutableSlice [struct]
DeclarationProtocols
From
struct MutableSlice<Base : MutableIndexable> : MutableCollectionType {
    typealias Index = Base.Index
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (_ index: Base.Index) -> Base._Element
    subscript (_ bounds: Range<Base.Index>) -> MutableSlice<Base>
    init(base base: Base, bounds bounds: Range<Base.Index>)
}
MutableCollectionType
To
struct MutableSlice<Base : MutableIndexable> : Collection, MutableCollection {
    typealias Index = Base.Index
    typealias IndexDistance = Base.IndexDistance
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript(_ index: Base.Index) -> Base._Element
    typealias SubSequence = MutableSlice<Base>
    subscript(_ bounds: Range<Base.Index>) -> MutableSlice<Base>
    func index(after i: Base.Index) -> Base.Index
    func formIndex(after i: inout Base.Index)
    func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
    func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
    func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
    init(base base: Base, bounds bounds: Range<Base.Index>)
    var base: Base { get }
    mutating func popFirst() -> Base._Element?
    func map<T>(_ transform: (Base._Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> MutableSlice<Base>
    func dropLast(_ n: Int) -> MutableSlice<Base>
    func prefix(_ maxLength: Int) -> MutableSlice<Base>
    func suffix(_ maxLength: Int) -> MutableSlice<Base>
    func prefix(upTo end: Base.Index) -> MutableSlice<Base>
    func suffix(from start: Base.Index) -> MutableSlice<Base>
    func prefix(through position: Base.Index) -> MutableSlice<Base>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableSlice<Base>]
    mutating func removeFirst() -> Base._Element
    mutating func removeFirst(_ n: Int)
    typealias Generator = IndexingIterator<MutableSlice<Base>>
    func generate() -> IndexingIterator<MutableSlice<Base>>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableSlice<Base>]
    func index(where predicate: (Base._Element) throws -> Bool) rethrows -> Base.Index?
    mutating func partition(by belongsInSecondPartition: (Base._Element) throws -> Bool) rethrows -> Base.Index
    func sorted(by areInIncreasingOrder: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
    subscript(_ bounds: ClosedRange<Base.Index>) -> MutableSlice<Base> { get }
    subscript(_ bounds: ClosedRange<Base.Index>) -> MutableSlice<Base>
    func sort(_ isOrderedBefore: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
    func indexOf(_ predicate: (Base._Element) throws -> Bool) rethrows -> Base.Index?
    var indices: DefaultIndices<MutableSlice<Base>> { get }
    var lazy: LazySequence<MutableSlice<Base>> { get }
    subscript(_ bounds: Range<Base.Index>) -> MutableSlice<MutableSlice<Base>>
    func map<T>(_ transform: (Base._Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Base._Element) throws -> Void) rethrows
    func first(where predicate: (Base._Element) throws -> Bool) rethrows -> Base._Element?
    func dropFirst() -> MutableSlice<Base>
    func dropLast() -> MutableSlice<Base>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableSlice<Base>]
    func enumerated() -> EnumeratedSequence<MutableSlice<Base>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, by areEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Base._Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base._Element) throws -> Result) rethrows -> Result
    func reversed() -> [Base._Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<MutableSlice<Base>>
    func minElement(_ isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
    func maxElement(_ isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
    func reverse() -> [Base._Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Base._Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Base._Element) throws -> Result) rethrows -> Result
}
extension MutableSlice {
    func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance)
    func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Bool
}
extension MutableSlice {
    func makeIterator() -> IndexingIterator<MutableSlice<Base>>
}
extension MutableSlice {
    var isEmpty: Bool { get }
    var first: Base._Element? { get }
    var underestimatedCount: Int { get }
    var count: Base.IndexDistance { get }
}
extension MutableSlice {
    var lazy: LazyCollection<MutableSlice<Base>> { get }
}
extension MutableSlice where Base._Element : Collection {
    func joined() -> FlattenCollection<MutableSlice<Base>>
    func flatten() -> FlattenCollection<MutableSlice<Base>>
}
extension MutableSlice where Base._Element : Equatable {
    func split(separator separator: Base._Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [MutableSlice<Base>]
    func split(_ separator: Base._Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [MutableSlice<Base>]
    func index(of element: Base._Element) -> Base.Index?
    func split(separator separator: Base._Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base._Element>]
    func split(_ separator: Base._Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base._Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool
}
extension MutableSlice where Base._Element : Sequence {
    func joined() -> FlattenSequence<MutableSlice<Base>>
    func flatten() -> FlattenSequence<MutableSlice<Base>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<MutableSlice<Base>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<MutableSlice<Base>>
}
extension MutableSlice where Base._Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension MutableSlice where Base._Element : Comparable {
    func sorted() -> [Base._Element]
    func sorted() -> [Base._Element]
    func sort() -> [Base._Element]
    @warn_unqualified_access
    func min() -> Base._Element?
    @warn_unqualified_access
    func max() -> Base._Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Base._Element?
    func maxElement() -> Base._Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool
}
extension MutableSlice where Base.Index : Strideable, Index.Stride : SignedInteger {
    subscript(_ bounds: CountableRange<Base.Index>) -> MutableSlice<Base> { get }
    subscript(_ bounds: CountableClosedRange<Base.Index>) -> MutableSlice<Base> { get }
    subscript(_ bounds: CountableRange<Base.Index>) -> MutableSlice<Base>
    subscript(_ bounds: CountableClosedRange<Base.Index>) -> MutableSlice<Base>
}
Collection, MutableCollection

Modified MutableSlice.init(base: Base, bounds: Range<Base.Index>)
Deprecation
FromtvOS 9.2
To--

Modified MutableSlice.subscript(_: Range<Base.Index>) -> MutableSlice<Base>
Declaration
From
subscript (_ bounds: Range<Base.Index>) -> MutableSlice<Base>
To
subscript(_ bounds: Range<Base.Index>) -> MutableSlice<Base>

Modified MutableSlice.subscript(_: Base.Index) -> Base._Element
Declaration
From
subscript (_ index: Base.Index) -> Base._Element
To
subscript(_ index: Base.Index) -> Base._Element

DeclarationProtocols
From
struct ObjectIdentifier : Hashable, Comparable {
    var uintValue: UInt { get }
    var hashValue: Int { get }
    init(_ x: AnyObject)
    init(_ x: Any.Type)
}
Comparable, Hashable
To
struct ObjectIdentifier : Hashable {
    var hashValue: Int { get }
    init(_ x: AnyObject)
    init(_ x: Any.Type)
    var uintValue: UInt { get }
}
extension ObjectIdentifier : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension ObjectIdentifier : Comparable {
    static func <(_ lhs: ObjectIdentifier, _ rhs: ObjectIdentifier) -> Bool
    static func ==(_ x: ObjectIdentifier, _ y: ObjectIdentifier) -> Bool
}
Comparable, CustomDebugStringConvertible, Hashable

DeclarationProtocols
From
enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible {
    case None
    case Some(Wrapped)
    typealias T = Wrapped
    init()
    init(_ some: Wrapped)
    @warn_unused_result
    func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U?
    @warn_unused_result
    func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U?
    init(nilLiteral nilLiteral: ())
}
extension Optional : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
CustomDebugStringConvertible, NilLiteralConvertible
To
enum Optional<Wrapped> : ExpressibleByNilLiteral {
    case none
    case some(Wrapped)
    init(_ some: Wrapped)
    func map<U>(_ transform: (Wrapped) throws -> U) rethrows -> U?
    func flatMap<U>(_ transform: (Wrapped) throws -> U?) rethrows -> U?
    init(nilLiteral nilLiteral: ())
    var unsafelyUnwrapped: Wrapped { get }
    static var None: Wrapped? { get }
    static func Some(_ x: Wrapped) -> Wrapped?
}
extension Optional : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Optional : CustomReflectable {
    var customMirror: Mirror { get }
}
CustomDebugStringConvertible, CustomReflectable, ExpressibleByNilLiteral

Declaration
From
@warn_unused_result
    func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U?
To
func flatMap<U>(_ transform: (Wrapped) throws -> U?) rethrows -> U?

Declaration
From
@warn_unused_result
    func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U?
To
func map<U>(_ transform: (Wrapped) throws -> U) rethrows -> U?

Declaration
From
enum PlaygroundQuickLook {
    case Text(String)
    case Int(Int64)
    case UInt(UInt64)
    case Float(Float32)
    case Double(Float64)
    case Image(Any)
    case Sound(Any)
    case Color(Any)
    case BezierPath(Any)
    case AttributedString(Any)
    case Rectangle(Float64, Float64, Float64, Float64)
    case Point(Float64, Float64)
    case Size(Float64, Float64)
    case Logical(Bool)
    case Range(Int64, Int64)
    case View(Any)
    case Sprite(Any)
    case URL(String)
}
extension PlaygroundQuickLook {
    init(reflecting subject: Any)
}
To
enum PlaygroundQuickLook {
    case text(String)
    case int(Int64)
    case uInt(UInt64)
    case float(Float32)
    case double(Float64)
    case image(Any)
    case sound(Any)
    case color(Any)
    case bezierPath(Any)
    case attributedString(Any)
    case rectangle(Float64, Float64, Float64, Float64)
    case point(Float64, Float64)
    case size(Float64, Float64)
    case bool(Bool)
    case range(Int64, Int64)
    case view(Any)
    case sprite(Any)
    case url(String)
    case _raw([UInt8], String)
    init(reflecting subject: Any)
}

DeclarationProtocolsGenerics[Constraints]Generics[Parameters]
From
struct Range<Element : ForwardIndexType> : Equatable, CollectionType, CustomStringConvertible, CustomDebugStringConvertible {
    typealias T = Element
    init(_ x: Range<Element>)
    init(start start: Element, end end: Element)
    subscript (_ position: Element) -> Element { get }
    subscript (_ _: Element._DisabledRangeIndex) -> Element { get }
    func generate() -> RangeGenerator<Element>
    var startIndex: Element
    var endIndex: Element
    var description: String { get }
    var debugDescription: String { get }
}
extension Range : _Reflectable {
}
CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Equatable
Element : ForwardIndexType
Element
To
struct Range<Bound : Comparable> {
    init(uncheckedBounds bounds: (lower: Bound, upper: Bound))
    let lowerBound: Bound
    let upperBound: Bound
    func contains(_ element: Bound) -> Bool
    var isEmpty: Bool { get }
    init(_ other: Range<Bound>)
    func overlaps(_ other: Range<Bound>) -> Bool
    func overlaps(_ other: ClosedRange<Bound>) -> Bool
    func clamped(to limits: Range<Bound>) -> Range<Bound>
    var startIndex: Bound { get }
    var endIndex: Bound { get }
}
extension Range : CustomStringConvertible {
    var description: String { get }
}
extension Range : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Range : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Range : Equatable {
    static func ==(_ lhs: Range<Bound>, _ rhs: Range<Bound>) -> Bool
    static func ~=(_ pattern: Range<Bound>, _ value: Bound) -> Bool
}
CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, Equatable
Bound : Comparable
Bound

Modified Range.init(_: Range<Bound>)
Declaration
From
init(_ x: Range<Element>)
To
init(_ other: Range<Bound>)

Modified Set [struct]
DeclarationProtocols
From
struct Set<Element : Hashable> : Hashable, CollectionType, ArrayLiteralConvertible {
    typealias T = Element
    typealias Index = SetIndex<Element>
    init(minimumCapacity minimumCapacity: Int)
    var startIndex: SetIndex<Element> { get }
    var endIndex: SetIndex<Element> { get }
    @warn_unused_result
    func contains(_ member: Element) -> Bool
    @warn_unused_result
    func indexOf(_ member: Element) -> SetIndex<Element>?
    mutating func insert(_ member: Element)
    mutating func remove(_ member: Element) -> Element?
    mutating func removeAtIndex(_ index: SetIndex<Element>) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    mutating func removeFirst() -> Element
    var count: Int { get }
    subscript (_ position: SetIndex<Element>) -> Element { get }
    func generate() -> SetGenerator<Element>
    init(arrayLiteral elements: Element...)
    init()
    init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func isSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isStrictSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isStrictSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isDisjointWith<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func union<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func unionInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func subtract<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func subtractInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func intersect<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func intersectInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func exclusiveOr<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func exclusiveOrInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    var hashValue: Int { get }
    var isEmpty: Bool { get }
    var first: Element? { get }
}
extension Set : _ObjectiveCBridgeable {
}
extension Set : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Set : _Reflectable {
}
extension Set {
    mutating func popFirst() -> Element?
}
ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Hashable
To
struct Set<Element : Hashable> : SetAlgebra, Hashable, Collection, ExpressibleByArrayLiteral {
    typealias Index = SetIndex<Element>
    init(minimumCapacity minimumCapacity: Int)
    var startIndex: SetIndex<Element> { get }
    var endIndex: SetIndex<Element> { get }
    func index(after i: SetIndex<Element>) -> SetIndex<Element>
    func contains(_ member: Element) -> Bool
    func index(of member: Element) -> SetIndex<Element>?
    mutating func insert(_ newMember: Element) -> (inserted: Bool, memberAfterInsert: Element)
    mutating func update(with newMember: Element) -> Element?
    mutating func remove(_ member: Element) -> Element?
    mutating func remove(at position: SetIndex<Element>) -> Element
    mutating func removeAll(keepingCapacity keepCapacity: Bool = default)
    mutating func removeFirst() -> Element
    var count: Int { get }
    subscript(_ position: SetIndex<Element>) -> Element { get }
    func makeIterator() -> SetIterator<Element>
    init(arrayLiteral elements: Element...)
    init()
    init<Source : Sequence where Source.Iterator.Element == Element>(_ sequence: Source)
    func isSubset<S : Sequence where S.Iterator.Element == Element>(of possibleSuperset: S) -> Bool
    func isStrictSubset<S : Sequence where S.Iterator.Element == Element>(of possibleStrictSuperset: S) -> Bool
    func isSuperset<S : Sequence where S.Iterator.Element == Element>(of possibleSubset: S) -> Bool
    func isStrictSuperset<S : Sequence where S.Iterator.Element == Element>(of possibleStrictSubset: S) -> Bool
    func isDisjoint<S : Sequence where S.Iterator.Element == Element>(with other: S) -> Bool
    func union<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Set<Element>
    mutating func formUnion<S : Sequence where S.Iterator.Element == Element>(_ other: S)
    func subtracting<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Set<Element>
    mutating func subtract<S : Sequence where S.Iterator.Element == Element>(_ other: S)
    func intersection<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Set<Element>
    mutating func formIntersection<S : Sequence where S.Iterator.Element == Element>(_ other: S)
    func symmetricDifference<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Set<Element>
    mutating func formSymmetricDifference<S : Sequence where S.Iterator.Element == Element>(_ other: S)
    var hashValue: Int { get }
    var isEmpty: Bool { get }
    var first: Element? { get }
    static func ==(_ lhs: Set<Element>, _ rhs: Set<Element>) -> Bool
    mutating func popFirst() -> Element?
    mutating func subtract(_ other: Set<Element>)
    func isSubset(of other: Set<Element>) -> Bool
    func isSuperset(of other: Set<Element>) -> Bool
    func isDisjoint(with other: Set<Element>) -> Bool
    func subtracting(_ other: Set<Element>) -> Set<Element>
    func isStrictSuperset(of other: Set<Element>) -> Bool
    func isStrictSubset(of other: Set<Element>) -> Bool
    func intersection(_ other: Set<Element>) -> Set<Element>
    mutating func formSymmetricDifference(_ other: Set<Element>)
    mutating func removeAtIndex(_ index: SetIndex<Element>) -> Element
    func generate() -> SetIterator<Element>
    func indexOf(_ member: Element) -> SetIndex<Element>?
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> Slice<Set<Element>>
    func dropLast(_ n: Int) -> Slice<Set<Element>>
    func prefix(_ maxLength: Int) -> Slice<Set<Element>>
    func suffix(_ maxLength: Int) -> Slice<Set<Element>>
    func prefix(upTo end: SetIndex<Element>) -> Slice<Set<Element>>
    func suffix(from start: SetIndex<Element>) -> Slice<Set<Element>>
    func prefix(through position: SetIndex<Element>) -> Slice<Set<Element>>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<Set<Element>>]
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [Slice<Set<Element>>]
    typealias Generator = SetIterator<Element>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<Set<Element>>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [Slice<Set<Element>>]
    func index(where predicate: (Element) throws -> Bool) rethrows -> SetIndex<Element>?
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    subscript(_ bounds: ClosedRange<SetIndex<Element>>) -> Slice<Set<Element>> { get }
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    var indices: DefaultIndices<Set<Element>> { get }
    var lazy: LazySequence<Set<Element>> { get }
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> Slice<Set<Element>>
    func dropLast() -> Slice<Set<Element>>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<Set<Element>>]
    func enumerated() -> EnumeratedSequence<Set<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func reversed() -> [Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<Set<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func reverse() -> [Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
    func intersect(_ other: Set<Element>) -> Set<Element>
    func exclusiveOr(_ other: Set<Element>) -> Set<Element>
    mutating func unionInPlace(_ other: Set<Element>)
    mutating func intersectInPlace(_ other: Set<Element>)
    mutating func exclusiveOrInPlace(_ other: Set<Element>)
    func isSubsetOf(_ other: Set<Element>) -> Bool
    func isDisjointWith(_ other: Set<Element>) -> Bool
    func isSupersetOf(_ other: Set<Element>) -> Bool
    mutating func subtractInPlace(_ other: Set<Element>)
    func isStrictSupersetOf(_ other: Set<Element>) -> Bool
    func isStrictSubsetOf(_ other: Set<Element>) -> Bool
}
extension Set {
}
extension Set : CVarArg {
}
extension Set {
    subscript(_ bounds: Range<SetIndex<Element>>) -> Slice<Set<Element>> { get }
}
extension Set {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension Set {
    func formIndex(after i: inout SetIndex<Element>)
    func index(_ i: SetIndex<Element>, offsetBy n: Int) -> SetIndex<Element>
    func index(_ i: SetIndex<Element>, offsetBy n: Int, limitedBy limit: SetIndex<Element>) -> SetIndex<Element>?
    func formIndex(_ i: inout SetIndex<Element>, offsetBy n: Int)
    func formIndex(_ i: inout SetIndex<Element>, offsetBy n: Int, limitedBy limit: SetIndex<Element>) -> Bool
    func distance(from start: SetIndex<Element>, to end: SetIndex<Element>) -> Int
}
extension Set {
    var lazy: LazyCollection<Set<Element>> { get }
}
extension Set {
    convenience init<S : Sequence where S.Iterator.Element == Element>(_ sequence: S)
    convenience init(arrayLiteral arrayLiteral: Element...)
    mutating func subtract(_ other: Set<Element>)
    var isEmpty: Bool { get }
}
extension Set : CustomReflectable {
    var customMirror: Mirror { get }
}
extension Set : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Set where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension Set where Element : Sequence {
    func joined() -> FlattenSequence<Set<Element>>
    func flatten() -> FlattenSequence<Set<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<Set<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<Set<Element>>
}
extension Set where Element : Comparable {
    func sorted() -> [Element]
    func sort() -> [Element]
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension Set where Element : Collection {
    func joined() -> FlattenCollection<Set<Element>>
    func flatten() -> FlattenCollection<Set<Element>>
}
extension Set where Element : _AnyHashableProtocol {
    mutating func insert<ConcreteElement : Hashable>(_ newMember: ConcreteElement) -> (inserted: Bool, memberAfterInsert: ConcreteElement)
    mutating func update<ConcreteElement : Hashable>(with newMember: ConcreteElement) -> ConcreteElement?
    mutating func remove<ConcreteElement : Hashable>(_ member: ConcreteElement) -> ConcreteElement?
}
CVarArg, Collection, CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, ExpressibleByArrayLiteral, Hashable, SetAlgebra

Declaration
From
@warn_unused_result
    func contains(_ member: Element) -> Bool
To
func contains(_ member: Element) -> Bool

Modified Set.subscript(_: SetIndex<Element>) -> Element
Declaration
From
subscript (_ position: SetIndex<Element>) -> Element { get }
To
subscript(_ position: SetIndex<Element>) -> Element { get }

Modified SetIndex [struct]
DeclarationProtocols
From
struct SetIndex<Element : Hashable> : ForwardIndexType, Comparable {
    typealias T = Element
    func successor() -> SetIndex<Element>
}
Comparable, ForwardIndexType
To
struct SetIndex<Element : Hashable> : Comparable {
    static func ==(_ lhs: SetIndex<Element>, _ rhs: SetIndex<Element>) -> Bool
    static func <(_ lhs: SetIndex<Element>, _ rhs: SetIndex<Element>) -> Bool
}
Comparable

DeclarationProtocols
From
struct Slice<Base : Indexable> : CollectionType {
    typealias Index = Base.Index
    let startIndex: Base.Index
    let endIndex: Base.Index
    subscript (_ index: Base.Index) -> Base._Element { get }
    subscript (_ bounds: Range<Base.Index>) -> Slice<Base> { get }
    init(base base: Base, bounds bounds: Range<Base.Index>)
}
CollectionType
To
struct Slice<Base : Indexable> : Collection {
    typealias Index = Base.Index
    typealias IndexDistance = Base.IndexDistance
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript(_ index: Base.Index) -> Base._Element { get }
    typealias SubSequence = Slice<Base>
    subscript(_ bounds: Range<Base.Index>) -> Slice<Base> { get }
    func index(after i: Base.Index) -> Base.Index
    func formIndex(after i: inout Base.Index)
    func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
    func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
    func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
    init(base base: Base, bounds bounds: Range<Base.Index>)
    var base: Base { get }
    mutating func popFirst() -> Base._Element?
    func map<T>(_ transform: (Base._Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> Slice<Base>
    func dropLast(_ n: Int) -> Slice<Base>
    func prefix(_ maxLength: Int) -> Slice<Base>
    func suffix(_ maxLength: Int) -> Slice<Base>
    func prefix(upTo end: Base.Index) -> Slice<Base>
    func suffix(from start: Base.Index) -> Slice<Base>
    func prefix(through position: Base.Index) -> Slice<Base>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [Slice<Base>]
    mutating func removeFirst() -> Base._Element
    mutating func removeFirst(_ n: Int)
    typealias Generator = IndexingIterator<Slice<Base>>
    func generate() -> IndexingIterator<Slice<Base>>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [Slice<Base>]
    func index(where predicate: (Base._Element) throws -> Bool) rethrows -> Base.Index?
    func sorted(by areInIncreasingOrder: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
    subscript(_ bounds: ClosedRange<Base.Index>) -> Slice<Base> { get }
    func sort(_ isOrderedBefore: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
    func indexOf(_ predicate: (Base._Element) throws -> Bool) rethrows -> Base.Index?
    var indices: DefaultIndices<Slice<Base>> { get }
    var lazy: LazySequence<Slice<Base>> { get }
    func map<T>(_ transform: (Base._Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Base._Element) throws -> Void) rethrows
    func first(where predicate: (Base._Element) throws -> Bool) rethrows -> Base._Element?
    func dropFirst() -> Slice<Base>
    func dropLast() -> Slice<Base>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [Slice<Base>]
    func enumerated() -> EnumeratedSequence<Slice<Base>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, by areEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Base._Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base._Element) throws -> Result) rethrows -> Result
    func reversed() -> [Base._Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<Slice<Base>>
    func minElement(_ isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
    func maxElement(_ isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
    func reverse() -> [Base._Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Base._Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Base._Element) throws -> Result) rethrows -> Result
}
extension Slice {
    func makeIterator() -> IndexingIterator<Slice<Base>>
}
extension Slice {
    func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance)
    func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Bool
}
extension Slice {
    var isEmpty: Bool { get }
    var first: Base._Element? { get }
    var underestimatedCount: Int { get }
    var count: Base.IndexDistance { get }
}
extension Slice {
    var lazy: LazyCollection<Slice<Base>> { get }
}
extension Slice where Base._Element : Collection {
    func joined() -> FlattenCollection<Slice<Base>>
    func flatten() -> FlattenCollection<Slice<Base>>
}
extension Slice where Base._Element : Equatable {
    func split(separator separator: Base._Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [Slice<Base>]
    func split(_ separator: Base._Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [Slice<Base>]
    func index(of element: Base._Element) -> Base.Index?
    func split(separator separator: Base._Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base._Element>]
    func split(_ separator: Base._Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base._Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool
}
extension Slice where Base._Element : Comparable {
    func sorted() -> [Base._Element]
    func sort() -> [Base._Element]
    @warn_unqualified_access
    func min() -> Base._Element?
    @warn_unqualified_access
    func max() -> Base._Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Base._Element?
    func maxElement() -> Base._Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool
}
extension Slice where Base._Element : Sequence {
    func joined() -> FlattenSequence<Slice<Base>>
    func flatten() -> FlattenSequence<Slice<Base>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<Slice<Base>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<Slice<Base>>
}
extension Slice where Base._Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension Slice where Slice<Base> == Slice<Self> {
    subscript(_ bounds: Range<Base.Index>) -> Slice<Slice<Base>> { get }
}
extension Slice where Base.Index : Strideable, Index.Stride : SignedInteger {
    subscript(_ bounds: CountableRange<Base.Index>) -> Slice<Base> { get }
    subscript(_ bounds: CountableClosedRange<Base.Index>) -> Slice<Base> { get }
}
Collection

DeclarationReadonly
From
let endIndex: Base.Index
--
To
var endIndex: Base.Index { get }
yes

Deprecation
FromtvOS 9.2
To--

DeclarationReadonly
From
let startIndex: Base.Index
--
To
var startIndex: Base.Index { get }
yes

Modified Slice.subscript(_: Base.Index) -> Base._Element
Declaration
From
subscript (_ index: Base.Index) -> Base._Element { get }
To
subscript(_ index: Base.Index) -> Base._Element { get }

Modified Slice.subscript(_: Range<Base.Index>) -> Slice<Base>
Declaration
From
subscript (_ bounds: Range<Base.Index>) -> Slice<Base> { get }
To
subscript(_ bounds: Range<Base.Index>) -> Slice<Base> { get }

DeclarationProtocols
From
struct StaticString : UnicodeScalarLiteralConvertible, ExtendedGraphemeClusterLiteralConvertible, StringLiteralConvertible, CustomStringConvertible, CustomDebugStringConvertible, _Reflectable {
    var utf8Start: UnsafePointer<UInt8> { get }
    var unicodeScalar: UnicodeScalar { get }
    var byteSize: Int { get }
    var hasPointerRepresentation: Bool { get }
    var isASCII: Bool { get }
    func withUTF8Buffer<R>(@noescape _ body: (UnsafeBufferPointer<UInt8>) -> R) -> R
    var stringValue: String { get }
    init()
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
    init(unicodeScalarLiteral value: StaticString)
    init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    init(extendedGraphemeClusterLiteral value: StaticString)
    init(_builtinStringLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    init(stringLiteral value: StaticString)
    var description: String { get }
    var debugDescription: String { get }
}
CustomDebugStringConvertible, CustomStringConvertible, ExtendedGraphemeClusterLiteralConvertible, StringLiteralConvertible, UnicodeScalarLiteralConvertible
To
struct StaticString : ExpressibleByUnicodeScalarLiteral, ExpressibleByExtendedGraphemeClusterLiteral, ExpressibleByStringLiteral, CustomStringConvertible, CustomDebugStringConvertible, CustomReflectable {
    var utf8Start: UnsafePointer<UInt8> { get }
    var unicodeScalar: UnicodeScalar { get }
    var utf8CodeUnitCount: Int { get }
    var hasPointerRepresentation: Bool { get }
    var isASCII: Bool { get }
    func withUTF8Buffer<R>(_ body: (UnsafeBufferPointer<UInt8>) -> R) -> R
    init()
    init(unicodeScalarLiteral value: StaticString)
    init(extendedGraphemeClusterLiteral value: StaticString)
    init(stringLiteral value: StaticString)
    var description: String { get }
    var debugDescription: String { get }
    var customMirror: Mirror { get }
    var byteSize: Int { get }
    var stringValue: String { get }
}
CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, ExpressibleByExtendedGraphemeClusterLiteral, ExpressibleByStringLiteral, ExpressibleByUnicodeScalarLiteral

Declaration
From
func withUTF8Buffer<R>(@noescape _ body: (UnsafeBufferPointer<UInt8>) -> R) -> R
To
func withUTF8Buffer<R>(_ body: (UnsafeBufferPointer<UInt8>) -> R) -> R

Modified Strideable
Declaration
From
protocol Strideable : Comparable {
    associatedtype Stride : SignedNumberType
    @warn_unused_result
    func distanceTo(_ other: Self) -> Self.Stride
    @warn_unused_result
    func advancedBy(_ n: Self.Stride) -> Self
}
To
protocol Strideable : Comparable {
    associatedtype Stride : SignedNumber
    func distance(to other: Self) -> Self.Stride
    func advanced(by n: Self.Stride) -> Self
}

DeclarationProtocols
From
struct StrideThrough<Element : Strideable> : SequenceType {
    typealias T = Element
    func generate() -> StrideThroughGenerator<Element>
}
extension StrideThrough : _Reflectable {
}
SequenceType
To
struct StrideThrough<Element : Strideable> : Sequence, CustomReflectable {
    func makeIterator() -> StrideThroughIterator<Element>
    var customMirror: Mirror { get }
    func sorted() -> [Element]
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    func sort() -> [Element]
    var lazy: LazySequence<StrideThrough<Element>> { get }
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    func suffix(_ maxLength: Int) -> AnySequence<Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func dropFirst(_ n: Int) -> AnySequence<Element>
    func dropLast(_ n: Int) -> AnySequence<Element>
    func prefix(_ maxLength: Int) -> AnySequence<Element>
    func dropFirst() -> AnySequence<Element>
    func dropLast() -> AnySequence<Element>
    func generate() -> StrideThroughIterator<Element>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func enumerated() -> EnumeratedSequence<StrideThrough<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func contains(_ element: Element) -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func reversed() -> [Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<StrideThrough<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func reverse() -> [Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension StrideThrough where Element : Sequence {
    func joined() -> FlattenSequence<StrideThrough<Element>>
    func flatten() -> FlattenSequence<StrideThrough<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<StrideThrough<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<StrideThrough<Element>>
}
extension StrideThrough where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
CustomReflectable, Sequence

DeclarationProtocols
From
struct StrideTo<Element : Strideable> : SequenceType {
    typealias T = Element
    func generate() -> StrideToGenerator<Element>
}
extension StrideTo : _Reflectable {
}
SequenceType
To
struct StrideTo<Element : Strideable> : Sequence, CustomReflectable {
    func makeIterator() -> StrideToIterator<Element>
    var customMirror: Mirror { get }
    func sorted() -> [Element]
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    func sort() -> [Element]
    var lazy: LazySequence<StrideTo<Element>> { get }
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    func suffix(_ maxLength: Int) -> AnySequence<Element>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func dropFirst(_ n: Int) -> AnySequence<Element>
    func dropLast(_ n: Int) -> AnySequence<Element>
    func prefix(_ maxLength: Int) -> AnySequence<Element>
    func dropFirst() -> AnySequence<Element>
    func dropLast() -> AnySequence<Element>
    func generate() -> StrideToIterator<Element>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func enumerated() -> EnumeratedSequence<StrideTo<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func contains(_ element: Element) -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func reversed() -> [Element]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<StrideTo<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func reverse() -> [Element]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension StrideTo where Element : Sequence {
    func joined() -> FlattenSequence<StrideTo<Element>>
    func flatten() -> FlattenSequence<StrideTo<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<StrideTo<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<StrideTo<Element>>
}
extension StrideTo where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
CustomReflectable, Sequence

DeclarationProtocols
From
struct String {
    init()
}
extension String {
    @warn_unused_result
    static func availableStringEncodings() -> [NSStringEncoding]
    @warn_unused_result
    static func defaultCStringEncoding() -> NSStringEncoding
    @warn_unused_result
    static func localizedNameOfStringEncoding(_ encoding: NSStringEncoding) -> String
    @warn_unused_result
    static func localizedStringWithFormat(_ format: String, _ arguments: CVarArgType...) -> String
    static func pathWithComponents(_ components: [String]) -> String
    init?(UTF8String bytes: UnsafePointer<CChar>)
    @warn_unused_result
    func canBeConvertedToEncoding(_ encoding: NSStringEncoding) -> Bool
    var capitalizedString: String { get }
    var localizedCapitalizedString: String { get }
    @warn_unused_result
    func capitalizedStringWithLocale(_ locale: NSLocale?) -> String
    @warn_unused_result
    func caseInsensitiveCompare(_ aString: String) -> NSComparisonResult
    @warn_unused_result
    func commonPrefixWithString(_ aString: String, options options: NSStringCompareOptions) -> String
    @warn_unused_result
    func compare(_ aString: String, options mask: NSStringCompareOptions = default, range range: Range<Index>? = default, locale locale: NSLocale? = default) -> NSComparisonResult
    @warn_unused_result
    func completePathIntoString(_ outputName: UnsafeMutablePointer<String> = default, caseSensitive caseSensitive: Bool, matchesIntoArray matchesIntoArray: UnsafeMutablePointer<[String]> = default, filterTypes filterTypes: [String]? = default) -> Int
    @warn_unused_result
    func componentsSeparatedByCharactersInSet(_ separator: NSCharacterSet) -> [String]
    func componentsSeparatedByString(_ separator: String) -> [String]
    @warn_unused_result
    func cStringUsingEncoding(_ encoding: NSStringEncoding) -> [CChar]?
    @warn_unused_result
    func dataUsingEncoding(_ encoding: NSStringEncoding, allowLossyConversion allowLossyConversion: Bool = default) -> NSData?
    var decomposedStringWithCanonicalMapping: String { get }
    var decomposedStringWithCompatibilityMapping: String { get }
    func enumerateLines(_ body: (line: String, inout stop: Bool) -> ())
    func enumerateLinguisticTagsInRange(_ range: Range<Index>, scheme tagScheme: String, options opts: NSLinguisticTaggerOptions, orthography orthography: NSOrthography?, _ body: (String, Range<Index>, Range<Index>, inout Bool) -> ())
    func enumerateSubstringsInRange(_ range: Range<Index>, options opts: NSStringEnumerationOptions, _ body: (substring: String?, substringRange: Range<Index>, enclosingRange: Range<Index>, inout Bool) -> ())
    var fastestEncoding: NSStringEncoding { get }
    func fileSystemRepresentation() -> [CChar]
    func getBytes(inout _ buffer: [UInt8], maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding encoding: NSStringEncoding, options options: NSStringEncodingConversionOptions, range range: Range<Index>, remainingRange leftover: UnsafeMutablePointer<Range<Index>>) -> Bool
    func getCString(inout _ buffer: [CChar], maxLength maxLength: Int, encoding encoding: NSStringEncoding) -> Bool
    func getFileSystemRepresentation(inout _ buffer: [CChar], maxLength maxLength: Int) -> Bool
    func getLineStart(_ start: UnsafeMutablePointer<Index>, end end: UnsafeMutablePointer<Index>, contentsEnd contentsEnd: UnsafeMutablePointer<Index>, forRange forRange: Range<Index>)
    func getParagraphStart(_ start: UnsafeMutablePointer<Index>, end end: UnsafeMutablePointer<Index>, contentsEnd contentsEnd: UnsafeMutablePointer<Index>, forRange forRange: Range<Index>)
    var hash: Int { get }
    init?<S : SequenceType where S.Generator.Element == UInt8>(bytes bytes: S, encoding encoding: NSStringEncoding)
    init?(bytesNoCopy bytes: UnsafeMutablePointer<Void>, length length: Int, encoding encoding: NSStringEncoding, freeWhenDone flag: Bool)
    init(utf16CodeUnits utf16CodeUnits: UnsafePointer<unichar>, count count: Int)
    init(utf16CodeUnitsNoCopy utf16CodeUnitsNoCopy: UnsafePointer<unichar>, count count: Int, freeWhenDone flag: Bool)
    init(contentsOfFile path: String, encoding enc: NSStringEncoding) throws
    init(contentsOfFile path: String, usedEncoding usedEncoding: UnsafeMutablePointer<NSStringEncoding> = default) throws
    init(contentsOfURL url: NSURL, encoding enc: NSStringEncoding) throws
    init(contentsOfURL url: NSURL, usedEncoding enc: UnsafeMutablePointer<NSStringEncoding> = default) throws
    init?(CString CString: UnsafePointer<CChar>, encoding enc: NSStringEncoding)
    init?(data data: NSData, encoding encoding: NSStringEncoding)
    init(format format: String, _ arguments: CVarArgType...)
    init(format format: String, arguments arguments: [CVarArgType])
    init(format format: String, locale locale: NSLocale?, _ args: CVarArgType...)
    init(format format: String, locale locale: NSLocale?, arguments arguments: [CVarArgType])
    var lastPathComponent: String { get }
    var utf16Count: Int { get }
    @warn_unused_result
    func lengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int
    @warn_unused_result
    func lineRangeForRange(_ aRange: Range<Index>) -> Range<Index>
    @warn_unused_result
    func linguisticTagsInRange(_ range: Range<Index>, scheme tagScheme: String, options opts: NSLinguisticTaggerOptions = default, orthography orthography: NSOrthography? = default, tokenRanges tokenRanges: UnsafeMutablePointer<[Range<Index>]> = default) -> [String]
    @warn_unused_result
    func localizedCaseInsensitiveCompare(_ aString: String) -> NSComparisonResult
    @warn_unused_result
    func localizedCompare(_ aString: String) -> NSComparisonResult
    @warn_unused_result
    func localizedStandardCompare(_ string: String) -> NSComparisonResult
    var localizedLowercaseString: String { get }
    @warn_unused_result
    func lowercaseStringWithLocale(_ locale: NSLocale?) -> String
    @warn_unused_result
    func maximumLengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int
    @warn_unused_result
    func paragraphRangeForRange(_ aRange: Range<Index>) -> Range<Index>
    var pathComponents: [String] { get }
    var pathExtension: String { get }
    var precomposedStringWithCanonicalMapping: String { get }
    var precomposedStringWithCompatibilityMapping: String { get }
    @warn_unused_result
    func propertyList() -> AnyObject
    @warn_unused_result
    func propertyListFromStringsFileFormat() -> [String : String]
    @warn_unused_result
    func rangeOfCharacterFromSet(_ aSet: NSCharacterSet, options mask: NSStringCompareOptions = default, range aRange: Range<Index>? = default) -> Range<Index>?
    @warn_unused_result
    func rangeOfComposedCharacterSequenceAtIndex(_ anIndex: Index) -> Range<Index>
    @warn_unused_result
    func rangeOfComposedCharacterSequencesForRange(_ range: Range<Index>) -> Range<Index>
    @warn_unused_result
    func rangeOfString(_ aString: String, options mask: NSStringCompareOptions = default, range searchRange: Range<Index>? = default, locale locale: NSLocale? = default) -> Range<Index>?
    @warn_unused_result
    func localizedStandardContainsString(_ string: String) -> Bool
    @warn_unused_result
    func localizedStandardRangeOfString(_ string: String) -> Range<Index>?
    var smallestEncoding: NSStringEncoding { get }
    var stringByAbbreviatingWithTildeInPath: String { get }
    @warn_unused_result
    func stringByAddingPercentEncodingWithAllowedCharacters(_ allowedCharacters: NSCharacterSet) -> String?
    func stringByAddingPercentEscapesUsingEncoding(_ encoding: NSStringEncoding) -> String?
    @warn_unused_result
    func stringByAppendingFormat(_ format: String, _ arguments: CVarArgType...) -> String
    func stringByAppendingPathComponent(_ aString: String) -> String
    func stringByAppendingPathExtension(_ ext: String) -> String?
    @warn_unused_result
    func stringByAppendingString(_ aString: String) -> String
    var stringByDeletingLastPathComponent: String { get }
    var stringByDeletingPathExtension: String { get }
    var stringByExpandingTildeInPath: String { get }
    @warn_unused_result
    func stringByFoldingWithOptions(_ options: NSStringCompareOptions, locale locale: NSLocale?) -> String
    @warn_unused_result
    func stringByPaddingToLength(_ newLength: Int, withString padString: String, startingAtIndex padIndex: Int) -> String
    var stringByRemovingPercentEncoding: String? { get }
    @warn_unused_result
    func stringByReplacingCharactersInRange(_ range: Range<Index>, withString replacement: String) -> String
    @warn_unused_result
    func stringByReplacingOccurrencesOfString(_ target: String, withString replacement: String, options options: NSStringCompareOptions = default, range searchRange: Range<Index>? = default) -> String
    func stringByReplacingPercentEscapesUsingEncoding(_ encoding: NSStringEncoding) -> String?
    var stringByResolvingSymlinksInPath: String { get }
    var stringByStandardizingPath: String { get }
    @warn_unused_result
    func stringByTrimmingCharactersInSet(_ set: NSCharacterSet) -> String
    func stringsByAppendingPaths(_ paths: [String]) -> [String]
    @warn_unused_result
    func substringFromIndex(_ index: Index) -> String
    @warn_unused_result
    func substringToIndex(_ index: Index) -> String
    @warn_unused_result
    func substringWithRange(_ aRange: Range<Index>) -> String
    var localizedUppercaseString: String { get }
    @warn_unused_result
    func uppercaseStringWithLocale(_ locale: NSLocale?) -> String
    func writeToFile(_ path: String, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding) throws
    func writeToURL(_ url: NSURL, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding) throws
    @warn_unused_result
    func stringByApplyingTransform(_ transform: String, reverse reverse: Bool) -> String?
    @warn_unused_result
    func containsString(_ other: String) -> Bool
    @warn_unused_result
    func localizedCaseInsensitiveContainsString(_ other: String) -> Bool
}
extension String : _ObjectiveCBridgeable {
}
extension String {
    init(_ cocoaString: NSString)
}
extension String {
    typealias Index = String.CharacterView.Index
    var startIndex: Index { get }
    var endIndex: Index { get }
    subscript (_ i: Index) -> Character { get }
}
extension String {
    struct CharacterView {
        init(_ text: String)
    }
    var characters: String.CharacterView { get }
    mutating func withMutableCharacters<R>(_ body: (inout String.CharacterView) -> R) -> R
    init(_ characters: String.CharacterView)
}
extension String {
    struct UnicodeScalarView : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : BidirectionalIndexType, Comparable {
            @warn_unused_result
            func successor() -> String.UnicodeScalarView.Index
            @warn_unused_result
            func predecessor() -> String.UnicodeScalarView.Index
        }
        var startIndex: String.UnicodeScalarView.Index { get }
        var endIndex: String.UnicodeScalarView.Index { get }
        subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
        subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
        struct Generator : GeneratorType {
            mutating func next() -> UnicodeScalar?
        }
        @warn_unused_result
        func generate() -> String.UnicodeScalarView.Generator
        var description: String { get }
        var debugDescription: String { get }
    }
    init(_ unicodeScalars: String.UnicodeScalarView)
    typealias UnicodeScalarIndex = String.UnicodeScalarView.Index
}
extension String {
    struct UTF16View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        var startIndex: String.UTF16View.Index { get }
        var endIndex: String.UTF16View.Index { get }
        subscript (_ i: String.UTF16View.Index) -> CodeUnit { get }
        subscript (_ i: Int) -> CodeUnit { get }
        subscript (_ subRange: Range<Int>) -> String.UTF16View { get }
        subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
    var utf16: String.UTF16View { get }
    init?(_ utf16: String.UTF16View)
    typealias UTF16Index = String.UTF16View.Index
}
extension String {
    struct UTF8View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : ForwardIndexType {
            @warn_unused_result
            func successor() -> String.UTF8View.Index
        }
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        subscript (_ position: String.UTF8View.Index) -> CodeUnit { get }
        subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
    var utf8: String.UTF8View { get }
    var nulTerminatedUTF8: ContiguousArray<CodeUnit> { get }
    init?(_ utf8: String.UTF8View)
    typealias UTF8Index = String.UTF8View.Index
}
extension String {
    @warn_unused_result
    static func fromCString(_ cs: UnsafePointer<CChar>) -> String?
    @warn_unused_result
    static func fromCStringRepairingIllFormedUTF8(_ cs: UnsafePointer<CChar>) -> (String?, hadError: Bool)
}
extension String {
    init(_ c: Character)
}
extension String {
    func withCString<Result>(@noescape _ f: UnsafePointer<Int8> throws -> Result) rethrows -> Result
}
extension String : _Reflectable {
}
extension String : OutputStreamType {
    mutating func write(_ other: String)
}
extension String : Streamable {
    func writeTo<Target : OutputStreamType>(inout _ target: Target)
}
extension String {
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
}
extension String : UnicodeScalarLiteralConvertible {
    init(unicodeScalarLiteral value: String)
}
extension String {
    init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
}
extension String : ExtendedGraphemeClusterLiteralConvertible {
    init(extendedGraphemeClusterLiteral value: String)
}
extension String {
    init(_builtinUTF16StringLiteral start: Builtin.RawPointer, numberOfCodeUnits numberOfCodeUnits: Builtin.Word)
}
extension String {
    init(_builtinStringLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
}
extension String : StringLiteralConvertible {
    init(stringLiteral value: String)
}
extension String : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension String : Equatable {
}
extension String : Comparable {
}
extension String {
    mutating func appendContentsOf(_ other: String)
    mutating func append(_ x: UnicodeScalar)
}
extension String : Hashable {
    var hashValue: Int { get }
}
extension String {
    subscript (_ subRange: Range<Index>) -> String { get }
}
extension String {
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ c: Character)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_ newElements: S)
    init<S : SequenceType where S.Generator.Element == Character>(_ characters: S)
}
extension String {
    func join<S : SequenceType where S.Generator.Element == String>(_ elements: S) -> String
}
extension String {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == Character>(_ subRange: Range<Index>, with newElements: C)
    mutating func replaceRange(_ subRange: Range<Index>, with newElements: String)
    mutating func insert(_ newElement: Character, atIndex i: Index)
    mutating func insertContentsOf<S : CollectionType where S.Generator.Element == Character>(_ newElements: S, at i: Index)
    mutating func removeAtIndex(_ i: Index) -> Character
    mutating func removeRange(_ subRange: Range<Index>)
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
}
extension String {
    var lowercaseString: String { get }
    var uppercaseString: String { get }
}
extension String : StringInterpolationConvertible {
    init(stringInterpolation strings: String...)
    init<T>(stringInterpolationSegment expr: T)
    init(stringInterpolationSegment expr: String)
    init(stringInterpolationSegment expr: Character)
    init(stringInterpolationSegment expr: UnicodeScalar)
    init(stringInterpolationSegment expr: Bool)
    init(stringInterpolationSegment expr: Float32)
    init(stringInterpolationSegment expr: Float64)
    init(stringInterpolationSegment expr: UInt8)
    init(stringInterpolationSegment expr: Int8)
    init(stringInterpolationSegment expr: UInt16)
    init(stringInterpolationSegment expr: Int16)
    init(stringInterpolationSegment expr: UInt32)
    init(stringInterpolationSegment expr: Int32)
    init(stringInterpolationSegment expr: UInt64)
    init(stringInterpolationSegment expr: Int64)
    init(stringInterpolationSegment expr: UInt)
    init(stringInterpolationSegment expr: Int)
}
extension String {
    init(count count: Int, repeatedValue c: Character)
    init(count count: Int, repeatedValue c: UnicodeScalar)
    var isEmpty: Bool { get }
}
extension String {
    func hasPrefix(_ prefix: String) -> Bool
    func hasSuffix(_ suffix: String) -> Bool
}
extension String {
    init<T : _SignedIntegerType>(_ v: T)
    init<T : UnsignedIntegerType>(_ v: T)
    init<T : _SignedIntegerType>(_ v: T, radix radix: Int, uppercase uppercase: Bool = default)
    init<T : UnsignedIntegerType>(_ v: T, radix radix: Int, uppercase uppercase: Bool = default)
}
extension String {
    func toInt() -> Int?
}
extension String {
    var unicodeScalars: String.UnicodeScalarView
}
extension String {
    subscript (_ i: Int) -> Character { get }
    subscript (_ subRange: Range<Int>) -> String { get }
    var count: Int { get }
}
extension String : MirrorPathType {
}
extension String {
    init<T>(_ instance: T)
    init<T>(reflecting subject: T)
}
Comparable, CustomDebugStringConvertible, Equatable, ExtendedGraphemeClusterLiteralConvertible, Hashable, MirrorPathType, OutputStreamType, Streamable, StringInterpolationConvertible, StringLiteralConvertible, UnicodeScalarLiteralConvertible
To
struct String {
    init()
    init(cString cString: UnsafePointer<CChar>)
    init(cString cString: UnsafePointer<UInt8>)
    init?(validatingUTF8 cString: UnsafePointer<CChar>)
    static func decodeCString<Encoding : UnicodeCodec>(_ cString: UnsafePointer<Encoding.CodeUnit>?, as encoding: Encoding.Type, repairingInvalidCodeUnits isRepairing: Bool = default) -> (result: String, repairsMade: Bool)?
    static func fromCString(_ cs: UnsafePointer<CChar>) -> String?
    static func fromCStringRepairingIllFormedUTF8(_ cs: UnsafePointer<CChar>) -> (String?, hadError: Bool)
    init(_ c: Character)
    func withCString<Result>(_ body: (UnsafePointer<Int8>) throws -> Result) rethrows -> Result
    init<Subject>(describing instance: Subject)
    init<Subject>(reflecting subject: Subject)
    mutating func append(_ other: String)
    mutating func append(_ x: UnicodeScalar)
    static func +(_ lhs: String, _ rhs: String) -> String
    static func +=(_ lhs: inout String, _ rhs: String)
    func lowercased() -> String
    func uppercased() -> String
    init<T : LosslessStringConvertible>(_ value: T)
    mutating func appendContentsOf(_ other: String)
    mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Character>(_ newElements: S)
    mutating func insertContentsOf<S : Collection where S.Iterator.Element == Character>(_ newElements: S, at i: String.Index)
    mutating func replaceRange<C : Collection where C.Iterator.Element == Character>(_ subRange: Range<String.Index>, with newElements: C)
    mutating func replaceRange(_ subRange: Range<String.Index>, with newElements: String)
    mutating func removeAtIndex(_ i: String.Index) -> Character
    mutating func removeRange(_ subRange: Range<String.Index>)
    var lowercaseString: String { get }
    var uppercaseString: String { get }
    init<T>(_ _: T)
    struct CharacterView {
        init(_ text: String)
    }
    var characters: String.CharacterView
    mutating func withMutableCharacters<R>(_ body: (inout String.CharacterView) -> R) -> R
    init(_ characters: String.CharacterView)
    init(repeating repeatedValue: Character, count count: Int)
    init(repeating repeatedValue: UnicodeScalar, count count: Int)
    init(repeating repeatedValue: String, count count: Int)
    var isEmpty: Bool { get }
    func hasPrefix(_ prefix: String) -> Bool
    func hasSuffix(_ suffix: String) -> Bool
    init<T : _SignedInteger>(_ v: T)
    init<T : UnsignedInteger>(_ v: T)
    init<T : _SignedInteger>(_ value: T, radix radix: Int, uppercase uppercase: Bool = default)
    init<T : UnsignedInteger>(_ value: T, radix radix: Int, uppercase uppercase: Bool = default)
    init(count count: Int, repeatedValue c: Character)
    init(count count: Int, repeatedValue c: UnicodeScalar)
    typealias Index = String.CharacterView.Index
    typealias IndexDistance = String.CharacterView.IndexDistance
    var startIndex: String.Index { get }
    var endIndex: String.Index { get }
    func index(after i: String.Index) -> String.Index
    func index(before i: String.Index) -> String.Index
    func index(_ i: String.Index, offsetBy n: String.IndexDistance) -> String.Index
    func index(_ i: String.Index, offsetBy n: String.IndexDistance, limitedBy limit: String.Index) -> String.Index?
    func distance(from start: String.Index, to end: String.Index) -> String.IndexDistance
    subscript(_ i: String.Index) -> Character { get }
    subscript(_ bounds: Range<String.Index>) -> String { get }
    subscript(_ bounds: ClosedRange<String.Index>) -> String { get }
    init<S : Sequence where S.Iterator.Element == Character>(_ characters: S)
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ c: Character)
    mutating func append<S : Sequence where S.Iterator.Element == Character>(contentsOf newElements: S)
    mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Range<String.Index>, with newElements: C)
    mutating func replaceSubrange(_ bounds: Range<String.Index>, with newElements: String)
    mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: ClosedRange<String.Index>, with newElements: C)
    mutating func replaceSubrange(_ bounds: ClosedRange<String.Index>, with newElements: String)
    mutating func insert(_ newElement: Character, at i: String.Index)
    mutating func insert<S : Collection where S.Iterator.Element == Character>(contentsOf newElements: S, at i: String.Index)
    mutating func remove(at i: String.Index) -> Character
    mutating func removeSubrange(_ bounds: Range<String.Index>)
    mutating func removeSubrange(_ bounds: ClosedRange<String.Index>)
    mutating func removeAll(keepingCapacity keepCapacity: Bool = default)
    struct UTF16View : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        typealias IndexDistance = Int
        var startIndex: String.UTF16View.Index { get }
        var endIndex: String.UTF16View.Index { get }
        struct Indices {
        }
        var indices: String.UTF16View.Indices { get }
        func index(after i: String.UTF16View.Index) -> String.UTF16View.Index
        func index(before i: String.UTF16View.Index) -> String.UTF16View.Index
        func index(_ i: String.UTF16View.Index, offsetBy n: String.UTF16View.IndexDistance) -> String.UTF16View.Index
        func index(_ i: String.UTF16View.Index, offsetBy n: String.UTF16View.IndexDistance, limitedBy limit: String.UTF16View.Index) -> String.UTF16View.Index?
        func distance(from start: String.UTF16View.Index, to end: String.UTF16View.Index) -> String.UTF16View.IndexDistance
        subscript(_ i: String.UTF16View.Index) -> UTF16.CodeUnit { get }
        subscript(_ i: Int) -> UTF16.CodeUnit { get }
        subscript(_ bounds: Range<Int>) -> String.UTF16View { get }
        subscript(_ bounds: Range<String.UTF16View.Index>) -> String.UTF16View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
    var utf16: String.UTF16View
    init?(_ utf16: String.UTF16View)
    typealias UTF16Index = String.UTF16View.Index
    struct UTF8View : Collection, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        typealias IndexDistance = Int
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        func index(after i: String.UTF8View.Index) -> String.UTF8View.Index
        subscript(_ position: String.UTF8View.Index) -> UTF8.CodeUnit { get }
        subscript(_ bounds: Range<String.UTF8View.Index>) -> String.UTF8View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
    var utf8: String.UTF8View
    var utf8CString: ContiguousArray<CChar> { get }
    init?(_ utf8: String.UTF8View)
    typealias UTF8Index = String.UTF8View.Index
    var nulTerminatedUTF8: ContiguousArray<UTF8.CodeUnit> { get }
    struct UnicodeScalarView : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        var startIndex: String.UnicodeScalarView.Index { get }
        var endIndex: String.UnicodeScalarView.Index { get }
        func index(after i: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index
        func index(before i: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index
        subscript(_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
        subscript(_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
        struct Iterator : IteratorProtocol {
            mutating func next() -> UnicodeScalar?
        }
        func makeIterator() -> String.UnicodeScalarView.Iterator
        var description: String { get }
        var debugDescription: String { get }
    }
    init(_ unicodeScalars: String.UnicodeScalarView)
    typealias UnicodeScalarIndex = String.UnicodeScalarView.Index
    var unicodeScalars: String.UnicodeScalarView
    subscript(_ i: Int) -> Character { get }
    subscript(_ bounds: Range<Int>) -> String { get }
    subscript(_ bounds: ClosedRange<Int>) -> String { get }
    subscript(_ bounds: CountableRange<Int>) -> String { get }
    subscript(_ bounds: CountableClosedRange<Int>) -> String { get }
    var count: Int { get }
}
extension String {
    init(_ cocoaString: NSString)
}
extension String {
}
extension String : CVarArg {
}
extension String {
    static var availableStringEncodings: [String.Encoding] { get }
    static var defaultCStringEncoding: String.Encoding { get }
    static func localizedName(of encoding: String.Encoding) -> String
    static func localizedStringWithFormat(_ format: String, _ arguments: CVarArg...) -> String
    static func path(withComponents components: [String]) -> String
    init?(utf8String bytes: UnsafePointer<CChar>)
    func canBeConverted(to encoding: String.Encoding) -> Bool
    var capitalized: String { get }
    var localizedCapitalized: String { get }
    func capitalized(with locale: Locale?) -> String
    func caseInsensitiveCompare(_ aString: String) -> ComparisonResult
    func commonPrefix(with aString: String, options options: String.CompareOptions = default) -> String
    func compare(_ aString: String, options mask: String.CompareOptions = default, range range: Range<String.Index>? = default, locale locale: Locale? = default) -> ComparisonResult
    func completePath(into outputName: UnsafeMutablePointer<String>? = default, caseSensitive caseSensitive: Bool, matchesInto outputArray: UnsafeMutablePointer<[String]>? = default, filterTypes filterTypes: [String]? = default) -> Int
    func components(separatedBy separator: CharacterSet) -> [String]
    func components(separatedBy separator: String) -> [String]
    func cString(using encoding: String.Encoding) -> [CChar]?
    func data(using encoding: String.Encoding, allowLossyConversion allowLossyConversion: Bool = default) -> Data?
    var decomposedStringWithCanonicalMapping: String { get }
    var decomposedStringWithCompatibilityMapping: String { get }
    func enumerateLines(invoking body: @escaping (String, inout Bool) -> ())
    func enumerateLinguisticTags(in range: Range<String.Index>, scheme tagScheme: String, options opts: NSLinguisticTagger.Options = default, orthography orthography: NSOrthography? = default, invoking body: (String, Range<String.Index>, Range<String.Index>, inout Bool) -> ())
    func enumerateSubstrings(in range: Range<String.Index>, options opts: String.EnumerationOptions = default, _ body: @escaping (String?, Range<String.Index>, Range<String.Index>, inout Bool) -> ())
    var fastestEncoding: String.Encoding { get }
    var fileSystemRepresentation: [CChar] { get }
    func getBytes(_ buffer: inout [UInt8], maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding encoding: String.Encoding, options options: String.EncodingConversionOptions = default, range range: Range<String.Index>, remaining leftover: UnsafeMutablePointer<Range<String.Index>>) -> Bool
    func getCString(_ buffer: inout [CChar], maxLength maxLength: Int, encoding encoding: String.Encoding) -> Bool
    func getFileSystemRepresentation(_ buffer: inout [CChar], maxLength maxLength: Int) -> Bool
    func getLineStart(_ start: UnsafeMutablePointer<String.Index>, end end: UnsafeMutablePointer<String.Index>, contentsEnd contentsEnd: UnsafeMutablePointer<String.Index>, for range: Range<String.Index>)
    func getParagraphStart(_ start: UnsafeMutablePointer<String.Index>, end end: UnsafeMutablePointer<String.Index>, contentsEnd contentsEnd: UnsafeMutablePointer<String.Index>, for range: Range<String.Index>)
    var hash: Int { get }
    init?<S : Sequence where S.Iterator.Element == UInt8>(bytes bytes: S, encoding encoding: String.Encoding)
    init?(bytesNoCopy bytes: UnsafeMutableRawPointer, length length: Int, encoding encoding: String.Encoding, freeWhenDone flag: Bool)
    init(utf16CodeUnits utf16CodeUnits: UnsafePointer<unichar>, count count: Int)
    init(utf16CodeUnitsNoCopy utf16CodeUnitsNoCopy: UnsafePointer<unichar>, count count: Int, freeWhenDone flag: Bool)
    init(contentsOfFile path: String, encoding enc: String.Encoding) throws
    init(contentsOfFile path: String, usedEncoding usedEncoding: inout String.Encoding) throws
    init(contentsOfFile path: String) throws
    init(contentsOf url: URL, encoding enc: String.Encoding) throws
    init(contentsOf url: URL, usedEncoding usedEncoding: inout String.Encoding) throws
    init(contentsOf url: URL) throws
    init?(cString cString: UnsafePointer<CChar>, encoding enc: String.Encoding)
    init?(data data: Data, encoding encoding: String.Encoding)
    init(format format: String, _ arguments: CVarArg...)
    init(format format: String, arguments arguments: [CVarArg])
    init(format format: String, locale locale: Locale?, _ args: CVarArg...)
    init(format format: String, locale locale: Locale?, arguments arguments: [CVarArg])
    var lastPathComponent: String { get }
    var utf16Count: Int { get }
    func lengthOfBytes(using encoding: String.Encoding) -> Int
    func lineRange(for aRange: Range<String.Index>) -> Range<String.Index>
    func linguisticTags(in range: Range<String.Index>, scheme tagScheme: String, options opts: NSLinguisticTagger.Options = default, orthography orthography: NSOrthography? = default, tokenRanges tokenRanges: UnsafeMutablePointer<[Range<String.Index>]>? = default) -> [String]
    func localizedCaseInsensitiveCompare(_ aString: String) -> ComparisonResult
    func localizedCompare(_ aString: String) -> ComparisonResult
    func localizedStandardCompare(_ string: String) -> ComparisonResult
    var localizedLowercase: String { get }
    func lowercased(with locale: Locale?) -> String
    func maximumLengthOfBytes(using encoding: String.Encoding) -> Int
    func paragraphRange(for aRange: Range<String.Index>) -> Range<String.Index>
    var pathComponents: [String] { get }
    var pathExtension: String { get }
    var precomposedStringWithCanonicalMapping: String { get }
    var precomposedStringWithCompatibilityMapping: String { get }
    func propertyList() -> Any
    func propertyListFromStringsFileFormat() -> [String : String]
    func rangeOfCharacter(from aSet: CharacterSet, options mask: String.CompareOptions = default, range aRange: Range<String.Index>? = default) -> Range<String.Index>?
    func rangeOfComposedCharacterSequence(at anIndex: String.Index) -> Range<String.Index>
    func rangeOfComposedCharacterSequences(for range: Range<String.Index>) -> Range<String.Index>
    func range(of aString: String, options mask: String.CompareOptions = default, range searchRange: Range<String.Index>? = default, locale locale: Locale? = default) -> Range<String.Index>?
    func localizedStandardContains(_ string: String) -> Bool
    func localizedStandardRange(of string: String) -> Range<String.Index>?
    var smallestEncoding: String.Encoding { get }
    var abbreviatingWithTildeInPath: String { get }
    func addingPercentEncoding(withAllowedCharacters allowedCharacters: CharacterSet) -> String?
    func addingPercentEscapes(using encoding: String.Encoding) -> String?
    func appendingFormat(_ format: String, _ arguments: CVarArg...) -> String
    func appendingPathComponent(_ aString: String) -> String
    func appendingPathExtension(_ ext: String) -> String?
    func appending(_ aString: String) -> String
    var deletingLastPathComponent: String { get }
    var deletingPathExtension: String { get }
    var expandingTildeInPath: String { get }
    func folding(_ options: String.CompareOptions = default, locale locale: Locale?) -> String
    func folding(options options: String.CompareOptions = default, locale locale: Locale?) -> String
    func padding(toLength newLength: Int, withPad padString: String, startingAt padIndex: Int) -> String
    var removingPercentEncoding: String? { get }
    func replacingCharacters(in range: Range<String.Index>, with replacement: String) -> String
    func replacingOccurrences(of target: String, with replacement: String, options options: String.CompareOptions = default, range searchRange: Range<String.Index>? = default) -> String
    func replacingPercentEscapes(using encoding: String.Encoding) -> String?
    var resolvingSymlinksInPath: String { get }
    var standardizingPath: String { get }
    func trimmingCharacters(in set: CharacterSet) -> String
    func strings(byAppendingPaths paths: [String]) -> [String]
    func substring(from index: String.Index) -> String
    func substring(to index: String.Index) -> String
    func substring(with aRange: Range<String.Index>) -> String
    var localizedUppercase: String { get }
    func uppercased(with locale: Locale?) -> String
    func write(toFile path: String, atomically useAuxiliaryFile: Bool, encoding enc: String.Encoding) throws
    func write(to url: URL, atomically useAuxiliaryFile: Bool, encoding enc: String.Encoding) throws
    func applyingTransform(_ transform: StringTransform, reverse reverse: Bool) -> String?
    func contains(_ other: String) -> Bool
    func localizedCaseInsensitiveContains(_ other: String) -> Bool
}
extension String {
    static func localizedNameOfStringEncoding(_ encoding: String.Encoding) -> String
    static func pathWithComponents(_ components: [String]) -> String
    func canBeConvertedToEncoding(_ encoding: String.Encoding) -> Bool
    func capitalizedStringWith(_ locale: Locale?) -> String
    func commonPrefixWith(_ aString: String, options options: String.CompareOptions) -> String
    func completePathInto(_ outputName: UnsafeMutablePointer<String>? = default, caseSensitive caseSensitive: Bool, matchesInto matchesIntoArray: UnsafeMutablePointer<[String]>? = default, filterTypes filterTypes: [String]? = default) -> Int
    func componentsSeparatedByCharactersIn(_ separator: CharacterSet) -> [String]
    func componentsSeparatedBy(_ separator: String) -> [String]
    func cStringUsingEncoding(_ encoding: String.Encoding) -> [CChar]?
    func dataUsingEncoding(_ encoding: String.Encoding, allowLossyConversion allowLossyConversion: Bool = default) -> Data?
    func enumerateLinguisticTagsIn(_ range: Range<String.Index>, scheme tagScheme: String, options opts: NSLinguisticTagger.Options, orthography orthography: NSOrthography?, _ body: (String, Range<String.Index>, Range<String.Index>, inout Bool) -> ())
    func enumerateSubstringsIn(_ range: Range<String.Index>, options opts: String.EnumerationOptions = default, _ body: (String?, Range<String.Index>, Range<String.Index>, inout Bool) -> ())
    func getBytes(_ buffer: inout [UInt8], maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding encoding: String.Encoding, options options: String.EncodingConversionOptions = default, range range: Range<String.Index>, remainingRange leftover: UnsafeMutablePointer<Range<String.Index>>) -> Bool
    func getLineStart(_ start: UnsafeMutablePointer<String.Index>, end end: UnsafeMutablePointer<String.Index>, contentsEnd contentsEnd: UnsafeMutablePointer<String.Index>, forRange forRange: Range<String.Index>)
    func getParagraphStart(_ start: UnsafeMutablePointer<String.Index>, end end: UnsafeMutablePointer<String.Index>, contentsEnd contentsEnd: UnsafeMutablePointer<String.Index>, forRange forRange: Range<String.Index>)
    func lengthOfBytesUsingEncoding(_ encoding: String.Encoding) -> Int
    func lineRangeFor(_ aRange: Range<String.Index>) -> Range<String.Index>
    func linguisticTagsIn(_ range: Range<String.Index>, scheme tagScheme: String, options opts: NSLinguisticTagger.Options = default, orthography orthography: NSOrthography? = default, tokenRanges tokenRanges: UnsafeMutablePointer<[Range<String.Index>]>? = default) -> [String]
    func lowercaseStringWith(_ locale: Locale?) -> String
    func maximumLengthOfBytesUsingEncoding(_ encoding: String.Encoding) -> Int
    func paragraphRangeFor(_ aRange: Range<String.Index>) -> Range<String.Index>
    func rangeOfCharacterFrom(_ aSet: CharacterSet, options mask: String.CompareOptions = default, range aRange: Range<String.Index>? = default) -> Range<String.Index>?
    func rangeOfComposedCharacterSequenceAt(_ anIndex: String.Index) -> Range<String.Index>
    func rangeOfComposedCharacterSequencesFor(_ range: Range<String.Index>) -> Range<String.Index>
    func rangeOf(_ aString: String, options mask: String.CompareOptions = default, range searchRange: Range<String.Index>? = default, locale locale: Locale? = default) -> Range<String.Index>?
    func localizedStandardRangeOf(_ string: String) -> Range<String.Index>?
    func addingPercentEncodingWithAllowedCharacters(_ allowedCharacters: CharacterSet) -> String?
    func addingPercentEscapesUsingEncoding(_ encoding: String.Encoding) -> String?
    func stringByAppendingFormat(_ format: String, _ arguments: CVarArg...) -> String
    func byPaddingToLength(_ newLength: Int, withString padString: String, startingAt padIndex: Int) -> String
    func replacingCharactersIn(_ range: Range<String.Index>, withString replacement: String) -> String
    func replacingOccurrencesOf(_ target: String, withString replacement: String, options options: String.CompareOptions = default, range searchRange: Range<String.Index>? = default) -> String
    func replacingPercentEscapesUsingEncoding(_ encoding: String.Encoding) -> String?
    func byTrimmingCharactersIn(_ set: CharacterSet) -> String
    func stringsByAppendingPaths(_ paths: [String]) -> [String]
    func substringFrom(_ index: String.Index) -> String
    func substringTo(_ index: String.Index) -> String
    func substringWith(_ aRange: Range<String.Index>) -> String
    func uppercaseStringWith(_ locale: Locale?) -> String
    func writeToFile(_ path: String, atomically useAuxiliaryFile: Bool, encoding enc: String.Encoding) throws
    func writeToURL(_ url: URL, atomically useAuxiliaryFile: Bool, encoding enc: String.Encoding) throws
}
extension String {
    struct Encoding : RawRepresentable {
        var rawValue: UInt
        init(rawValue rawValue: UInt)
        static let ascii: String.Encoding
        static let nextstep: String.Encoding
        static let japaneseEUC: String.Encoding
        static let utf8: String.Encoding
        static let isoLatin1: String.Encoding
        static let symbol: String.Encoding
        static let nonLossyASCII: String.Encoding
        static let shiftJIS: String.Encoding
        static let isoLatin2: String.Encoding
        static let unicode: String.Encoding
        static let windowsCP1251: String.Encoding
        static let windowsCP1252: String.Encoding
        static let windowsCP1253: String.Encoding
        static let windowsCP1254: String.Encoding
        static let windowsCP1250: String.Encoding
        static let iso2022JP: String.Encoding
        static let macOSRoman: String.Encoding
        static let utf16: String.Encoding
        static let utf16BigEndian: String.Encoding
        static let utf16LittleEndian: String.Encoding
        static let utf32: String.Encoding
        static let utf32BigEndian: String.Encoding
        static let utf32LittleEndian: String.Encoding
    }
    typealias EncodingConversionOptions = NSString.EncodingConversionOptions
    typealias EnumerationOptions = NSString.EnumerationOptions
    typealias CompareOptions = NSString.CompareOptions
}
extension String : CustomReflectable {
    var customMirror: Mirror { get }
}
extension String : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension String : TextOutputStream {
    mutating func write(_ other: String)
}
extension String : TextOutputStreamable {
    func write<Target : TextOutputStream>(to target: inout Target)
}
extension String : ExpressibleByUnicodeScalarLiteral {
    init(unicodeScalarLiteral value: String)
}
extension String : ExpressibleByExtendedGraphemeClusterLiteral {
    init(extendedGraphemeClusterLiteral value: String)
}
extension String : ExpressibleByStringLiteral {
    init(stringLiteral value: String)
}
extension String : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension String : Equatable {
    static func ==(_ lhs: String, _ rhs: String) -> Bool
}
extension String : Comparable {
    static func <(_ lhs: String, _ rhs: String) -> Bool
}
extension String : Hashable {
    var hashValue: Int { get }
}
extension String : CustomStringConvertible {
    var description: String { get }
}
extension String : LosslessStringConvertible {
    init?(_ description: String)
}
extension String : ExpressibleByStringInterpolation {
    init(stringInterpolation strings: String...)
    init<T>(stringInterpolationSegment expr: T)
    init(stringInterpolationSegment expr: String)
    init(stringInterpolationSegment expr: Character)
    init(stringInterpolationSegment expr: UnicodeScalar)
    init(stringInterpolationSegment expr: Bool)
    init(stringInterpolationSegment expr: Float32)
    init(stringInterpolationSegment expr: Float64)
    init(stringInterpolationSegment expr: UInt8)
    init(stringInterpolationSegment expr: Int8)
    init(stringInterpolationSegment expr: UInt16)
    init(stringInterpolationSegment expr: Int16)
    init(stringInterpolationSegment expr: UInt32)
    init(stringInterpolationSegment expr: Int32)
    init(stringInterpolationSegment expr: UInt64)
    init(stringInterpolationSegment expr: Int64)
    init(stringInterpolationSegment expr: UInt)
    init(stringInterpolationSegment expr: Int)
}
CVarArg, Comparable, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, ExpressibleByExtendedGraphemeClusterLiteral, ExpressibleByStringInterpolation, ExpressibleByStringLiteral, ExpressibleByUnicodeScalarLiteral, Hashable, LosslessStringConvertible, TextOutputStream, TextOutputStreamable

DeclarationReadonly
From
var characters: String.CharacterView { get }
yes
To
var characters: String.CharacterView
--

Declaration
From
var endIndex: Index { get }
To
var endIndex: String.Index { get }

DeclarationGenerics[Parameters]
From
init<T>(reflecting subject: T)
T
To
init<Subject>(reflecting subject: Subject)
Subject

Declaration
From
var startIndex: Index { get }
To
var startIndex: String.Index { get }

Declaration
From
subscript (_ i: Index) -> Character { get }
To
subscript(_ i: String.Index) -> Character { get }

Modified String.subscript(_: Range<String.Index>) -> String
Declaration
From
subscript (_ subRange: Range<Index>) -> String { get }
To
subscript(_ bounds: Range<String.Index>) -> String { get }

Modified String.utf16
DeclarationReadonly
From
var utf16: String.UTF16View { get }
yes
To
var utf16: String.UTF16View
--

Modified String.utf8
DeclarationReadonly
From
var utf8: String.UTF8View { get }
yes
To
var utf8: String.UTF8View
--

Declaration
From
func withCString<Result>(@noescape _ f: UnsafePointer<Int8> throws -> Result) rethrows -> Result
To
func withCString<Result>(_ body: (UnsafePointer<Int8>) throws -> Result) rethrows -> Result

Modified String.CharacterView [struct]
DeclarationProtocols
From
struct CharacterView {
        init(_ text: String)
    }
extension String.CharacterView : CollectionType {
    struct Index : BidirectionalIndexType, Comparable, _Reflectable {
        func successor() -> String.CharacterView.Index
        func predecessor() -> String.CharacterView.Index
    }
    var startIndex: String.CharacterView.Index { get }
    var endIndex: String.CharacterView.Index { get }
    subscript (_ i: String.CharacterView.Index) -> Character { get }
}
extension String.CharacterView : RangeReplaceableCollectionType {
    init()
    mutating func replaceRange<C : CollectionType where C.Generator.Element == Character>(_ subRange: Range<String.CharacterView.Index>, with newElements: C)
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ c: Character)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_ newElements: S)
    init<S : SequenceType where S.Generator.Element == Character>(_ characters: S)
}
extension String.CharacterView {
    subscript (_ subRange: Range<String.CharacterView.Index>) -> String.CharacterView { get }
}
CollectionType, RangeReplaceableCollectionType
To
struct CharacterView {
        init(_ text: String)
    }
extension String.CharacterView {
    subscript(_ bounds: Range<String.CharacterView.Index>) -> String.CharacterView { get }
    mutating func replaceRange<C where C : Collection, C.Iterator.Element == Character>(_ subRange: Range<String.CharacterView.Index>, with newElements: C)
    mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Character>(_ newElements: S)
}
extension String.CharacterView : BidirectionalCollection {
    struct Index : Comparable, CustomPlaygroundQuickLookable {
        var customPlaygroundQuickLook: PlaygroundQuickLook { get }
    }
    typealias IndexDistance = Int
    var startIndex: String.CharacterView.Index { get }
    var endIndex: String.CharacterView.Index { get }
    func index(after i: String.CharacterView.Index) -> String.CharacterView.Index
    func index(before i: String.CharacterView.Index) -> String.CharacterView.Index
    subscript(_ i: String.CharacterView.Index) -> Character { get }
}
extension String.CharacterView : RangeReplaceableCollection {
    init()
    mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Range<String.CharacterView.Index>, with newElements: C)
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ c: Character)
    mutating func append<S : Sequence where S.Iterator.Element == Character>(contentsOf newElements: S)
    init<S : Sequence where S.Iterator.Element == Character>(_ characters: S)
}
BidirectionalCollection, RangeReplaceableCollection

Modified String.CharacterView.subscript(_: String.CharacterView.Index) -> Character
Declaration
From
subscript (_ i: String.CharacterView.Index) -> Character { get }
To
subscript(_ i: String.CharacterView.Index) -> Character { get }

Modified String.CharacterView.subscript(_: Range<String.CharacterView.Index>) -> String.CharacterView
Declaration
From
subscript (_ subRange: Range<String.CharacterView.Index>) -> String.CharacterView { get }
To
subscript(_ bounds: Range<String.CharacterView.Index>) -> String.CharacterView { get }

Modified String.CharacterView.Index [struct]
DeclarationProtocols
From
struct Index : BidirectionalIndexType, Comparable, _Reflectable {
        func successor() -> String.CharacterView.Index
        func predecessor() -> String.CharacterView.Index
    }
BidirectionalIndexType, Comparable
To
struct Index : Comparable, CustomPlaygroundQuickLookable {
        var customPlaygroundQuickLook: PlaygroundQuickLook { get }
    }
Comparable, CustomPlaygroundQuickLookable

DeclarationProtocols
From
struct UnicodeScalarView : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : BidirectionalIndexType, Comparable {
            @warn_unused_result
            func successor() -> String.UnicodeScalarView.Index
            @warn_unused_result
            func predecessor() -> String.UnicodeScalarView.Index
        }
        var startIndex: String.UnicodeScalarView.Index { get }
        var endIndex: String.UnicodeScalarView.Index { get }
        subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
        subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
        struct Generator : GeneratorType {
            mutating func next() -> UnicodeScalar?
        }
        @warn_unused_result
        func generate() -> String.UnicodeScalarView.Generator
        var description: String { get }
        var debugDescription: String { get }
    }
extension String.UnicodeScalarView : RangeReplaceableCollectionType {
    init()
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ x: UnicodeScalar)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == UnicodeScalar>(_ newElements: S)
    mutating func replaceRange<C : CollectionType where C.Generator.Element == UnicodeScalar>(_ subRange: Range<String.UnicodeScalarView.Index>, with newElements: C)
}
CollectionType, CustomDebugStringConvertible, CustomStringConvertible, RangeReplaceableCollectionType
To
struct UnicodeScalarView : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        var startIndex: String.UnicodeScalarView.Index { get }
        var endIndex: String.UnicodeScalarView.Index { get }
        func index(after i: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index
        func index(before i: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index
        subscript(_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
        subscript(_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
        struct Iterator : IteratorProtocol {
            mutating func next() -> UnicodeScalar?
        }
        func makeIterator() -> String.UnicodeScalarView.Iterator
        var description: String { get }
        var debugDescription: String { get }
    }
extension String.UnicodeScalarView {
    mutating func popLast() -> UnicodeScalar?
    mutating func removeLast() -> UnicodeScalar
    mutating func removeLast(_ n: Int)
    func dropLast(_ n: Int) -> String.UnicodeScalarView
    func suffix(_ maxLength: Int) -> String.UnicodeScalarView
    mutating func popFirst() -> UnicodeScalar?
    func map<T>(_ transform: (UnicodeScalar) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> String.UnicodeScalarView
    func prefix(_ maxLength: Int) -> String.UnicodeScalarView
    func prefix(upTo end: String.UnicodeScalarView.Index) -> String.UnicodeScalarView
    func suffix(from start: String.UnicodeScalarView.Index) -> String.UnicodeScalarView
    func prefix(through position: String.UnicodeScalarView.Index) -> String.UnicodeScalarView
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (UnicodeScalar) throws -> Bool) rethrows -> [String.UnicodeScalarView]
    func split(separator separator: UnicodeScalar, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [String.UnicodeScalarView]
    mutating func removeFirst() -> UnicodeScalar
    mutating func removeFirst(_ n: Int)
    typealias Generator = String.UnicodeScalarView.Iterator
    func generate() -> String.UnicodeScalarView.Iterator
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (UnicodeScalar) throws -> Bool) rethrows -> [String.UnicodeScalarView]
    func split(_ separator: UnicodeScalar, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [String.UnicodeScalarView]
    var last: UnicodeScalar? { get }
    func index(of element: UnicodeScalar) -> String.UnicodeScalarView.Index?
    func index(where predicate: (UnicodeScalar) throws -> Bool) rethrows -> String.UnicodeScalarView.Index?
    func sorted() -> [UnicodeScalar]
    func sorted(by areInIncreasingOrder: (UnicodeScalar, UnicodeScalar) -> Bool) -> [UnicodeScalar]
    subscript(_ bounds: ClosedRange<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
    func sort(_ isOrderedBefore: (UnicodeScalar, UnicodeScalar) -> Bool) -> [UnicodeScalar]
    func sort() -> [UnicodeScalar]
    func indexOf(_ element: UnicodeScalar) -> String.UnicodeScalarView.Index?
    var indices: DefaultBidirectionalIndices<String.UnicodeScalarView> { get }
    var lazy: LazySequence<String.UnicodeScalarView> { get }
    func reversed() -> ReversedCollection<String.UnicodeScalarView>
    func reverse() -> ReversedCollection<String.UnicodeScalarView>
    func map<T>(_ transform: (UnicodeScalar) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (UnicodeScalar) throws -> Bool) rethrows -> [UnicodeScalar]
    var underestimatedCount: Int { get }
    func forEach(_ body: (UnicodeScalar) throws -> Void) rethrows
    func first(where predicate: (UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
    func dropFirst() -> String.UnicodeScalarView
    func dropLast() -> String.UnicodeScalarView
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (UnicodeScalar) throws -> Bool) rethrows -> [String.UnicodeScalarView]
    func enumerated() -> EnumeratedSequence<String.UnicodeScalarView>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
    @warn_unqualified_access
    func min() -> UnicodeScalar?
    @warn_unqualified_access
    func max() -> UnicodeScalar?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UnicodeScalar>(with possiblePrefix: PossiblePrefix, by areEquivalent: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UnicodeScalar>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence, by areEquivalent: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence) -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence, by areInIncreasingOrder: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence) -> Bool
    func contains(_ element: UnicodeScalar) -> Bool
    func contains(where predicate: (UnicodeScalar) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, UnicodeScalar) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (UnicodeScalar) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (UnicodeScalar) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<String.UnicodeScalarView>
    func minElement(_ isOrderedBefore: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
    func maxElement(_ isOrderedBefore: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UnicodeScalar>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence, isEquivalent isEquivalent: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, UnicodeScalar) throws -> Result) rethrows -> Result
    func minElement() -> UnicodeScalar?
    func maxElement() -> UnicodeScalar?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UnicodeScalar>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence) -> Bool
}
extension String.UnicodeScalarView {
    var lazy: LazyBidirectionalCollection<String.UnicodeScalarView> { get }
}
extension String.UnicodeScalarView {
    var isEmpty: Bool { get }
    var first: UnicodeScalar? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension String.UnicodeScalarView {
    var lazy: LazyCollection<String.UnicodeScalarView> { get }
}
extension String.UnicodeScalarView {
    func formIndex(after i: inout String.UnicodeScalarView.Index)
    func formIndex(_ i: inout String.UnicodeScalarView.Index, offsetBy n: Int)
    func formIndex(_ i: inout String.UnicodeScalarView.Index, offsetBy n: Int, limitedBy limit: String.UnicodeScalarView.Index) -> Bool
}
extension String.UnicodeScalarView {
    func formIndex(before i: inout String.UnicodeScalarView.Index)
    func index(_ i: String.UnicodeScalarView.Index, offsetBy n: Int) -> String.UnicodeScalarView.Index
    func index(_ i: String.UnicodeScalarView.Index, offsetBy n: Int, limitedBy limit: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index?
    func distance(from start: String.UnicodeScalarView.Index, to end: String.UnicodeScalarView.Index) -> Int
}
extension String.UnicodeScalarView : RangeReplaceableCollection {
    init()
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ x: UnicodeScalar)
    mutating func append<S : Sequence where S.Iterator.Element == UnicodeScalar>(contentsOf newElements: S)
    mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == UnicodeScalar>(_ bounds: Range<String.UnicodeScalarView.Index>, with newElements: C)
}
extension String.UnicodeScalarView : CustomReflectable {
    var customMirror: Mirror { get }
}
extension String.UnicodeScalarView : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
BidirectionalCollection, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, RangeReplaceableCollection

Declaration
From
subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
To
subscript(_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }

Modified String.UnicodeScalarView.subscript(_: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView
Declaration
From
subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
To
subscript(_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }

Modified String.UnicodeScalarView.Index [struct]
DeclarationProtocols
From
struct Index : BidirectionalIndexType, Comparable {
            @warn_unused_result
            func successor() -> String.UnicodeScalarView.Index
            @warn_unused_result
            func predecessor() -> String.UnicodeScalarView.Index
        }
BidirectionalIndexType, Comparable
To
struct Index {
        }
extension String.UnicodeScalarView.Index : Comparable {
    static func ==(_ lhs: String.UnicodeScalarView.Index, _ rhs: String.UnicodeScalarView.Index) -> Bool
    static func <(_ lhs: String.UnicodeScalarView.Index, _ rhs: String.UnicodeScalarView.Index) -> Bool
}
Comparable

DeclarationProtocols
From
struct UTF16View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        var startIndex: String.UTF16View.Index { get }
        var endIndex: String.UTF16View.Index { get }
        subscript (_ i: String.UTF16View.Index) -> CodeUnit { get }
        subscript (_ i: Int) -> CodeUnit { get }
        subscript (_ subRange: Range<Int>) -> String.UTF16View { get }
        subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
CollectionType, CustomDebugStringConvertible, CustomStringConvertible
To
struct UTF16View : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        typealias IndexDistance = Int
        var startIndex: String.UTF16View.Index { get }
        var endIndex: String.UTF16View.Index { get }
        struct Indices {
        }
        var indices: String.UTF16View.Indices { get }
        func index(after i: String.UTF16View.Index) -> String.UTF16View.Index
        func index(before i: String.UTF16View.Index) -> String.UTF16View.Index
        func index(_ i: String.UTF16View.Index, offsetBy n: String.UTF16View.IndexDistance) -> String.UTF16View.Index
        func index(_ i: String.UTF16View.Index, offsetBy n: String.UTF16View.IndexDistance, limitedBy limit: String.UTF16View.Index) -> String.UTF16View.Index?
        func distance(from start: String.UTF16View.Index, to end: String.UTF16View.Index) -> String.UTF16View.IndexDistance
        subscript(_ i: String.UTF16View.Index) -> UTF16.CodeUnit { get }
        subscript(_ i: Int) -> UTF16.CodeUnit { get }
        subscript(_ bounds: Range<Int>) -> String.UTF16View { get }
        subscript(_ bounds: Range<String.UTF16View.Index>) -> String.UTF16View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
extension String.UTF16View : RandomAccessCollection {
}
extension String.UTF16View {
    mutating func popLast() -> UInt16?
    mutating func removeLast() -> UInt16
    mutating func removeLast(_ n: Int)
    func dropLast(_ n: Int) -> String.UTF16View
    func suffix(_ maxLength: Int) -> String.UTF16View
    mutating func popFirst() -> UInt16?
    func map<T>(_ transform: (UInt16) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> String.UTF16View
    func prefix(_ maxLength: Int) -> String.UTF16View
    func prefix(upTo end: String.UTF16View.Index) -> String.UTF16View
    func suffix(from start: String.UTF16View.Index) -> String.UTF16View
    func prefix(through position: String.UTF16View.Index) -> String.UTF16View
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (UInt16) throws -> Bool) rethrows -> [String.UTF16View]
    func split(separator separator: UInt16, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [String.UTF16View]
    mutating func removeFirst() -> UInt16
    mutating func removeFirst(_ n: Int)
    typealias Generator = IndexingIterator<String.UTF16View>
    func generate() -> IndexingIterator<String.UTF16View>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (UInt16) throws -> Bool) rethrows -> [String.UTF16View]
    func split(_ separator: UInt16, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [String.UTF16View]
    var last: UInt16? { get }
    func index(of element: UInt16) -> String.UTF16View.Index?
    func index(where predicate: (UInt16) throws -> Bool) rethrows -> String.UTF16View.Index?
    func sorted() -> [UInt16]
    func sorted(by areInIncreasingOrder: (UInt16, UInt16) -> Bool) -> [UInt16]
    subscript(_ bounds: ClosedRange<String.UTF16View.Index>) -> String.UTF16View { get }
    func sort(_ isOrderedBefore: (UInt16, UInt16) -> Bool) -> [UInt16]
    func sort() -> [UInt16]
    func indexOf(_ element: UInt16) -> String.UTF16View.Index?
    var lazy: LazySequence<String.UTF16View> { get }
    func reversed() -> ReversedCollection<String.UTF16View>
    func reverse() -> ReversedCollection<String.UTF16View>
    func map<T>(_ transform: (UInt16) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (UInt16) throws -> Bool) rethrows -> [UInt16]
    var underestimatedCount: Int { get }
    func forEach(_ body: (UInt16) throws -> Void) rethrows
    func first(where predicate: (UInt16) throws -> Bool) rethrows -> UInt16?
    func dropFirst() -> String.UTF16View
    func dropLast() -> String.UTF16View
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (UInt16) throws -> Bool) rethrows -> [String.UTF16View]
    func enumerated() -> EnumeratedSequence<String.UTF16View>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16?
    @warn_unqualified_access
    func min() -> UInt16?
    @warn_unqualified_access
    func max() -> UInt16?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with possiblePrefix: PossiblePrefix, by areEquivalent: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence, by areEquivalent: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence) -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence, by areInIncreasingOrder: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence) -> Bool
    func contains(_ element: UInt16) -> Bool
    func contains(where predicate: (UInt16) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, UInt16) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (UInt16) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (UInt16) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<String.UTF16View>
    func minElement(_ isOrderedBefore: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16?
    func maxElement(_ isOrderedBefore: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence, isEquivalent isEquivalent: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, UInt16) throws -> Result) rethrows -> Result
    func minElement() -> UInt16?
    func maxElement() -> UInt16?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence) -> Bool
}
extension String.UTF16View {
    var lazy: LazyBidirectionalCollection<String.UTF16View> { get }
}
extension String.UTF16View {
    func makeIterator() -> IndexingIterator<String.UTF16View>
}
extension String.UTF16View {
    var isEmpty: Bool { get }
    var first: UInt16? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension String.UTF16View {
    var lazy: LazyCollection<String.UTF16View> { get }
}
extension String.UTF16View {
    func formIndex(after i: inout String.UTF16View.Index)
    func formIndex(_ i: inout String.UTF16View.Index, offsetBy n: Int)
    func formIndex(_ i: inout String.UTF16View.Index, offsetBy n: Int, limitedBy limit: String.UTF16View.Index) -> Bool
}
extension String.UTF16View {
    func formIndex(before i: inout String.UTF16View.Index)
}
extension String.UTF16View : CustomReflectable {
    var customMirror: Mirror { get }
}
extension String.UTF16View : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
BidirectionalCollection, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, RandomAccessCollection

Declaration
From
subscript (_ i: String.UTF16View.Index) -> CodeUnit { get }
To
subscript(_ i: String.UTF16View.Index) -> UTF16.CodeUnit { get }

Declaration
From
subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get }
To
subscript(_ bounds: Range<String.UTF16View.Index>) -> String.UTF16View { get }

Modified String.UTF16View.Index [struct]
DeclarationProtocols
From
struct Index {
        }
extension String.UTF16View.Index : BidirectionalIndexType {
    typealias Distance = Int
    @warn_unused_result
    func successor() -> String.UTF16View.Index
    @warn_unused_result
    func predecessor() -> String.UTF16View.Index
}
extension String.UTF16View.Index : Comparable, Equatable {
}
extension String.UTF16View.Index {
    @warn_unused_result
    func distanceTo(_ end: String.UTF16View.Index) -> Distance
    @warn_unused_result
    func advancedBy(_ n: Distance) -> String.UTF16View.Index
    @warn_unused_result
    func advancedBy(_ n: Distance, limit limit: String.UTF16View.Index) -> String.UTF16View.Index
}
extension String.UTF16View.Index {
    init?(_ utf8Index: UTF8Index, within utf16: String.UTF16View)
    init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf16: String.UTF16View)
    init(_ characterIndex: Index, within utf16: String.UTF16View)
    @warn_unused_result
    func samePositionIn(_ utf8: String.UTF8View) -> String.UTF8View.Index?
    @warn_unused_result
    func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> UnicodeScalarIndex?
    @warn_unused_result
    func samePositionIn(_ characters: String) -> Index?
}
BidirectionalIndexType, Comparable, Equatable
To
struct Index {
        }
extension String.UTF16View.Index : Strideable {
    init(_ offset: Int)
    func distance(to other: String.UTF16View.Index) -> Int
    func advanced(by n: Int) -> String.UTF16View.Index
}
extension String.UTF16View.Index {
    init?(_ utf8Index: String.UTF8Index, within utf16: String.UTF16View)
    init(_ unicodeScalarIndex: String.UnicodeScalarIndex, within utf16: String.UTF16View)
    init(_ characterIndex: String.Index, within utf16: String.UTF16View)
    func samePosition(in utf8: String.UTF8View) -> String.UTF8View.Index?
    func samePosition(in unicodeScalars: String.UnicodeScalarView) -> String.UnicodeScalarIndex?
    func samePosition(in characters: String) -> String.Index?
    func successor() -> String.UTF16View.Index
    func predecessor() -> String.UTF16View.Index
    func advancedBy(_ n: String.UTF16View.IndexDistance) -> String.UTF16View.Index
    func advancedBy(_ n: String.UTF16View.IndexDistance, limit limit: String.UTF16View.Index) -> String.UTF16View.Index
    func distanceTo(_ end: String.UTF16View.Index) -> String.UTF16View.IndexDistance
}
extension String.UTF16View.Index : Comparable {
    static func ==(_ lhs: String.UTF16View.Index, _ rhs: String.UTF16View.Index) -> Bool
    static func <(_ lhs: String.UTF16View.Index, _ rhs: String.UTF16View.Index) -> Bool
}
Comparable, Strideable

Modified String.UTF16View.Index.init(_: String.UTF8Index, within: String.UTF16View)
Declaration
From
init?(_ utf8Index: UTF8Index, within utf16: String.UTF16View)
To
init?(_ utf8Index: String.UTF8Index, within utf16: String.UTF16View)

Modified String.UTF16View.Index.init(_: String.UnicodeScalarIndex, within: String.UTF16View)
Declaration
From
init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf16: String.UTF16View)
To
init(_ unicodeScalarIndex: String.UnicodeScalarIndex, within utf16: String.UTF16View)

Modified String.UTF16View.Index.init(_: String.Index, within: String.UTF16View)
Declaration
From
init(_ characterIndex: Index, within utf16: String.UTF16View)
To
init(_ characterIndex: String.Index, within utf16: String.UTF16View)

DeclarationProtocols
From
struct UTF8View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : ForwardIndexType {
            @warn_unused_result
            func successor() -> String.UTF8View.Index
        }
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        subscript (_ position: String.UTF8View.Index) -> CodeUnit { get }
        subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
CollectionType, CustomDebugStringConvertible, CustomStringConvertible
To
struct UTF8View : Collection, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        typealias IndexDistance = Int
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        func index(after i: String.UTF8View.Index) -> String.UTF8View.Index
        subscript(_ position: String.UTF8View.Index) -> UTF8.CodeUnit { get }
        subscript(_ bounds: Range<String.UTF8View.Index>) -> String.UTF8View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
extension String.UTF8View {
    func makeIterator() -> IndexingIterator<String.UTF8View>
}
extension String.UTF8View {
    mutating func popFirst() -> UInt8?
    func map<T>(_ transform: (UInt8) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> String.UTF8View
    func dropLast(_ n: Int) -> String.UTF8View
    func prefix(_ maxLength: Int) -> String.UTF8View
    func suffix(_ maxLength: Int) -> String.UTF8View
    func prefix(upTo end: String.UTF8View.Index) -> String.UTF8View
    func suffix(from start: String.UTF8View.Index) -> String.UTF8View
    func prefix(through position: String.UTF8View.Index) -> String.UTF8View
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (UInt8) throws -> Bool) rethrows -> [String.UTF8View]
    func split(separator separator: UInt8, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [String.UTF8View]
    mutating func removeFirst() -> UInt8
    mutating func removeFirst(_ n: Int)
    typealias Generator = IndexingIterator<String.UTF8View>
    func generate() -> IndexingIterator<String.UTF8View>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (UInt8) throws -> Bool) rethrows -> [String.UTF8View]
    func split(_ separator: UInt8, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [String.UTF8View]
    func index(of element: UInt8) -> String.UTF8View.Index?
    func index(where predicate: (UInt8) throws -> Bool) rethrows -> String.UTF8View.Index?
    func sorted() -> [UInt8]
    func sorted(by areInIncreasingOrder: (UInt8, UInt8) -> Bool) -> [UInt8]
    subscript(_ bounds: ClosedRange<String.UTF8View.Index>) -> String.UTF8View { get }
    func sort(_ isOrderedBefore: (UInt8, UInt8) -> Bool) -> [UInt8]
    func sort() -> [UInt8]
    func indexOf(_ element: UInt8) -> String.UTF8View.Index?
    var indices: DefaultIndices<String.UTF8View> { get }
    var lazy: LazySequence<String.UTF8View> { get }
    func map<T>(_ transform: (UInt8) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (UInt8) throws -> Bool) rethrows -> [UInt8]
    var underestimatedCount: Int { get }
    func forEach(_ body: (UInt8) throws -> Void) rethrows
    func first(where predicate: (UInt8) throws -> Bool) rethrows -> UInt8?
    func dropFirst() -> String.UTF8View
    func dropLast() -> String.UTF8View
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (UInt8) throws -> Bool) rethrows -> [String.UTF8View]
    func enumerated() -> EnumeratedSequence<String.UTF8View>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?
    @warn_unqualified_access
    func min() -> UInt8?
    @warn_unqualified_access
    func max() -> UInt8?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with possiblePrefix: PossiblePrefix, by areEquivalent: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence, by areEquivalent: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence) -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence, by areInIncreasingOrder: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence) -> Bool
    func contains(_ element: UInt8) -> Bool
    func contains(where predicate: (UInt8) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, UInt8) throws -> Result) rethrows -> Result
    func reversed() -> [UInt8]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (UInt8) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (UInt8) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<String.UTF8View>
    func minElement(_ isOrderedBefore: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?
    func maxElement(_ isOrderedBefore: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?
    func reverse() -> [UInt8]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence, isEquivalent isEquivalent: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, UInt8) throws -> Result) rethrows -> Result
    func minElement() -> UInt8?
    func maxElement() -> UInt8?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence) -> Bool
}
extension String.UTF8View {
    var isEmpty: Bool { get }
    var first: UInt8? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension String.UTF8View {
    var lazy: LazyCollection<String.UTF8View> { get }
}
extension String.UTF8View {
    func formIndex(after i: inout String.UTF8View.Index)
    func index(_ i: String.UTF8View.Index, offsetBy n: Int) -> String.UTF8View.Index
    func index(_ i: String.UTF8View.Index, offsetBy n: Int, limitedBy limit: String.UTF8View.Index) -> String.UTF8View.Index?
    func formIndex(_ i: inout String.UTF8View.Index, offsetBy n: Int)
    func formIndex(_ i: inout String.UTF8View.Index, offsetBy n: Int, limitedBy limit: String.UTF8View.Index) -> Bool
    func distance(from start: String.UTF8View.Index, to end: String.UTF8View.Index) -> Int
}
extension String.UTF8View : CustomReflectable {
    var customMirror: Mirror { get }
}
extension String.UTF8View : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
Collection, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible

Modified String.UTF8View.subscript(_: Range<String.UTF8View.Index>) -> String.UTF8View
Declaration
From
subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get }
To
subscript(_ bounds: Range<String.UTF8View.Index>) -> String.UTF8View { get }

Declaration
From
subscript (_ position: String.UTF8View.Index) -> CodeUnit { get }
To
subscript(_ position: String.UTF8View.Index) -> UTF8.CodeUnit { get }

Modified String.UTF8View.Index [struct]
DeclarationProtocols
From
struct Index : ForwardIndexType {
            @warn_unused_result
            func successor() -> String.UTF8View.Index
        }
extension String.UTF8View.Index {
    init?(_ utf16Index: UTF16Index, within utf8: String.UTF8View)
    init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf8: String.UTF8View)
    init(_ characterIndex: Index, within utf8: String.UTF8View)
    @warn_unused_result
    func samePositionIn(_ utf16: String.UTF16View) -> String.UTF16View.Index?
    @warn_unused_result
    func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> UnicodeScalarIndex?
    @warn_unused_result
    func samePositionIn(_ characters: String) -> Index?
}
ForwardIndexType
To
struct Index {
        }
extension String.UTF8View.Index {
    init?(_ utf16Index: String.UTF16Index, within utf8: String.UTF8View)
    init(_ unicodeScalarIndex: String.UnicodeScalarIndex, within utf8: String.UTF8View)
    init(_ characterIndex: String.Index, within utf8: String.UTF8View)
    func samePosition(in utf16: String.UTF16View) -> String.UTF16View.Index?
    func samePosition(in unicodeScalars: String.UnicodeScalarView) -> String.UnicodeScalarIndex?
    func samePosition(in characters: String) -> String.Index?
    func successor() -> String.UTF8View.Index
    func advancedBy(_ n: String.UTF8View.IndexDistance) -> String.UTF8View.Index
    func advancedBy(_ n: String.UTF8View.IndexDistance, limit limit: String.UTF8View.Index) -> String.UTF8View.Index
    func distanceTo(_ end: String.UTF8View.Index) -> String.UTF8View.IndexDistance
}
extension String.UTF8View.Index : Comparable {
    static func ==(_ lhs: String.UTF8View.Index, _ rhs: String.UTF8View.Index) -> Bool
    static func <(_ lhs: String.UTF8View.Index, _ rhs: String.UTF8View.Index) -> Bool
}
Comparable

Modified String.UTF8View.Index.init(_: String.Index, within: String.UTF8View)
Declaration
From
init(_ characterIndex: Index, within utf8: String.UTF8View)
To
init(_ characterIndex: String.Index, within utf8: String.UTF8View)

Modified String.UTF8View.Index.init(_: String.UTF16Index, within: String.UTF8View)
Declaration
From
init?(_ utf16Index: UTF16Index, within utf8: String.UTF8View)
To
init?(_ utf16Index: String.UTF16Index, within utf8: String.UTF8View)

Modified String.UTF8View.Index.init(_: String.UnicodeScalarIndex, within: String.UTF8View)
Declaration
From
init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf8: String.UTF8View)
To
init(_ unicodeScalarIndex: String.UnicodeScalarIndex, within utf8: String.UTF8View)

Modified UInt [struct]
DeclarationProtocols
From
struct UInt : UnsignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ v: Builtin.Word)
    init(_ value: UInt)
    init(bigEndian value: UInt)
    init(littleEndian value: UInt)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt)
    var bigEndian: UInt { get }
    var littleEndian: UInt { get }
    var byteSwapped: UInt { get }
    static var max: UInt { get }
    static var min: UInt { get }
}
extension UInt {
    init(_ value: CGFloat)
}
extension UInt : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension UInt : Hashable {
    var hashValue: Int { get }
}
extension UInt : CustomStringConvertible {
    var description: String { get }
}
extension UInt : RandomAccessIndexType {
    func successor() -> UInt
    func predecessor() -> UInt
    func distanceTo(_ other: UInt) -> Distance
    func advancedBy(_ n: Distance) -> UInt
}
extension UInt {
    static func addWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: Int)
    init(bitPattern bitPattern: Int)
}
extension UInt : BitwiseOperationsType {
    static var allZeros: UInt { get }
}
extension UInt {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt : _Reflectable {
}
extension UInt : CVarArgType {
}
BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, UnsignedIntegerType
To
struct UInt : UnsignedInteger, Comparable, Equatable {
    init()
    init(bigEndian value: UInt)
    init(littleEndian value: UInt)
    init(integerLiteral value: UInt)
    var bigEndian: UInt { get }
    var littleEndian: UInt { get }
    var byteSwapped: UInt { get }
    static var max: UInt { get }
    static var min: UInt { get }
    init(bitPattern pointer: OpaquePointer?)
    static func addWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
    init(_ value: UInt8)
    init?(exactly value: UInt8)
    init(_ value: Int8)
    init?(exactly value: Int8)
    init(_ value: UInt16)
    init?(exactly value: UInt16)
    init(_ value: Int16)
    init?(exactly value: Int16)
    init(_ value: UInt32)
    init?(exactly value: UInt32)
    init(_ value: Int32)
    init?(exactly value: Int32)
    init(_ value: UInt64)
    init?(exactly value: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ value: Int64)
    init?(exactly value: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ value: UInt)
    init?(exactly value: UInt)
    init(_ value: Int)
    init?(exactly value: Int)
    init(bitPattern bitPattern: Int)
    init(_ other: Float)
    init(_ other: Double)
    init?(_ text: String, radix radix: Int = default)
    init(bitPattern objectID: ObjectIdentifier)
    init(_ objectID: ObjectIdentifier)
    init<U>(bitPattern bitPattern: UnsafeMutablePointer<U>?)
    init<U>(bitPattern bitPattern: UnsafePointer<U>?)
    init(bitPattern bitPattern: UnsafeMutableRawPointer?)
    init(bitPattern bitPattern: UnsafeRawPointer?)
    func distance(to other: UInt) -> Int
    func advanced(by n: Int) -> UInt
}
extension UInt {
    init(_ value: CGFloat)
}
extension UInt {
    init(_ number: NSNumber)
}
extension UInt : Hashable {
    var hashValue: Int { get }
}
extension UInt : CustomStringConvertible {
    var description: String { get }
}
extension UInt : BitwiseOperations {
    static var allZeros: UInt { get }
}
extension UInt : CustomReflectable {
    var customMirror: Mirror { get }
}
extension UInt : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension UInt : CVarArg {
}
BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, UnsignedInteger

DeclarationProtocols
From
struct UInt16 : UnsignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: UInt16)
    init(bigEndian value: UInt16)
    init(littleEndian value: UInt16)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt16)
    var bigEndian: UInt16 { get }
    var littleEndian: UInt16 { get }
    var byteSwapped: UInt16 { get }
    static var max: UInt16 { get }
    static var min: UInt16 { get }
}
extension UInt16 {
    init(_ value: CGFloat)
}
extension UInt16 : Hashable {
    var hashValue: Int { get }
}
extension UInt16 : CustomStringConvertible {
    var description: String { get }
}
extension UInt16 : RandomAccessIndexType {
    func successor() -> UInt16
    func predecessor() -> UInt16
    func distanceTo(_ other: UInt16) -> Distance
    func advancedBy(_ n: Distance) -> UInt16
}
extension UInt16 {
    static func addWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt16 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int16)
}
extension UInt16 : BitwiseOperationsType {
    static var allZeros: UInt16 { get }
}
extension UInt16 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt16 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt16 : _Reflectable {
}
extension UInt16 : CVarArgType {
}
BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, UnsignedIntegerType
To
struct UInt16 : UnsignedInteger, Comparable, Equatable {
    init()
    init(bigEndian value: UInt16)
    init(littleEndian value: UInt16)
    init(integerLiteral value: UInt16)
    var bigEndian: UInt16 { get }
    var littleEndian: UInt16 { get }
    var byteSwapped: UInt16 { get }
    static var max: UInt16 { get }
    static var min: UInt16 { get }
    static func addWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
    init(_ value: UInt8)
    init?(exactly value: UInt8)
    init(_ value: Int8)
    init?(exactly value: Int8)
    init(_ value: UInt16)
    init?(exactly value: UInt16)
    init(_ value: Int16)
    init?(exactly value: Int16)
    init(_ value: UInt32)
    init?(exactly value: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ value: Int32)
    init?(exactly value: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ value: UInt64)
    init?(exactly value: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ value: Int64)
    init?(exactly value: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ value: UInt)
    init?(exactly value: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ value: Int)
    init?(exactly value: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int16)
    init(_ other: Float)
    init(_ other: Double)
    init?(_ text: String, radix radix: Int = default)
    func distance(to other: UInt16) -> Int
    func advanced(by n: Int) -> UInt16
}
extension UInt16 {
    init(_ value: CGFloat)
}
extension UInt16 : Hashable {
    var hashValue: Int { get }
}
extension UInt16 : CustomStringConvertible {
    var description: String { get }
}
extension UInt16 : BitwiseOperations {
    static var allZeros: UInt16 { get }
}
extension UInt16 : CustomReflectable {
    var customMirror: Mirror { get }
}
extension UInt16 : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension UInt16 : CVarArg {
}
BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, UnsignedInteger

DeclarationProtocols
From
struct UInt32 : UnsignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: UInt32)
    init(bigEndian value: UInt32)
    init(littleEndian value: UInt32)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt32)
    var bigEndian: UInt32 { get }
    var littleEndian: UInt32 { get }
    var byteSwapped: UInt32 { get }
    static var max: UInt32 { get }
    static var min: UInt32 { get }
}
extension UInt32 {
    init(_ value: CGFloat)
}
extension UInt32 : Hashable {
    var hashValue: Int { get }
}
extension UInt32 : CustomStringConvertible {
    var description: String { get }
}
extension UInt32 : RandomAccessIndexType {
    func successor() -> UInt32
    func predecessor() -> UInt32
    func distanceTo(_ other: UInt32) -> Distance
    func advancedBy(_ n: Distance) -> UInt32
}
extension UInt32 {
    static func addWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt32 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int32)
}
extension UInt32 : BitwiseOperationsType {
    static var allZeros: UInt32 { get }
}
extension UInt32 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt32 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt32 : _Reflectable {
}
extension UInt32 {
    init(_ v: UnicodeScalar)
}
extension UInt32 : CVarArgType {
}
BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, UnsignedIntegerType
To
struct UInt32 : UnsignedInteger, Comparable, Equatable {
    init()
    init(bigEndian value: UInt32)
    init(littleEndian value: UInt32)
    init(integerLiteral value: UInt32)
    var bigEndian: UInt32 { get }
    var littleEndian: UInt32 { get }
    var byteSwapped: UInt32 { get }
    static var max: UInt32 { get }
    static var min: UInt32 { get }
    static func addWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
    init(_ value: UInt8)
    init?(exactly value: UInt8)
    init(_ value: Int8)
    init?(exactly value: Int8)
    init(_ value: UInt16)
    init?(exactly value: UInt16)
    init(_ value: Int16)
    init?(exactly value: Int16)
    init(_ value: UInt32)
    init?(exactly value: UInt32)
    init(_ value: Int32)
    init?(exactly value: Int32)
    init(_ value: UInt64)
    init?(exactly value: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ value: Int64)
    init?(exactly value: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ value: UInt)
    init?(exactly value: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ value: Int)
    init?(exactly value: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int32)
    init(_ other: Float)
    init(_ other: Double)
    init?(_ text: String, radix radix: Int = default)
    init(_ v: UnicodeScalar)
    func distance(to other: UInt32) -> Int
    func advanced(by n: Int) -> UInt32
}
extension UInt32 {
    init(_ value: CGFloat)
}
extension UInt32 : Hashable {
    var hashValue: Int { get }
}
extension UInt32 : CustomStringConvertible {
    var description: String { get }
}
extension UInt32 : BitwiseOperations {
    static var allZeros: UInt32 { get }
}
extension UInt32 : CustomReflectable {
    var customMirror: Mirror { get }
}
extension UInt32 : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension UInt32 : CVarArg {
}
BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, UnsignedInteger

DeclarationProtocols
From
struct UInt64 : UnsignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: UInt64)
    init(bigEndian value: UInt64)
    init(littleEndian value: UInt64)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt64)
    var bigEndian: UInt64 { get }
    var littleEndian: UInt64 { get }
    var byteSwapped: UInt64 { get }
    static var max: UInt64 { get }
    static var min: UInt64 { get }
}
extension UInt64 {
    init(_ value: CGFloat)
}
extension UInt64 : Hashable {
    var hashValue: Int { get }
}
extension UInt64 : CustomStringConvertible {
    var description: String { get }
}
extension UInt64 : RandomAccessIndexType {
    func successor() -> UInt64
    func predecessor() -> UInt64
    func distanceTo(_ other: UInt64) -> Distance
    func advancedBy(_ n: Distance) -> UInt64
}
extension UInt64 {
    static func addWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt64 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
    init(bitPattern bitPattern: Int64)
}
extension UInt64 : BitwiseOperationsType {
    static var allZeros: UInt64 { get }
}
extension UInt64 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt64 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt64 : _Reflectable {
}
extension UInt64 {
    init(_ v: UnicodeScalar)
}
extension UInt64 : CVarArgType, _CVarArgAlignedType {
}
BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, UnsignedIntegerType
To
struct UInt64 : UnsignedInteger, Comparable, Equatable {
    init()
    init(bigEndian value: UInt64)
    init(littleEndian value: UInt64)
    init(integerLiteral value: UInt64)
    var bigEndian: UInt64 { get }
    var littleEndian: UInt64 { get }
    var byteSwapped: UInt64 { get }
    static var max: UInt64 { get }
    static var min: UInt64 { get }
    static func addWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
    init(_ value: UInt8)
    init?(exactly value: UInt8)
    init(_ value: Int8)
    init?(exactly value: Int8)
    init(_ value: UInt16)
    init?(exactly value: UInt16)
    init(_ value: Int16)
    init?(exactly value: Int16)
    init(_ value: UInt32)
    init?(exactly value: UInt32)
    init(_ value: Int32)
    init?(exactly value: Int32)
    init(_ value: UInt64)
    init?(exactly value: UInt64)
    init(_ value: Int64)
    init?(exactly value: Int64)
    init(_ value: UInt)
    init?(exactly value: UInt)
    init(_ value: Int)
    init?(exactly value: Int)
    init(bitPattern bitPattern: Int64)
    init(_ other: Float)
    init(_ other: Double)
    init?(_ text: String, radix radix: Int = default)
    init(_ v: UnicodeScalar)
    func distance(to other: UInt64) -> Int
    func advanced(by n: Int) -> UInt64
}
extension UInt64 {
    init(_ value: CGFloat)
}
extension UInt64 : Hashable {
    var hashValue: Int { get }
}
extension UInt64 : CustomStringConvertible {
    var description: String { get }
}
extension UInt64 : BitwiseOperations {
    static var allZeros: UInt64 { get }
}
extension UInt64 : CustomReflectable {
    var customMirror: Mirror { get }
}
extension UInt64 : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension UInt64 : CVarArg {
}
BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, UnsignedInteger

DeclarationProtocols
From
struct UInt8 : UnsignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: UInt8)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt8)
    static var max: UInt8 { get }
    static var min: UInt8 { get }
}
extension UInt8 {
    init(_ value: CGFloat)
}
extension UInt8 : Hashable {
    var hashValue: Int { get }
}
extension UInt8 : CustomStringConvertible {
    var description: String { get }
}
extension UInt8 : RandomAccessIndexType {
    func successor() -> UInt8
    func predecessor() -> UInt8
    func distanceTo(_ other: UInt8) -> Distance
    func advancedBy(_ n: Distance) -> UInt8
}
extension UInt8 {
    static func addWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt8 {
    init(_ v: Int8)
    init(_ v: UInt16)
    init(truncatingBitPattern truncatingBitPattern: UInt16)
    init(_ v: Int16)
    init(truncatingBitPattern truncatingBitPattern: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int8)
}
extension UInt8 : BitwiseOperationsType {
    static var allZeros: UInt8 { get }
}
extension UInt8 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt8 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt8 : _Reflectable {
}
extension UInt8 {
    init(ascii v: UnicodeScalar)
}
extension UInt8 : CVarArgType {
}
BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, UnsignedIntegerType
To
struct UInt8 : UnsignedInteger, Comparable, Equatable {
    init()
    init(integerLiteral value: UInt8)
    static var max: UInt8 { get }
    static var min: UInt8 { get }
    static func addWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
    init(_ value: UInt8)
    init?(exactly value: UInt8)
    init(_ value: Int8)
    init?(exactly value: Int8)
    init(_ value: UInt16)
    init?(exactly value: UInt16)
    init(truncatingBitPattern truncatingBitPattern: UInt16)
    init(_ value: Int16)
    init?(exactly value: Int16)
    init(truncatingBitPattern truncatingBitPattern: Int16)
    init(_ value: UInt32)
    init?(exactly value: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ value: Int32)
    init?(exactly value: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ value: UInt64)
    init?(exactly value: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ value: Int64)
    init?(exactly value: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ value: UInt)
    init?(exactly value: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ value: Int)
    init?(exactly value: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int8)
    init(_ other: Float)
    init(_ other: Double)
    init?(_ text: String, radix radix: Int = default)
    init(ascii v: UnicodeScalar)
    func distance(to other: UInt8) -> Int
    func advanced(by n: Int) -> UInt8
}
extension UInt8 {
    init(_ value: CGFloat)
}
extension UInt8 : Hashable {
    var hashValue: Int { get }
}
extension UInt8 : CustomStringConvertible {
    var description: String { get }
}
extension UInt8 : BitwiseOperations {
    static var allZeros: UInt8 { get }
}
extension UInt8 : CustomReflectable {
    var customMirror: Mirror { get }
}
extension UInt8 : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension UInt8 : CVarArg {
}
BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, UnsignedInteger

DeclarationProtocols
From
enum UnicodeDecodingResult {
    case Result(UnicodeScalar)
    case EmptyInput
    case Error
    @warn_unused_result
    func isEmptyInput() -> Bool
}
--
To
enum UnicodeDecodingResult : Equatable {
    case scalarValue(UnicodeScalar)
    case emptyInput
    case error
    static func ==(_ lhs: UnicodeDecodingResult, _ rhs: UnicodeDecodingResult) -> Bool
}
Equatable

DeclarationProtocols
From
struct UnicodeScalar : UnicodeScalarLiteralConvertible {
    var value: UInt32 { get }
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
    init(unicodeScalarLiteral value: UnicodeScalar)
    init()
    init(_ v: UInt32)
    init(_ v: UInt16)
    init(_ v: UInt8)
    init(_ v: UnicodeScalar)
    @warn_unused_result
    func escape(asASCII forceASCII: Bool) -> String
    @warn_unused_result
    func isASCII() -> Bool
}
extension UnicodeScalar : _Reflectable {
}
extension UnicodeScalar : Streamable {
    func writeTo<Target : OutputStreamType>(inout _ target: Target)
}
extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension UnicodeScalar : Hashable {
    var hashValue: Int { get }
}
extension UnicodeScalar {
    init(_ v: Int)
}
extension UnicodeScalar : Comparable, Equatable {
}
Comparable, CustomDebugStringConvertible, CustomStringConvertible, Equatable, Hashable, Streamable, UnicodeScalarLiteralConvertible
To
struct UnicodeScalar : ExpressibleByUnicodeScalarLiteral {
    var value: UInt32 { get }
    init(unicodeScalarLiteral value: UnicodeScalar)
    init?(_ v: UInt32)
    init?(_ v: UInt16)
    init(_ v: UInt8)
    init(_ v: UnicodeScalar)
    func escaped(asASCII forceASCII: Bool) -> String
    var isASCII: Bool { get }
    init?(_ v: Int)
    init()
    func escape(asASCII forceASCII: Bool) -> String
}
extension UnicodeScalar : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension UnicodeScalar : TextOutputStreamable {
    func write<Target : TextOutputStream>(to target: inout Target)
}
extension UnicodeScalar : Comparable {
    static func <(_ lhs: UnicodeScalar, _ rhs: UnicodeScalar) -> Bool
}
extension UnicodeScalar : LosslessStringConvertible {
    init?(_ description: String)
}
extension UnicodeScalar : Hashable {
    var hashValue: Int { get }
}
extension UnicodeScalar : CustomReflectable {
    var customMirror: Mirror { get }
}
extension UnicodeScalar : Equatable {
    static func ==(_ lhs: UnicodeScalar, _ rhs: UnicodeScalar) -> Bool
}
extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
Comparable, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, ExpressibleByUnicodeScalarLiteral, Hashable, LosslessStringConvertible, TextOutputStreamable

Modified UnicodeScalar.init(_: UInt16)
Declaration
From
init(_ v: UInt16)
To
init?(_ v: UInt16)

Modified UnicodeScalar.init(_: UInt32)
Declaration
From
init(_ v: UInt32)
To
init?(_ v: UInt32)

Modified UnicodeScalar.init(_: Int)
Declaration
From
init(_ v: Int)
To
init?(_ v: Int)

Modified UnicodeScalarIndex.init(_: String.Index, within: String.UnicodeScalarView)
Declaration
From
init(_ characterIndex: Index, within unicodeScalars: String.UnicodeScalarView)
To
init(_ characterIndex: String.Index, within unicodeScalars: String.UnicodeScalarView)

Modified UnicodeScalarIndex.init(_: String.UTF16Index, within: String.UnicodeScalarView)
Declaration
From
init?(_ utf16Index: UTF16Index, within unicodeScalars: String.UnicodeScalarView)
To
init?(_ utf16Index: String.UTF16Index, within unicodeScalars: String.UnicodeScalarView)

Modified UnicodeScalarIndex.init(_: String.UTF8Index, within: String.UnicodeScalarView)
Declaration
From
init?(_ utf8Index: UTF8Index, within unicodeScalars: String.UnicodeScalarView)
To
init?(_ utf8Index: String.UTF8Index, within unicodeScalars: String.UnicodeScalarView)

Declaration
From
struct Unmanaged<Instance : AnyObject> {
    typealias T = Instance
    @warn_unused_result
    static func fromOpaque(_ value: COpaquePointer) -> Unmanaged<Instance>
    @warn_unused_result
    func toOpaque() -> COpaquePointer
    @warn_unused_result
    static func passRetained(_ value: Instance) -> Unmanaged<Instance>
    @warn_unused_result
    static func passUnretained(_ value: Instance) -> Unmanaged<Instance>
    @warn_unused_result
    func takeUnretainedValue() -> Instance
    @warn_unused_result
    func takeRetainedValue() -> Instance
    func retain() -> Unmanaged<Instance>
    func release()
    func autorelease() -> Unmanaged<Instance>
}
To
struct Unmanaged<Instance : AnyObject> {
    static func fromOpaque(_ value: UnsafeRawPointer) -> Unmanaged<Instance>
    func toOpaque() -> UnsafeMutableRawPointer
    static func passRetained(_ value: Instance) -> Unmanaged<Instance>
    static func passUnretained(_ value: Instance) -> Unmanaged<Instance>
    func takeUnretainedValue() -> Instance
    func takeRetainedValue() -> Instance
    func retain() -> Unmanaged<Instance>
    func release()
    func autorelease() -> Unmanaged<Instance>
    static func fromOpaque(_ value: OpaquePointer) -> Unmanaged<Instance>
    func toOpaque() -> OpaquePointer
}

Deprecation
FromtvOS 9.2
To--

Declaration
From
@warn_unused_result
    static func passRetained(_ value: Instance) -> Unmanaged<Instance>
To
static func passRetained(_ value: Instance) -> Unmanaged<Instance>

Declaration
From
@warn_unused_result
    static func passUnretained(_ value: Instance) -> Unmanaged<Instance>
To
static func passUnretained(_ value: Instance) -> Unmanaged<Instance>

Deprecation
FromtvOS 9.2
To--

Declaration
From
@warn_unused_result
    func takeRetainedValue() -> Instance
To
func takeRetainedValue() -> Instance

Declaration
From
@warn_unused_result
    func takeUnretainedValue() -> Instance
To
func takeUnretainedValue() -> Instance

DeclarationProtocols
From
struct UnsafeBufferPointer<Element> : CollectionType {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ i: Int) -> Element { get }
    init(start start: UnsafePointer<Element>, count count: Int)
    func generate() -> UnsafeBufferPointerGenerator<Element>
    var baseAddress: UnsafePointer<Element> { get }
    var count: Int { get }
}
extension UnsafeBufferPointer {
    init(_ audioBuffer: AudioBuffer)
}
extension UnsafeBufferPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
CollectionType, CustomDebugStringConvertible
To
struct UnsafeBufferPointer<Element> : Indexable, Collection, RandomAccessCollection {
    typealias Index = Int
    typealias IndexDistance = Int
    typealias Iterator = IndexingIterator<UnsafeBufferPointer<Element>>
    var startIndex: Int { get }
    var endIndex: Int { get }
    func index(after i: Int) -> Int
    func formIndex(after i: inout Int)
    func index(before i: Int) -> Int
    func formIndex(before i: inout Int)
    func index(_ i: Int, offsetBy n: Int) -> Int
    func index(_ i: Int, offsetBy n: Int, limitedBy limit: Int) -> Int?
    func distance(from start: Int, to end: Int) -> Int
    typealias Indices = CountableRange<Int>
    var indices: UnsafeBufferPointer.Indices { get }
    subscript(_ i: Int) -> Element { get }
    subscript(_ bounds: Range<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>> { get }
    init(start start: UnsafePointer<Element>?, count count: Int)
    func makeIterator() -> UnsafeBufferPointerIterator<Element>
    var baseAddress: UnsafePointer<Element>? { get }
    var count: Int { get }
    func dropLast(_ n: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
    func suffix(_ maxLength: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
    func prefix(_ maxLength: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
    func prefix(upTo end: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
    func suffix(from start: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
    func prefix(through position: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [RandomAccessSlice<UnsafeBufferPointer<Element>>]
    typealias Generator = IndexingIterator<UnsafeBufferPointer<Element>>
    func generate() -> IndexingIterator<UnsafeBufferPointer<Element>>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [RandomAccessSlice<UnsafeBufferPointer<Element>>]
    var last: Element? { get }
    func index(where predicate: (Element) throws -> Bool) rethrows -> Int?
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    subscript(_ bounds: ClosedRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>> { get }
    subscript(_ bounds: CountableRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>> { get }
    subscript(_ bounds: CountableClosedRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>> { get }
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Int?
    var lazy: LazySequence<UnsafeBufferPointer<Element>> { get }
    var indices: CountableRange<Int> { get }
    func reversed() -> ReversedRandomAccessCollection<UnsafeBufferPointer<Element>>
    func reverse() -> ReversedRandomAccessCollection<UnsafeBufferPointer<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> RandomAccessSlice<UnsafeBufferPointer<Element>>
    func dropLast() -> RandomAccessSlice<UnsafeBufferPointer<Element>>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [RandomAccessSlice<UnsafeBufferPointer<Element>>]
    func enumerated() -> EnumeratedSequence<UnsafeBufferPointer<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<UnsafeBufferPointer<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension UnsafeBufferPointer {
    init(_ audioBuffer: AudioBuffer)
}
extension UnsafeBufferPointer {
    var lazy: LazyRandomAccessCollection<UnsafeBufferPointer<Element>> { get }
}
extension UnsafeBufferPointer {
    subscript(_ bounds: Range<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>> { get }
}
extension UnsafeBufferPointer {
    var lazy: LazyBidirectionalCollection<UnsafeBufferPointer<Element>> { get }
}
extension UnsafeBufferPointer {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension UnsafeBufferPointer {
    func formIndex(_ i: inout Int, offsetBy n: Int)
    func formIndex(_ i: inout Int, offsetBy n: Int, limitedBy limit: Int) -> Bool
}
extension UnsafeBufferPointer {
    var lazy: LazyCollection<UnsafeBufferPointer<Element>> { get }
}
extension UnsafeBufferPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension UnsafeBufferPointer where Element : Sequence {
    func joined() -> FlattenSequence<UnsafeBufferPointer<Element>>
    func flatten() -> FlattenSequence<UnsafeBufferPointer<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<UnsafeBufferPointer<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<UnsafeBufferPointer<Element>>
}
extension UnsafeBufferPointer where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension UnsafeBufferPointer where Element : Comparable {
    func sorted() -> [Element]
    func sort() -> [Element]
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension UnsafeBufferPointer where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [RandomAccessSlice<UnsafeBufferPointer<Element>>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [RandomAccessSlice<UnsafeBufferPointer<Element>>]
    func index(of element: Element) -> Int?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension UnsafeBufferPointer where Element : BidirectionalCollection {
    func joined() -> FlattenBidirectionalCollection<UnsafeBufferPointer<Element>>
    func flatten() -> FlattenBidirectionalCollection<UnsafeBufferPointer<Element>>
}
extension UnsafeBufferPointer where Element : Collection {
    func joined() -> FlattenCollection<UnsafeBufferPointer<Element>>
    func flatten() -> FlattenCollection<UnsafeBufferPointer<Element>>
}
Collection, CustomDebugStringConvertible, Indexable, RandomAccessCollection

Declaration
From
var baseAddress: UnsafePointer<Element> { get }
To
var baseAddress: UnsafePointer<Element>? { get }

Declaration
From
subscript (_ i: Int) -> Element { get }
To
subscript(_ i: Int) -> Element { get }

DeclarationProtocols
From
struct UnsafeMutableBufferPointer<Element> : MutableCollectionType {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ i: Int) -> Element { get nonmutating set }
    init(start start: UnsafeMutablePointer<Element>, count count: Int)
    func generate() -> UnsafeBufferPointerGenerator<Element>
    var baseAddress: UnsafeMutablePointer<Element> { get }
    var count: Int { get }
}
extension UnsafeMutableBufferPointer {
    init(_ audioBuffer: AudioBuffer)
}
extension UnsafeMutableBufferPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
CustomDebugStringConvertible, MutableCollectionType
To
struct UnsafeMutableBufferPointer<Element> : MutableIndexable, MutableCollection, RandomAccessCollection {
    typealias Index = Int
    typealias IndexDistance = Int
    typealias Iterator = IndexingIterator<UnsafeMutableBufferPointer<Element>>
    var startIndex: Int { get }
    var endIndex: Int { get }
    func index(after i: Int) -> Int
    func formIndex(after i: inout Int)
    func index(before i: Int) -> Int
    func formIndex(before i: inout Int)
    func index(_ i: Int, offsetBy n: Int) -> Int
    func index(_ i: Int, offsetBy n: Int, limitedBy limit: Int) -> Int?
    func distance(from start: Int, to end: Int) -> Int
    typealias Indices = CountableRange<Int>
    var indices: UnsafeMutableBufferPointer.Indices { get }
    subscript(_ i: Int) -> Element { get nonmutating set }
    subscript(_ bounds: Range<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    init(start start: UnsafeMutablePointer<Element>?, count count: Int)
    func makeIterator() -> UnsafeBufferPointerIterator<Element>
    var baseAddress: UnsafeMutablePointer<Element>? { get }
    var count: Int { get }
    func dropLast(_ n: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    func suffix(_ maxLength: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func dropFirst(_ n: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    func prefix(_ maxLength: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    func prefix(upTo end: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    func suffix(from start: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    func prefix(through position: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>]
    typealias Generator = IndexingIterator<UnsafeMutableBufferPointer<Element>>
    func generate() -> IndexingIterator<UnsafeMutableBufferPointer<Element>>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>]
    var last: Element? { get }
    func index(where predicate: (Element) throws -> Bool) rethrows -> Int?
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int
    func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
    mutating func sort(by areInIncreasingOrder: (Element, Element) -> Bool)
    subscript(_ bounds: ClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> { get }
    subscript(_ bounds: CountableRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> { get }
    subscript(_ bounds: CountableClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> { get }
    subscript(_ bounds: ClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    subscript(_ bounds: CountableRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    subscript(_ bounds: CountableClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    mutating func partition(isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    mutating func partition(_ range: Range<Int>, isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int
    func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
    mutating func sortInPlace(_ isOrderedBefore: (Element, Element) -> Bool)
    func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Int?
    var lazy: LazySequence<UnsafeMutableBufferPointer<Element>> { get }
    subscript(_ bounds: Range<Int>) -> MutableSlice<UnsafeMutableBufferPointer<Element>>
    var indices: CountableRange<Int> { get }
    func reversed() -> ReversedRandomAccessCollection<UnsafeMutableBufferPointer<Element>>
    func reverse() -> ReversedRandomAccessCollection<UnsafeMutableBufferPointer<Element>>
    func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Element) throws -> Void) rethrows
    func first(where predicate: (Element) throws -> Bool) rethrows -> Element?
    func dropFirst() -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    func dropLast() -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>]
    func enumerated() -> EnumeratedSequence<UnsafeMutableBufferPointer<Element>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<UnsafeMutableBufferPointer<Element>>
    func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result
}
extension UnsafeMutableBufferPointer {
    init(_ audioBuffer: AudioBuffer)
}
extension UnsafeMutableBufferPointer {
    var lazy: LazyRandomAccessCollection<UnsafeMutableBufferPointer<Element>> { get }
}
extension UnsafeMutableBufferPointer {
    var lazy: LazyBidirectionalCollection<UnsafeMutableBufferPointer<Element>> { get }
}
extension UnsafeMutableBufferPointer {
    var isEmpty: Bool { get }
    var first: Element? { get }
    var underestimatedCount: Int { get }
    var count: Int { get }
}
extension UnsafeMutableBufferPointer {
    func formIndex(_ i: inout Int, offsetBy n: Int)
    func formIndex(_ i: inout Int, offsetBy n: Int, limitedBy limit: Int) -> Bool
}
extension UnsafeMutableBufferPointer {
    var lazy: LazyCollection<UnsafeMutableBufferPointer<Element>> { get }
}
extension UnsafeMutableBufferPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension UnsafeMutableBufferPointer where Element : Sequence {
    func joined() -> FlattenSequence<UnsafeMutableBufferPointer<Element>>
    func flatten() -> FlattenSequence<UnsafeMutableBufferPointer<Element>>
    func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<UnsafeMutableBufferPointer<Element>>
    func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<UnsafeMutableBufferPointer<Element>>
}
extension UnsafeMutableBufferPointer where Element == String {
    func joined(separator separator: String = default) -> String
    func joinWithSeparator(_ separator: String) -> String
}
extension UnsafeMutableBufferPointer where Element : Comparable {
    func sorted() -> [Element]
    func sorted() -> [Element]
    mutating func sort()
    mutating func partition() -> Int
    mutating func partition(_ range: Range<Int>) -> Int
    func sort() -> [Element]
    mutating func sortInPlace()
    @warn_unqualified_access
    func min() -> Element?
    @warn_unqualified_access
    func max() -> Element?
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
    func minElement() -> Element?
    func maxElement() -> Element?
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension UnsafeMutableBufferPointer where Element : Equatable {
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>]
    func index(of element: Element) -> Int?
    func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>]
    func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>]
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool
}
extension UnsafeMutableBufferPointer where Element : BidirectionalCollection {
    func joined() -> FlattenBidirectionalCollection<UnsafeMutableBufferPointer<Element>>
    func flatten() -> FlattenBidirectionalCollection<UnsafeMutableBufferPointer<Element>>
}
extension UnsafeMutableBufferPointer where Element : Collection {
    func joined() -> FlattenCollection<UnsafeMutableBufferPointer<Element>>
    func flatten() -> FlattenCollection<UnsafeMutableBufferPointer<Element>>
}
CustomDebugStringConvertible, MutableCollection, MutableIndexable, RandomAccessCollection

Declaration
From
var baseAddress: UnsafeMutablePointer<Element> { get }
To
var baseAddress: UnsafeMutablePointer<Element>? { get }

Declaration
From
subscript (_ i: Int) -> Element { get nonmutating set }
To
subscript(_ i: Int) -> Element { get nonmutating set }

DeclarationProtocolsGenerics[Parameters]
From
struct UnsafeMutablePointer<Memory> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType {
    typealias T = Memory
    typealias Distance = Int
    init()
    init(_ other: COpaquePointer)
    init(bitPattern bitPattern: Int)
    init(bitPattern bitPattern: UInt)
    init<U>(_ from: UnsafeMutablePointer<U>)
    init<U>(_ from: UnsafePointer<U>)
    init(nilLiteral nilLiteral: ())
    @warn_unused_result
    static func alloc(_ num: Int) -> UnsafeMutablePointer<Memory>
    func dealloc(_ num: Int)
    var memory: Memory { get nonmutating set }
    func initialize(_ newvalue: Memory)
    @warn_unused_result
    func move() -> Memory
    func assignFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func assignBackwardFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func moveInitializeFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func moveInitializeBackwardFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func initializeFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func initializeFrom<C : CollectionType where C.Generator.Element == Memory>(_ source: C)
    func moveAssignFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func destroy()
    func destroy(_ count: Int)
    subscript (_ i: Int) -> Memory { get nonmutating set }
    var hashValue: Int { get }
    func successor() -> UnsafeMutablePointer<Memory>
    func predecessor() -> UnsafeMutablePointer<Memory>
    func distanceTo(_ x: UnsafeMutablePointer<Memory>) -> Int
    func advancedBy(_ n: Int) -> UnsafeMutablePointer<Memory>
}
extension UnsafeMutablePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension UnsafeMutablePointer : _Reflectable {
}
extension UnsafeMutablePointer : CVarArgType {
}
CVarArgType, CustomDebugStringConvertible, Hashable, NilLiteralConvertible, RandomAccessIndexTypeMemory
To
struct UnsafeMutablePointer<Pointee> : Strideable, Hashable {
    typealias Distance = Int
    init(_ from: OpaquePointer)
    init?(_ from: OpaquePointer?)
    init?(bitPattern bitPattern: Int)
    init?(bitPattern bitPattern: UInt)
    init(_ other: UnsafeMutablePointer<Pointee>)
    init?(_ other: UnsafeMutablePointer<Pointee>?)
    init(mutating other: UnsafePointer<Pointee>)
    init?(mutating other: UnsafePointer<Pointee>?)
    static func allocate(capacity count: Int) -> UnsafeMutablePointer<Pointee>
    func deallocate(capacity capacity: Int)
    var pointee: Pointee { get nonmutating set }
    func initialize(to newValue: Pointee, count count: Int = default)
    func move() -> Pointee
    func assign(from source: UnsafePointer<Pointee>, count count: Int)
    func moveInitialize(from source: UnsafeMutablePointer<Pointee>, count count: Int)
    func initialize(from source: UnsafePointer<Pointee>, count count: Int)
    func initialize<C : Collection where C.Iterator.Element == Pointee>(from source: C)
    func moveAssign(from source: UnsafeMutablePointer<Pointee>, count count: Int)
    func deinitialize(count count: Int = default) -> UnsafeMutableRawPointer
    func withMemoryRebound<T, Result>(to to: T.Type, capacity count: Int, _ body: (UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result
    subscript(_ i: Int) -> Pointee { get nonmutating set }
    var hashValue: Int { get }
    func successor() -> UnsafeMutablePointer<Pointee>
    func predecessor() -> UnsafeMutablePointer<Pointee>
    func distance(to x: UnsafeMutablePointer<Pointee>) -> Int
    func advanced(by n: Int) -> UnsafeMutablePointer<Pointee>
    init<U>(_ from: UnsafeMutablePointer<U>)
    init?<U>(_ from: UnsafeMutablePointer<U>?)
    init<U>(_ from: UnsafePointer<U>)
    init?<U>(_ from: UnsafePointer<U>?)
    init(_ from: UnsafePointer<Pointee>)
    init?(_ from: UnsafePointer<Pointee>?)
    typealias Memory = Pointee
    init()
    static func alloc(_ num: Int) -> UnsafeMutablePointer<Pointee>
    init(allocatingCapacity allocatingCapacity: Int)
    func dealloc(_ num: Int)
    func deallocateCapacity(_ num: Int)
    var memory: Pointee
    func initialize(_ newvalue: Pointee)
    func initialize(with newvalue: Pointee, count count: Int = default)
    func destroy()
    func destroy(_ count: Int)
    func initializeFrom(_ source: UnsafePointer<Pointee>, count count: Int)
    func assignFrom(_ source: UnsafePointer<Pointee>, count count: Int)
    func assignBackwardFrom(_ source: UnsafePointer<Pointee>, count count: Int)
    func moveInitializeFrom(_ source: UnsafePointer<Pointee>, count count: Int)
    func moveInitializeBackwardFrom(_ source: UnsafePointer<Pointee>, count count: Int)
    func moveAssignFrom(_ source: UnsafePointer<Pointee>, count count: Int)
    func stride(to end: UnsafeMutablePointer<Pointee>, by stride: Int) -> StrideTo<UnsafeMutablePointer<Pointee>>
    @warn_unqualified_access
    func stride(through end: UnsafeMutablePointer<Pointee>, by stride: Int) -> StrideThrough<UnsafeMutablePointer<Pointee>>
}
extension UnsafeMutablePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension UnsafeMutablePointer : CustomReflectable {
    var customMirror: Mirror { get }
}
extension UnsafeMutablePointer : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension UnsafeMutablePointer : CVarArg {
}
CVarArg, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, Hashable, StrideablePointee

Declaration
From
init(bitPattern bitPattern: UInt)
To
init?(bitPattern bitPattern: UInt)

Declaration
From
init(bitPattern bitPattern: Int)
To
init?(bitPattern bitPattern: Int)

Declaration
From
@warn_unused_result
    func move() -> Memory
To
func move() -> Pointee

Declaration
From
func predecessor() -> UnsafeMutablePointer<Memory>
To
func predecessor() -> UnsafeMutablePointer<Pointee>

Declaration
From
subscript (_ i: Int) -> Memory { get nonmutating set }
To
subscript(_ i: Int) -> Pointee { get nonmutating set }

Declaration
From
func successor() -> UnsafeMutablePointer<Memory>
To
func successor() -> UnsafeMutablePointer<Pointee>

DeclarationProtocolsGenerics[Parameters]
From
struct UnsafePointer<Memory> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType {
    typealias T = Memory
    typealias Distance = Int
    init()
    init(_ other: COpaquePointer)
    init(bitPattern bitPattern: Int)
    init(bitPattern bitPattern: UInt)
    init<U>(_ from: UnsafeMutablePointer<U>)
    init<U>(_ from: UnsafePointer<U>)
    init(nilLiteral nilLiteral: ())
    var memory: Memory { get }
    subscript (_ i: Int) -> Memory { get }
    var hashValue: Int { get }
    func successor() -> UnsafePointer<Memory>
    func predecessor() -> UnsafePointer<Memory>
    func distanceTo(_ x: UnsafePointer<Memory>) -> Int
    func advancedBy(_ n: Int) -> UnsafePointer<Memory>
}
extension UnsafePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension UnsafePointer : _Reflectable {
}
extension UnsafePointer : CVarArgType {
}
CVarArgType, CustomDebugStringConvertible, Hashable, NilLiteralConvertible, RandomAccessIndexTypeMemory
To
struct UnsafePointer<Pointee> : Strideable, Hashable {
    typealias Distance = Int
    init(_ from: OpaquePointer)
    init?(_ from: OpaquePointer?)
    init?(bitPattern bitPattern: Int)
    init?(bitPattern bitPattern: UInt)
    init(_ other: UnsafePointer<Pointee>)
    init?(_ other: UnsafePointer<Pointee>?)
    init(_ other: UnsafeMutablePointer<Pointee>)
    init?(_ other: UnsafeMutablePointer<Pointee>?)
    var pointee: Pointee { get }
    func withMemoryRebound<T, Result>(to to: T.Type, capacity count: Int, _ body: (UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result
    subscript(_ i: Int) -> Pointee { get }
    var hashValue: Int { get }
    func successor() -> UnsafePointer<Pointee>
    func predecessor() -> UnsafePointer<Pointee>
    func distance(to x: UnsafePointer<Pointee>) -> Int
    func advanced(by n: Int) -> UnsafePointer<Pointee>
    init<U>(_ from: UnsafeMutablePointer<U>)
    init?<U>(_ from: UnsafeMutablePointer<U>?)
    init<U>(_ from: UnsafePointer<U>)
    init?<U>(_ from: UnsafePointer<U>?)
    typealias Memory = Pointee
    init()
    var memory: Pointee { get }
    func stride(to end: UnsafePointer<Pointee>, by stride: Int) -> StrideTo<UnsafePointer<Pointee>>
    @warn_unqualified_access
    func stride(through end: UnsafePointer<Pointee>, by stride: Int) -> StrideThrough<UnsafePointer<Pointee>>
}
extension UnsafePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension UnsafePointer : CustomReflectable {
    var customMirror: Mirror { get }
}
extension UnsafePointer : CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension UnsafePointer : CVarArg {
}
CVarArg, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, Hashable, StrideablePointee

Declaration
From
init(bitPattern bitPattern: UInt)
To
init?(bitPattern bitPattern: UInt)

Declaration
From
init(bitPattern bitPattern: Int)
To
init?(bitPattern bitPattern: Int)

Declaration
From
func predecessor() -> UnsafePointer<Memory>
To
func predecessor() -> UnsafePointer<Pointee>

Declaration
From
subscript (_ i: Int) -> Memory { get }
To
subscript(_ i: Int) -> Pointee { get }

Declaration
From
func successor() -> UnsafePointer<Memory>
To
func successor() -> UnsafePointer<Pointee>

Modified UTF16 [struct]
DeclarationProtocols
From
struct UTF16 : UnicodeCodecType {
    typealias CodeUnit = UInt16
    init()
    mutating func decode<G : GeneratorType where G.Element == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult
    static func encode(_ input: UnicodeScalar, output put: (CodeUnit) -> Void)
}
extension UTF16 {
    @warn_unused_result
    static func width(_ x: UnicodeScalar) -> Int
    @warn_unused_result
    static func leadSurrogate(_ x: UnicodeScalar) -> CodeUnit
    @warn_unused_result
    static func trailSurrogate(_ x: UnicodeScalar) -> CodeUnit
    @warn_unused_result
    static func isLeadSurrogate(_ x: CodeUnit) -> Bool
    @warn_unused_result
    static func isTrailSurrogate(_ x: CodeUnit) -> Bool
    @warn_unused_result
    static func measure<Encoding : UnicodeCodecType, Input : GeneratorType where Encoding.CodeUnit == Input.Element>(_ _: Encoding.Type, input input: Input, repairIllFormedSequences repairIllFormedSequences: Bool) -> (Int, Bool)?
}
UnicodeCodecType
To
struct UTF16 : UnicodeCodec {
    typealias CodeUnit = UInt16
    init()
    mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> UnicodeDecodingResult
    static func encode(_ input: UnicodeScalar, into processCodeUnit: (UTF16.CodeUnit) -> Swift.Void)
    static func width(_ x: UnicodeScalar) -> Int
    static func leadSurrogate(_ x: UnicodeScalar) -> UTF16.CodeUnit
    static func trailSurrogate(_ x: UnicodeScalar) -> UTF16.CodeUnit
    static func isLeadSurrogate(_ x: UTF16.CodeUnit) -> Bool
    static func isTrailSurrogate(_ x: UTF16.CodeUnit) -> Bool
    static func transcodedLength<Input, Encoding where Input : IteratorProtocol, Encoding : UnicodeCodec, Encoding.CodeUnit == Input.Element>(of input: Input, decodedAs sourceEncoding: Encoding.Type, repairingIllFormedSequences repairingIllFormedSequences: Bool) -> (count: Int, isASCII: Bool)?
    static func measure<Encoding, Input where Encoding : UnicodeCodec, Input : IteratorProtocol, Encoding.CodeUnit == Input.Element>(_ _: Encoding.Type, input input: Input, repairIllFormedSequences repairIllFormedSequences: Bool) -> (Int, Bool)?
    static func encode(_ input: UnicodeScalar, output put: (UInt16) -> Void)
}
UnicodeCodec

Modified UTF16.isLeadSurrogate(_: UTF16.CodeUnit) -> Bool [static]
Declaration
From
@warn_unused_result
    static func isLeadSurrogate(_ x: CodeUnit) -> Bool
To
static func isLeadSurrogate(_ x: UTF16.CodeUnit) -> Bool

Modified UTF16.isTrailSurrogate(_: UTF16.CodeUnit) -> Bool [static]
Declaration
From
@warn_unused_result
    static func isTrailSurrogate(_ x: CodeUnit) -> Bool
To
static func isTrailSurrogate(_ x: UTF16.CodeUnit) -> Bool

Modified UTF16.leadSurrogate(_: UnicodeScalar) -> UTF16.CodeUnit [static]
Declaration
From
@warn_unused_result
    static func leadSurrogate(_ x: UnicodeScalar) -> CodeUnit
To
static func leadSurrogate(_ x: UnicodeScalar) -> UTF16.CodeUnit

Modified UTF16.trailSurrogate(_: UnicodeScalar) -> UTF16.CodeUnit [static]
Declaration
From
@warn_unused_result
    static func trailSurrogate(_ x: UnicodeScalar) -> CodeUnit
To
static func trailSurrogate(_ x: UnicodeScalar) -> UTF16.CodeUnit

Modified UTF16.width(_: UnicodeScalar) -> Int [static]
Declaration
From
@warn_unused_result
    static func width(_ x: UnicodeScalar) -> Int
To
static func width(_ x: UnicodeScalar) -> Int

Modified UTF32 [struct]
DeclarationProtocols
From
struct UTF32 : UnicodeCodecType {
    typealias CodeUnit = UInt32
    init()
    mutating func decode<G : GeneratorType where G.Element == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult
    static func encode(_ input: UnicodeScalar, output put: (CodeUnit) -> Void)
}
UnicodeCodecType
To
struct UTF32 : UnicodeCodec {
    typealias CodeUnit = UInt32
    init()
    mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> UnicodeDecodingResult
    static func encode(_ input: UnicodeScalar, into processCodeUnit: (UTF32.CodeUnit) -> Swift.Void)
    static func encode(_ input: UnicodeScalar, output put: (UInt32) -> Void)
}
UnicodeCodec

Modified UTF8 [struct]
DeclarationProtocols
From
struct UTF8 : UnicodeCodecType {
    typealias CodeUnit = UInt8
    init()
    mutating func decode<G : GeneratorType where G.Element == CodeUnit>(inout _ next: G) -> UnicodeDecodingResult
    static func encode(_ input: UnicodeScalar, output put: (CodeUnit) -> Void)
    @warn_unused_result
    static func isContinuation(_ byte: CodeUnit) -> Bool
}
UnicodeCodecType
To
struct UTF8 : UnicodeCodec {
    typealias CodeUnit = UInt8
    init()
    mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> UnicodeDecodingResult
    static func encode(_ input: UnicodeScalar, into processCodeUnit: (UTF8.CodeUnit) -> Swift.Void)
    static func isContinuation(_ byte: UTF8.CodeUnit) -> Bool
    static func encode(_ input: UnicodeScalar, output put: (UInt8) -> Void)
}
UnicodeCodec

Modified UTF8.isContinuation(_: UTF8.CodeUnit) -> Bool [static]
Declaration
From
@warn_unused_result
    static func isContinuation(_ byte: CodeUnit) -> Bool
To
static func isContinuation(_ byte: UTF8.CodeUnit) -> Bool

DeclarationProtocolsGenerics[Constraints]
From
struct Zip2Sequence<Sequence1 : SequenceType, Sequence2 : SequenceType> : SequenceType {
    typealias Stream1 = Sequence1.Generator
    typealias Stream2 = Sequence2.Generator
    typealias Generator = Zip2Generator<Sequence1.Generator, Sequence2.Generator>
    init(_ sequence1: Sequence1, _ sequence2: Sequence2)
    func generate() -> Zip2Generator<Sequence1.Generator, Sequence2.Generator>
}
SequenceType
Sequence1 : SequenceType, Sequence2 : SequenceType
To
struct Zip2Sequence<Sequence1 : Sequence, Sequence2 : Sequence> : Sequence {
    typealias Stream1 = Sequence1.Iterator
    typealias Stream2 = Sequence2.Iterator
    typealias Iterator = Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator>
    typealias Generator = Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator>
    func makeIterator() -> Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator>
    init(_ sequence1: Sequence1, _ sequence2: Sequence2)
    func sorted(by areInIncreasingOrder: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) -> Bool) -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)]
    func sort(_ isOrderedBefore: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) -> Bool) -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)]
    var lazy: LazySequence<Zip2Sequence<Sequence1, Sequence2>> { get }
    func map<T>(_ transform: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> T) rethrows -> [T]
    func filter(_ isIncluded: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)]
    func suffix(_ maxLength: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>
    func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>]
    var underestimatedCount: Int { get }
    func forEach(_ body: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Void) rethrows
    func first(where predicate: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)?
    func dropFirst(_ n: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>
    func dropLast(_ n: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>
    func prefix(_ maxLength: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>
    func dropFirst() -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>
    func dropLast() -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>
    func generate() -> Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator>
    func underestimateCount() -> Int
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>]
    func enumerated() -> EnumeratedSequence<Zip2Sequence<Sequence1, Sequence2>>
    @warn_unqualified_access
    func min(by areInIncreasingOrder: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)?
    @warn_unqualified_access
    func max(by areInIncreasingOrder: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)?
    func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(with possiblePrefix: PossiblePrefix, by areEquivalent: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_ other: OtherSequence, by areEquivalent: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool
    func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_ other: OtherSequence, by areInIncreasingOrder: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool
    func contains(where predicate: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Result) rethrows -> Result
    func reversed() -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)]
    func flatMap<SegmentOfResult : Sequence>(_ transform: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
    func flatMap<ElementOfResult>(_ transform: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
    func enumerate() -> EnumeratedSequence<Zip2Sequence<Sequence1, Sequence2>>
    func minElement(_ isOrderedBefore: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)?
    func maxElement(_ isOrderedBefore: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)?
    func reverse() -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)]
    func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool
    func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_ other: OtherSequence, isEquivalent isEquivalent: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool
    func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool
    func contains(_ predicate: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> Bool
    func reduce<Result>(_ initial: Result, combine combine: (Result, (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Result) rethrows -> Result
}
Sequence
Sequence1 : Sequence, Sequence2 : Sequence

Modified !=(_: _OptionalNilComparisonType, _: T?) -> Bool
Declaration
From
@warn_unused_result
func !=<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool
To
func !=<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool

Modified !=(_: [Element], _: [Element]) -> Bool
Declaration
From
@warn_unused_result
func !=<Element : Equatable>(_ lhs: [Element], _ rhs: [Element]) -> Bool
To
func !=<Element : Equatable>(_ lhs: [Element], _ rhs: [Element]) -> Bool

Declaration
From
@warn_unused_result
func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool
To
func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool

Modified !=(_: T?, _: _OptionalNilComparisonType) -> Bool
Declaration
From
@warn_unused_result
func !=<T>(_ lhs: T?, _ rhs: _OptionalNilComparisonType) -> Bool
To
func !=<T>(_ lhs: T?, _ rhs: _OptionalNilComparisonType) -> Bool

Modified !=(_: ContiguousArray<Element>, _: ContiguousArray<Element>) -> Bool
Declaration
From
@warn_unused_result
func !=<Element : Equatable>(_ lhs: ContiguousArray<Element>, _ rhs: ContiguousArray<Element>) -> Bool
To
func !=<Element : Equatable>(_ lhs: ContiguousArray<Element>, _ rhs: ContiguousArray<Element>) -> Bool

Declaration
From
@warn_unused_result
func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool
To
func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool

Declaration
From
@warn_unused_result
func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool
To
func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool

Modified !=(_: T?, _: T?) -> Bool
Declaration
From
@warn_unused_result
func !=<T : Equatable>(_ lhs: T?, _ rhs: T?) -> Bool
To
func !=<T : Equatable>(_ lhs: T?, _ rhs: T?) -> Bool

Declaration
From
@warn_unused_result
func !=<A : Equatable, B : Equatable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool
To
func !=<A : Equatable, B : Equatable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool

Modified !=(_: ArraySlice<Element>, _: ArraySlice<Element>) -> Bool
Declaration
From
@warn_unused_result
func !=<Element : Equatable>(_ lhs: ArraySlice<Element>, _ rhs: ArraySlice<Element>) -> Bool
To
func !=<Element : Equatable>(_ lhs: ArraySlice<Element>, _ rhs: ArraySlice<Element>) -> Bool

Declaration
From
@warn_unused_result
func !=<A : Equatable, B : Equatable, C : Equatable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool
To
func !=<A : Equatable, B : Equatable, C : Equatable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Declaration
From
@warn_unused_result
func !==(_ lhs: AnyObject?, _ rhs: AnyObject?) -> Bool
To
func !==(_ lhs: AnyObject?, _ rhs: AnyObject?) -> Bool

Modified &=(_: Int64, _: Int64)
Declaration
From
func &=(inout _ lhs: Int64, _ rhs: Int64)
To
func &=(_ lhs: inout Int64, _ rhs: Int64)

Modified &=(_: Int32, _: Int32)
Declaration
From
func &=(inout _ lhs: Int32, _ rhs: Int32)
To
func &=(_ lhs: inout Int32, _ rhs: Int32)

Modified &=(_: Int8, _: Int8)
Declaration
From
func &=(inout _ lhs: Int8, _ rhs: Int8)
To
func &=(_ lhs: inout Int8, _ rhs: Int8)

Modified &=(_: UInt64, _: UInt64)
Declaration
From
func &=(inout _ lhs: UInt64, _ rhs: UInt64)
To
func &=(_ lhs: inout UInt64, _ rhs: UInt64)

Modified &=(_: UInt16, _: UInt16)
Declaration
From
func &=(inout _ lhs: UInt16, _ rhs: UInt16)
To
func &=(_ lhs: inout UInt16, _ rhs: UInt16)

Modified &=(_: Int16, _: Int16)
Declaration
From
func &=(inout _ lhs: Int16, _ rhs: Int16)
To
func &=(_ lhs: inout Int16, _ rhs: Int16)

Modified &=(_: UInt, _: UInt)
Declaration
From
func &=(inout _ lhs: UInt, _ rhs: UInt)
To
func &=(_ lhs: inout UInt, _ rhs: UInt)

Modified &=(_: Int, _: Int)
Declaration
From
func &=(inout _ lhs: Int, _ rhs: Int)
To
func &=(_ lhs: inout Int, _ rhs: Int)

Modified &=(_: UInt8, _: UInt8)
Declaration
From
func &=(inout _ lhs: UInt8, _ rhs: UInt8)
To
func &=(_ lhs: inout UInt8, _ rhs: UInt8)

Modified &=(_: UInt32, _: UInt32)
Declaration
From
func &=(inout _ lhs: UInt32, _ rhs: UInt32)
To
func &=(_ lhs: inout UInt32, _ rhs: UInt32)

Modified *(_: Double, _: Double) -> Double
Declaration
From
@warn_unused_result
func *(_ lhs: Double, _ rhs: Double) -> Double
To
func *(_ lhs: Double, _ rhs: Double) -> Double

Modified *(_: Float, _: Float) -> Float
Declaration
From
@warn_unused_result
func *(_ lhs: Float, _ rhs: Float) -> Float
To
func *(_ lhs: Float, _ rhs: Float) -> Float

Modified *=(_: Int, _: Int)
Declaration
From
func *=(inout _ lhs: Int, _ rhs: Int)
To
func *=(_ lhs: inout Int, _ rhs: Int)

Modified *=(_: UInt8, _: UInt8)
Declaration
From
func *=(inout _ lhs: UInt8, _ rhs: UInt8)
To
func *=(_ lhs: inout UInt8, _ rhs: UInt8)

Modified *=(_: UInt, _: UInt)
Declaration
From
func *=(inout _ lhs: UInt, _ rhs: UInt)
To
func *=(_ lhs: inout UInt, _ rhs: UInt)

Modified *=(_: Int8, _: Int8)
Declaration
From
func *=(inout _ lhs: Int8, _ rhs: Int8)
To
func *=(_ lhs: inout Int8, _ rhs: Int8)

Modified *=(_: Double, _: Double)
Declaration
From
func *=(inout _ lhs: Double, _ rhs: Double)
To
func *=(_ lhs: inout Double, _ rhs: Double)

Modified *=(_: Int16, _: Int16)
Declaration
From
func *=(inout _ lhs: Int16, _ rhs: Int16)
To
func *=(_ lhs: inout Int16, _ rhs: Int16)

Modified *=(_: UInt32, _: UInt32)
Declaration
From
func *=(inout _ lhs: UInt32, _ rhs: UInt32)
To
func *=(_ lhs: inout UInt32, _ rhs: UInt32)

Modified *=(_: Int64, _: Int64)
Declaration
From
func *=(inout _ lhs: Int64, _ rhs: Int64)
To
func *=(_ lhs: inout Int64, _ rhs: Int64)

Modified *=(_: Int32, _: Int32)
Declaration
From
func *=(inout _ lhs: Int32, _ rhs: Int32)
To
func *=(_ lhs: inout Int32, _ rhs: Int32)

Modified *=(_: UInt16, _: UInt16)
Declaration
From
func *=(inout _ lhs: UInt16, _ rhs: UInt16)
To
func *=(_ lhs: inout UInt16, _ rhs: UInt16)

Modified *=(_: Float, _: Float)
Declaration
From
func *=(inout _ lhs: Float, _ rhs: Float)
To
func *=(_ lhs: inout Float, _ rhs: Float)

Modified *=(_: UInt64, _: UInt64)
Declaration
From
func *=(inout _ lhs: UInt64, _ rhs: UInt64)
To
func *=(_ lhs: inout UInt64, _ rhs: UInt64)

Modified +(_: Float) -> Float
Declaration
From
@warn_unused_result
prefix func +(_ x: Float) -> Float
To
prefix func +(_ x: Float) -> Float

Modified +(_: Double) -> Double
Declaration
From
@warn_unused_result
prefix func +(_ x: Double) -> Double
To
prefix func +(_ x: Double) -> Double

Modified +(_: Double, _: Double) -> Double
Declaration
From
@warn_unused_result
func +(_ lhs: Double, _ rhs: Double) -> Double
To
func +(_ lhs: Double, _ rhs: Double) -> Double

Modified +(_: UnsafeMutablePointer<Pointee>, _: Int) -> UnsafeMutablePointer<Pointee>
DeclarationGenerics[Parameters]
From
@warn_unused_result
func +<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: Int) -> UnsafeMutablePointer<Memory>
Memory
To
func +<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: Int) -> UnsafeMutablePointer<Pointee>
Pointee

Modified +(_: Int, _: UnsafePointer<Pointee>) -> UnsafePointer<Pointee>
DeclarationGenerics[Parameters]
From
@warn_unused_result
func +<Memory>(_ lhs: Int, _ rhs: UnsafePointer<Memory>) -> UnsafePointer<Memory>
Memory
To
func +<Pointee>(_ lhs: Int, _ rhs: UnsafePointer<Pointee>) -> UnsafePointer<Pointee>
Pointee

Modified +(_: Int, _: UnsafeMutablePointer<Pointee>) -> UnsafeMutablePointer<Pointee>
DeclarationGenerics[Parameters]
From
@warn_unused_result
func +<Memory>(_ lhs: Int, _ rhs: UnsafeMutablePointer<Memory>) -> UnsafeMutablePointer<Memory>
Memory
To
func +<Pointee>(_ lhs: Int, _ rhs: UnsafeMutablePointer<Pointee>) -> UnsafeMutablePointer<Pointee>
Pointee

Modified +(_: T, _: T.Stride) -> T
Declaration
From
@warn_unused_result
func +<T : Strideable>(_ lhs: T, _ rhs: T.Stride) -> T
To
func +<T : Strideable>(_ lhs: T, _ rhs: T.Stride) -> T

Modified +(_: Float, _: Float) -> Float
Declaration
From
@warn_unused_result
func +(_ lhs: Float, _ rhs: Float) -> Float
To
func +(_ lhs: Float, _ rhs: Float) -> Float

Modified +(_: T.Stride, _: T) -> T
Declaration
From
@warn_unused_result
func +<T : Strideable>(_ lhs: T.Stride, _ rhs: T) -> T
To
func +<T : Strideable>(_ lhs: T.Stride, _ rhs: T) -> T

Modified +(_: UnsafePointer<Pointee>, _: Int) -> UnsafePointer<Pointee>
DeclarationGenerics[Parameters]
From
@warn_unused_result
func +<Memory>(_ lhs: UnsafePointer<Memory>, _ rhs: Int) -> UnsafePointer<Memory>
Memory
To
func +<Pointee>(_ lhs: UnsafePointer<Pointee>, _ rhs: Int) -> UnsafePointer<Pointee>
Pointee

Modified +=(_: UInt64, _: UInt64)
Declaration
From
func +=(inout _ lhs: UInt64, _ rhs: UInt64)
To
func +=(_ lhs: inout UInt64, _ rhs: UInt64)

Modified +=(_: Int8, _: Int8)
Declaration
From
func +=(inout _ lhs: Int8, _ rhs: Int8)
To
func +=(_ lhs: inout Int8, _ rhs: Int8)

Modified +=(_: UInt16, _: UInt16)
Declaration
From
func +=(inout _ lhs: UInt16, _ rhs: UInt16)
To
func +=(_ lhs: inout UInt16, _ rhs: UInt16)

Modified +=(_: UnsafePointer<Pointee>, _: Int)
DeclarationGenerics[Parameters]
From
func +=<Memory>(inout _ lhs: UnsafePointer<Memory>, _ rhs: Int)
Memory
To
func +=<Pointee>(_ lhs: inout UnsafePointer<Pointee>, _ rhs: Int)
Pointee

Modified +=(_: Double, _: Double)
Declaration
From
func +=(inout _ lhs: Double, _ rhs: Double)
To
func +=(_ lhs: inout Double, _ rhs: Double)

Modified +=(_: Int32, _: Int32)
Declaration
From
func +=(inout _ lhs: Int32, _ rhs: Int32)
To
func +=(_ lhs: inout Int32, _ rhs: Int32)

Modified +=(_: UInt, _: UInt)
Declaration
From
func +=(inout _ lhs: UInt, _ rhs: UInt)
To
func +=(_ lhs: inout UInt, _ rhs: UInt)

Modified +=(_: Float, _: Float)
Declaration
From
func +=(inout _ lhs: Float, _ rhs: Float)
To
func +=(_ lhs: inout Float, _ rhs: Float)

Modified +=(_: UInt32, _: UInt32)
Declaration
From
func +=(inout _ lhs: UInt32, _ rhs: UInt32)
To
func +=(_ lhs: inout UInt32, _ rhs: UInt32)

Modified +=(_: Int64, _: Int64)
Declaration
From
func +=(inout _ lhs: Int64, _ rhs: Int64)
To
func +=(_ lhs: inout Int64, _ rhs: Int64)

Modified +=(_: Int, _: Int)
Declaration
From
func +=(inout _ lhs: Int, _ rhs: Int)
To
func +=(_ lhs: inout Int, _ rhs: Int)

Modified +=(_: Int16, _: Int16)
Declaration
From
func +=(inout _ lhs: Int16, _ rhs: Int16)
To
func +=(_ lhs: inout Int16, _ rhs: Int16)

Modified +=(_: UnsafeMutablePointer<Pointee>, _: Int)
DeclarationGenerics[Parameters]
From
func +=<Memory>(inout _ lhs: UnsafeMutablePointer<Memory>, _ rhs: Int)
Memory
To
func +=<Pointee>(_ lhs: inout UnsafeMutablePointer<Pointee>, _ rhs: Int)
Pointee

Modified +=(_: T, _: T.Stride)
Declaration
From
func +=<T : Strideable>(inout _ lhs: T, _ rhs: T.Stride)
To
func +=<T : Strideable>(_ lhs: inout T, _ rhs: T.Stride)

Modified +=(_: UInt8, _: UInt8)
Declaration
From
func +=(inout _ lhs: UInt8, _ rhs: UInt8)
To
func +=(_ lhs: inout UInt8, _ rhs: UInt8)

Modified -(_: Float) -> Float
Declaration
From
@warn_unused_result
prefix func -(_ x: Float) -> Float
To
prefix func -(_ x: Float) -> Float

Modified -(_: Double) -> Double
Declaration
From
@warn_unused_result
prefix func -(_ x: Double) -> Double
To
prefix func -(_ x: Double) -> Double

Modified -(_: UnsafeMutablePointer<Pointee>, _: Int) -> UnsafeMutablePointer<Pointee>
DeclarationGenerics[Parameters]
From
@warn_unused_result
func -<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: Int) -> UnsafeMutablePointer<Memory>
Memory
To
func -<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: Int) -> UnsafeMutablePointer<Pointee>
Pointee

Modified -(_: T, _: T) -> T.Stride
Declaration
From
@warn_unused_result
func -<T : Strideable>(_ lhs: T, _ rhs: T) -> T.Stride
To
func -<T : Strideable>(_ lhs: T, _ rhs: T) -> T.Stride

Modified -(_: T, _: T.Stride) -> T
Declaration
From
@warn_unused_result
func -<T : Strideable>(_ lhs: T, _ rhs: T.Stride) -> T
To
func -<T : Strideable>(_ lhs: T, _ rhs: T.Stride) -> T

Modified -(_: UnsafeMutablePointer<Pointee>, _: UnsafeMutablePointer<Pointee>) -> Int
DeclarationGenerics[Parameters]
From
@warn_unused_result
func -<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: UnsafeMutablePointer<Memory>) -> Int
Memory
To
func -<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: UnsafeMutablePointer<Pointee>) -> Int
Pointee

Modified -(_: Double, _: Double) -> Double
Declaration
From
@warn_unused_result
func -(_ lhs: Double, _ rhs: Double) -> Double
To
func -(_ lhs: Double, _ rhs: Double) -> Double

Modified -(_: Float, _: Float) -> Float
Declaration
From
@warn_unused_result
func -(_ lhs: Float, _ rhs: Float) -> Float
To
func -(_ lhs: Float, _ rhs: Float) -> Float

Modified -(_: UnsafePointer<Pointee>, _: UnsafePointer<Pointee>) -> Int
DeclarationGenerics[Parameters]
From
@warn_unused_result
func -<Memory>(_ lhs: UnsafePointer<Memory>, _ rhs: UnsafePointer<Memory>) -> Int
Memory
To
func -<Pointee>(_ lhs: UnsafePointer<Pointee>, _ rhs: UnsafePointer<Pointee>) -> Int
Pointee

Modified -(_: UnsafePointer<Pointee>, _: Int) -> UnsafePointer<Pointee>
DeclarationGenerics[Parameters]
From
@warn_unused_result
func -<Memory>(_ lhs: UnsafePointer<Memory>, _ rhs: Int) -> UnsafePointer<Memory>
Memory
To
func -<Pointee>(_ lhs: UnsafePointer<Pointee>, _ rhs: Int) -> UnsafePointer<Pointee>
Pointee

Modified -=(_: Int, _: Int)
Declaration
From
func -=(inout _ lhs: Int, _ rhs: Int)
To
func -=(_ lhs: inout Int, _ rhs: Int)

Modified -=(_: Int8, _: Int8)
Declaration
From
func -=(inout _ lhs: Int8, _ rhs: Int8)
To
func -=(_ lhs: inout Int8, _ rhs: Int8)

Modified -=(_: UnsafeMutablePointer<Pointee>, _: Int)
DeclarationGenerics[Parameters]
From
func -=<Memory>(inout _ lhs: UnsafeMutablePointer<Memory>, _ rhs: Int)
Memory
To
func -=<Pointee>(_ lhs: inout UnsafeMutablePointer<Pointee>, _ rhs: Int)
Pointee

Modified -=(_: T, _: T.Stride)
Declaration
From
func -=<T : Strideable>(inout _ lhs: T, _ rhs: T.Stride)
To
func -=<T : Strideable>(_ lhs: inout T, _ rhs: T.Stride)

Modified -=(_: UInt32, _: UInt32)
Declaration
From
func -=(inout _ lhs: UInt32, _ rhs: UInt32)
To
func -=(_ lhs: inout UInt32, _ rhs: UInt32)

Modified -=(_: UnsafePointer<Pointee>, _: Int)
DeclarationGenerics[Parameters]
From
func -=<Memory>(inout _ lhs: UnsafePointer<Memory>, _ rhs: Int)
Memory
To
func -=<Pointee>(_ lhs: inout UnsafePointer<Pointee>, _ rhs: Int)
Pointee

Modified -=(_: Double, _: Double)
Declaration
From
func -=(inout _ lhs: Double, _ rhs: Double)
To
func -=(_ lhs: inout Double, _ rhs: Double)

Modified -=(_: Int16, _: Int16)
Declaration
From
func -=(inout _ lhs: Int16, _ rhs: Int16)
To
func -=(_ lhs: inout Int16, _ rhs: Int16)

Modified -=(_: UInt16, _: UInt16)
Declaration
From
func -=(inout _ lhs: UInt16, _ rhs: UInt16)
To
func -=(_ lhs: inout UInt16, _ rhs: UInt16)

Modified -=(_: UInt8, _: UInt8)
Declaration
From
func -=(inout _ lhs: UInt8, _ rhs: UInt8)
To
func -=(_ lhs: inout UInt8, _ rhs: UInt8)

Modified -=(_: UInt, _: UInt)
Declaration
From
func -=(inout _ lhs: UInt, _ rhs: UInt)
To
func -=(_ lhs: inout UInt, _ rhs: UInt)

Modified -=(_: Float, _: Float)
Declaration
From
func -=(inout _ lhs: Float, _ rhs: Float)
To
func -=(_ lhs: inout Float, _ rhs: Float)

Modified -=(_: Int32, _: Int32)
Declaration
From
func -=(inout _ lhs: Int32, _ rhs: Int32)
To
func -=(_ lhs: inout Int32, _ rhs: Int32)

Modified -=(_: Int64, _: Int64)
Declaration
From
func -=(inout _ lhs: Int64, _ rhs: Int64)
To
func -=(_ lhs: inout Int64, _ rhs: Int64)

Modified -=(_: UInt64, _: UInt64)
Declaration
From
func -=(inout _ lhs: UInt64, _ rhs: UInt64)
To
func -=(_ lhs: inout UInt64, _ rhs: UInt64)

Modified /(_: Float, _: Float) -> Float
Declaration
From
@warn_unused_result
func /(_ lhs: Float, _ rhs: Float) -> Float
To
func /(_ lhs: Float, _ rhs: Float) -> Float

Modified /(_: Double, _: Double) -> Double
Declaration
From
@warn_unused_result
func /(_ lhs: Double, _ rhs: Double) -> Double
To
func /(_ lhs: Double, _ rhs: Double) -> Double

Modified /=(_: Float, _: Float)
Declaration
From
func /=(inout _ lhs: Float, _ rhs: Float)
To
func /=(_ lhs: inout Float, _ rhs: Float)

Modified /=(_: Double, _: Double)
Declaration
From
func /=(inout _ lhs: Double, _ rhs: Double)
To
func /=(_ lhs: inout Double, _ rhs: Double)

Declaration
From
@warn_unused_result
func <<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool
To
func <<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Modified <(_: UnsafePointer<Pointee>, _: UnsafePointer<Pointee>) -> Bool
DeclarationGenerics[Parameters]
From
@warn_unused_result
func <<Memory>(_ lhs: UnsafePointer<Memory>, _ rhs: UnsafePointer<Memory>) -> Bool
Memory
To
func <<Pointee>(_ lhs: UnsafePointer<Pointee>, _ rhs: UnsafePointer<Pointee>) -> Bool
Pointee

Declaration
From
@warn_unused_result
func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool
To
func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool

Declaration
From
@warn_unused_result
func <<A : Comparable, B : Comparable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool
To
func <<A : Comparable, B : Comparable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool

Modified <(_: UnsafeMutablePointer<Pointee>, _: UnsafeMutablePointer<Pointee>) -> Bool
DeclarationGenerics[Parameters]
From
@warn_unused_result
func <<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: UnsafeMutablePointer<Memory>) -> Bool
Memory
To
func <<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: UnsafeMutablePointer<Pointee>) -> Bool
Pointee

Declaration
From
@warn_unused_result
func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool
To
func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool

Declaration
From
@warn_unused_result
func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool
To
func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool

Modified <<=(_: Int16, _: Int16)
Declaration
From
func <<=(inout _ lhs: Int16, _ rhs: Int16)
To
func <<=(_ lhs: inout Int16, _ rhs: Int16)

Modified <<=(_: UInt32, _: UInt32)
Declaration
From
func <<=(inout _ lhs: UInt32, _ rhs: UInt32)
To
func <<=(_ lhs: inout UInt32, _ rhs: UInt32)

Modified <<=(_: Int8, _: Int8)
Declaration
From
func <<=(inout _ lhs: Int8, _ rhs: Int8)
To
func <<=(_ lhs: inout Int8, _ rhs: Int8)

Modified <<=(_: UInt8, _: UInt8)
Declaration
From
func <<=(inout _ lhs: UInt8, _ rhs: UInt8)
To
func <<=(_ lhs: inout UInt8, _ rhs: UInt8)

Modified <<=(_: Int64, _: Int64)
Declaration
From
func <<=(inout _ lhs: Int64, _ rhs: Int64)
To
func <<=(_ lhs: inout Int64, _ rhs: Int64)

Modified <<=(_: UInt, _: UInt)
Declaration
From
func <<=(inout _ lhs: UInt, _ rhs: UInt)
To
func <<=(_ lhs: inout UInt, _ rhs: UInt)

Modified <<=(_: UInt16, _: UInt16)
Declaration
From
func <<=(inout _ lhs: UInt16, _ rhs: UInt16)
To
func <<=(_ lhs: inout UInt16, _ rhs: UInt16)

Modified <<=(_: Int32, _: Int32)
Declaration
From
func <<=(inout _ lhs: Int32, _ rhs: Int32)
To
func <<=(_ lhs: inout Int32, _ rhs: Int32)

Modified <<=(_: Int, _: Int)
Declaration
From
func <<=(inout _ lhs: Int, _ rhs: Int)
To
func <<=(_ lhs: inout Int, _ rhs: Int)

Modified <<=(_: UInt64, _: UInt64)
Declaration
From
func <<=(inout _ lhs: UInt64, _ rhs: UInt64)
To
func <<=(_ lhs: inout UInt64, _ rhs: UInt64)

Declaration
From
@warn_unused_result
func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool
To
func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool

Declaration
From
@warn_unused_result
func <=<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool
To
func <=<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Declaration
From
@warn_unused_result
func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool
To
func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool

Declaration
From
@warn_unused_result
func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool
To
func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool

Declaration
From
@warn_unused_result
func <=<A : Comparable, B : Comparable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool
To
func <=<A : Comparable, B : Comparable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool

Modified ==(_: [Element], _: [Element]) -> Bool
Declaration
From
@warn_unused_result
func ==<Element : Equatable>(_ lhs: [Element], _ rhs: [Element]) -> Bool
To
func ==<Element : Equatable>(_ lhs: [Element], _ rhs: [Element]) -> Bool

Modified ==(_: T?, _: _OptionalNilComparisonType) -> Bool
Declaration
From
@warn_unused_result
func ==<T>(_ lhs: T?, _ rhs: _OptionalNilComparisonType) -> Bool
To
func ==<T>(_ lhs: T?, _ rhs: _OptionalNilComparisonType) -> Bool

Modified ==(_: _OptionalNilComparisonType, _: T?) -> Bool
Declaration
From
@warn_unused_result
func ==<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool
To
func ==<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool

Declaration
From
@warn_unused_result
func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool
To
func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool

Modified ==(_: UnsafeMutablePointer<Pointee>, _: UnsafeMutablePointer<Pointee>) -> Bool
DeclarationGenerics[Parameters]
From
@warn_unused_result
func ==<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: UnsafeMutablePointer<Memory>) -> Bool
Memory
To
func ==<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: UnsafeMutablePointer<Pointee>) -> Bool
Pointee

Modified ==(_: UnsafePointer<Pointee>, _: UnsafePointer<Pointee>) -> Bool
DeclarationGenerics[Parameters]
From
@warn_unused_result
func ==<Memory>(_ lhs: UnsafePointer<Memory>, _ rhs: UnsafePointer<Memory>) -> Bool
Memory
To
func ==<Pointee>(_ lhs: UnsafePointer<Pointee>, _ rhs: UnsafePointer<Pointee>) -> Bool
Pointee

Modified ==(_: ArraySlice<Element>, _: ArraySlice<Element>) -> Bool
Declaration
From
@warn_unused_result
func ==<Element : Equatable>(_ lhs: ArraySlice<Element>, _ rhs: ArraySlice<Element>) -> Bool
To
func ==<Element : Equatable>(_ lhs: ArraySlice<Element>, _ rhs: ArraySlice<Element>) -> Bool

Modified ==(_: AutoreleasingUnsafeMutablePointer<Pointee>, _: AutoreleasingUnsafeMutablePointer<Pointee>) -> Bool
DeclarationGenerics[Parameters]
From
@warn_unused_result
func ==<Memory>(_ lhs: AutoreleasingUnsafeMutablePointer<Memory>, _ rhs: AutoreleasingUnsafeMutablePointer<Memory>) -> Bool
Memory
To
func ==<Pointee>(_ lhs: AutoreleasingUnsafeMutablePointer<Pointee>, _ rhs: AutoreleasingUnsafeMutablePointer<Pointee>) -> Bool
Pointee

Modified ==(_: T?, _: T?) -> Bool
Declaration
From
@warn_unused_result
func ==<T : Equatable>(_ lhs: T?, _ rhs: T?) -> Bool
To
func ==<T : Equatable>(_ lhs: T?, _ rhs: T?) -> Bool

Declaration
From
@warn_unused_result
func ==<A : Equatable, B : Equatable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool
To
func ==<A : Equatable, B : Equatable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool

Modified ==(_: ContiguousArray<Element>, _: ContiguousArray<Element>) -> Bool
Declaration
From
@warn_unused_result
func ==<Element : Equatable>(_ lhs: ContiguousArray<Element>, _ rhs: ContiguousArray<Element>) -> Bool
To
func ==<Element : Equatable>(_ lhs: ContiguousArray<Element>, _ rhs: ContiguousArray<Element>) -> Bool

Declaration
From
@warn_unused_result
func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool
To
func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool

Modified ==(_: _HeapBuffer<Value, Element>, _: _HeapBuffer<Value, Element>) -> Bool
Declaration
From
@warn_unused_result
func ==<Value, Element>(_ lhs: _HeapBuffer<Value, Element>, _ rhs: _HeapBuffer<Value, Element>) -> Bool
To
func ==<Value, Element>(_ lhs: _HeapBuffer<Value, Element>, _ rhs: _HeapBuffer<Value, Element>) -> Bool

Declaration
From
@warn_unused_result
func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool
To
func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool

Declaration
From
@warn_unused_result
func ==<A : Equatable, B : Equatable, C : Equatable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool
To
func ==<A : Equatable, B : Equatable, C : Equatable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Declaration
From
@warn_unused_result
func ===(_ lhs: AnyObject?, _ rhs: AnyObject?) -> Bool
To
func ===(_ lhs: AnyObject?, _ rhs: AnyObject?) -> Bool

Declaration
From
@warn_unused_result
func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool
To
func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool

Declaration
From
@warn_unused_result
func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool
To
func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool

Declaration
From
@warn_unused_result
func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool
To
func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool

Declaration
From
@warn_unused_result
func ><A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool
To
func ><A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Declaration
From
@warn_unused_result
func ><A : Comparable, B : Comparable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool
To
func ><A : Comparable, B : Comparable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool

Declaration
From
@warn_unused_result
func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool
To
func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool

Declaration
From
@warn_unused_result
func >=<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool
To
func >=<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Declaration
From
@warn_unused_result
func >=<A : Comparable, B : Comparable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool
To
func >=<A : Comparable, B : Comparable>(_ lhs: (A, B), _ rhs: (A, B)) -> Bool

Declaration
From
@warn_unused_result
func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool
To
func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool

Declaration
From
@warn_unused_result
func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool
To
func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool

Modified >>=(_: Int32, _: Int32)
Declaration
From
func >>=(inout _ lhs: Int32, _ rhs: Int32)
To
func >>=(_ lhs: inout Int32, _ rhs: Int32)

Modified >>=(_: Int, _: Int)
Declaration
From
func >>=(inout _ lhs: Int, _ rhs: Int)
To
func >>=(_ lhs: inout Int, _ rhs: Int)

Modified >>=(_: Int64, _: Int64)
Declaration
From
func >>=(inout _ lhs: Int64, _ rhs: Int64)
To
func >>=(_ lhs: inout Int64, _ rhs: Int64)

Modified >>=(_: Int16, _: Int16)
Declaration
From
func >>=(inout _ lhs: Int16, _ rhs: Int16)
To
func >>=(_ lhs: inout Int16, _ rhs: Int16)

Modified >>=(_: UInt, _: UInt)
Declaration
From
func >>=(inout _ lhs: UInt, _ rhs: UInt)
To
func >>=(_ lhs: inout UInt, _ rhs: UInt)

Modified >>=(_: UInt64, _: UInt64)
Declaration
From
func >>=(inout _ lhs: UInt64, _ rhs: UInt64)
To
func >>=(_ lhs: inout UInt64, _ rhs: UInt64)

Modified >>=(_: UInt16, _: UInt16)
Declaration
From
func >>=(inout _ lhs: UInt16, _ rhs: UInt16)
To
func >>=(_ lhs: inout UInt16, _ rhs: UInt16)

Modified >>=(_: UInt32, _: UInt32)
Declaration
From
func >>=(inout _ lhs: UInt32, _ rhs: UInt32)
To
func >>=(_ lhs: inout UInt32, _ rhs: UInt32)

Modified >>=(_: Int8, _: Int8)
Declaration
From
func >>=(inout _ lhs: Int8, _ rhs: Int8)
To
func >>=(_ lhs: inout Int8, _ rhs: Int8)

Modified >>=(_: UInt8, _: UInt8)
Declaration
From
func >>=(inout _ lhs: UInt8, _ rhs: UInt8)
To
func >>=(_ lhs: inout UInt8, _ rhs: UInt8)

Declaration
From
@warn_unused_result
func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T?) rethrows -> T?
To
func ??<T>(_ optional: T?, _ defaultValue: @autoclosure () throws -> T?) rethrows -> T?

Declaration
From
@warn_unused_result
func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T) rethrows -> T
To
func ??<T>(_ optional: T?, _ defaultValue: @autoclosure () throws -> T) rethrows -> T

Modified ^=(_: UInt, _: UInt)
Declaration
From
func ^=(inout _ lhs: UInt, _ rhs: UInt)
To
func ^=(_ lhs: inout UInt, _ rhs: UInt)

Modified ^=(_: Int16, _: Int16)
Declaration
From
func ^=(inout _ lhs: Int16, _ rhs: Int16)
To
func ^=(_ lhs: inout Int16, _ rhs: Int16)

Modified ^=(_: UInt32, _: UInt32)
Declaration
From
func ^=(inout _ lhs: UInt32, _ rhs: UInt32)
To
func ^=(_ lhs: inout UInt32, _ rhs: UInt32)

Modified ^=(_: UInt16, _: UInt16)
Declaration
From
func ^=(inout _ lhs: UInt16, _ rhs: UInt16)
To
func ^=(_ lhs: inout UInt16, _ rhs: UInt16)

Modified ^=(_: Int, _: Int)
Declaration
From
func ^=(inout _ lhs: Int, _ rhs: Int)
To
func ^=(_ lhs: inout Int, _ rhs: Int)

Modified ^=(_: Int32, _: Int32)
Declaration
From
func ^=(inout _ lhs: Int32, _ rhs: Int32)
To
func ^=(_ lhs: inout Int32, _ rhs: Int32)

Modified ^=(_: UInt8, _: UInt8)
Declaration
From
func ^=(inout _ lhs: UInt8, _ rhs: UInt8)
To
func ^=(_ lhs: inout UInt8, _ rhs: UInt8)

Modified ^=(_: Int64, _: Int64)
Declaration
From
func ^=(inout _ lhs: Int64, _ rhs: Int64)
To
func ^=(_ lhs: inout Int64, _ rhs: Int64)

Modified ^=(_: Int8, _: Int8)
Declaration
From
func ^=(inout _ lhs: Int8, _ rhs: Int8)
To
func ^=(_ lhs: inout Int8, _ rhs: Int8)

Modified ^=(_: UInt64, _: UInt64)
Declaration
From
func ^=(inout _ lhs: UInt64, _ rhs: UInt64)
To
func ^=(_ lhs: inout UInt64, _ rhs: UInt64)

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

Declaration
From
func assertionFailure(@autoclosure _ message: () -> String = default, file file: StaticString = #file, line line: UInt = #line)
To
func assertionFailure(_ message: @autoclosure () -> String = default, file file: StaticString = #file, line line: UInt = #line)

Declaration
From
typealias Index = Bit
To
typealias Index = Int

Declaration
From
typealias Element = (Key, Value)
To
typealias Element = (key: Key, value: Value)

Declaration
From
typealias Element = (Key, Value)
To
typealias Element = (key: Key, value: Value)

Declaration
From
@warn_unused_result
func max<T : Comparable>(_ x: T, _ y: T) -> T
To
func max<T : Comparable>(_ x: T, _ y: T) -> T

Declaration
From
@warn_unused_result
func max<T : Comparable>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T
To
func max<T : Comparable>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T

Declaration
From
@warn_unused_result
func min<T : Comparable>(_ x: T, _ y: T) -> T
To
func min<T : Comparable>(_ x: T, _ y: T) -> T

Declaration
From
@warn_unused_result
func min<T : Comparable>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T
To
func min<T : Comparable>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T

Declaration
From
typealias Children = AnyForwardCollection<Child>
To
typealias Children = AnyCollection<Mirror.Child>

Modified MutableIndexable.Index
Declaration
From
associatedtype Index : ForwardIndexType
To
associatedtype Index : Comparable

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

Declaration
From
associatedtype Stride : SignedNumberType
To
associatedtype Stride : SignedNumber

Declaration
From
func swap<T>(inout _ a: T, inout _ b: T)
To
func swap<T>(_ a: inout T, _ b: inout T)

Declaration
From
func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: () throws -> Result) rethrows -> Result
To
func withExtendedLifetime<T, Result>(_ x: T, _ body: () throws -> Result) rethrows -> Result

Declaration
From
func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: T throws -> Result) rethrows -> Result
To
func withExtendedLifetime<T, Result>(_ x: T, _ body: (T) throws -> Result) rethrows -> Result

Declaration
From
typealias Stream1 = Sequence1.Generator
To
typealias Stream1 = Sequence1.Iterator

Declaration
From
typealias Stream2 = Sequence2.Generator
To
typealias Stream2 = Sequence2.Iterator

Modified |=(_: UInt, _: UInt)
Declaration
From
func |=(inout _ lhs: UInt, _ rhs: UInt)
To
func |=(_ lhs: inout UInt, _ rhs: UInt)

Modified |=(_: UInt16, _: UInt16)
Declaration
From
func |=(inout _ lhs: UInt16, _ rhs: UInt16)
To
func |=(_ lhs: inout UInt16, _ rhs: UInt16)

Modified |=(_: Int, _: Int)
Declaration
From
func |=(inout _ lhs: Int, _ rhs: Int)
To
func |=(_ lhs: inout Int, _ rhs: Int)

Modified |=(_: UInt8, _: UInt8)
Declaration
From
func |=(inout _ lhs: UInt8, _ rhs: UInt8)
To
func |=(_ lhs: inout UInt8, _ rhs: UInt8)

Modified |=(_: UInt32, _: UInt32)
Declaration
From
func |=(inout _ lhs: UInt32, _ rhs: UInt32)
To
func |=(_ lhs: inout UInt32, _ rhs: UInt32)

Modified |=(_: Int8, _: Int8)
Declaration
From
func |=(inout _ lhs: Int8, _ rhs: Int8)
To
func |=(_ lhs: inout Int8, _ rhs: Int8)

Modified |=(_: Int32, _: Int32)
Declaration
From
func |=(inout _ lhs: Int32, _ rhs: Int32)
To
func |=(_ lhs: inout Int32, _ rhs: Int32)

Modified |=(_: Int16, _: Int16)
Declaration
From
func |=(inout _ lhs: Int16, _ rhs: Int16)
To
func |=(_ lhs: inout Int16, _ rhs: Int16)

Modified |=(_: UInt64, _: UInt64)
Declaration
From
func |=(inout _ lhs: UInt64, _ rhs: UInt64)
To
func |=(_ lhs: inout UInt64, _ rhs: UInt64)

Modified |=(_: Int64, _: Int64)
Declaration
From
func |=(inout _ lhs: Int64, _ rhs: Int64)
To
func |=(_ lhs: inout Int64, _ rhs: Int64)

Modified ~=(_: _OptionalNilComparisonType, _: T?) -> Bool
Declaration
From
@warn_unused_result
func ~=<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool
To
func ~=<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool

Declaration
From
@warn_unused_result
func ~=<T : Equatable>(_ a: T, _ b: T) -> Bool
To
func ~=<T : Equatable>(_ a: T, _ b: T) -> Bool