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.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<T : BooleanType>(_: T)

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 CollectionOfOne.subscript(_: Index) -> Element

Removed CollectionType

Removed CollectionType.count

Removed CollectionType.dropFirst(_: 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.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.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.prefix(_: Int) -> Self.SubSequence

Removed CollectionType.prefixThrough(_: 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.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.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.popFirst() -> (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 DictionaryLiteral.subscript(_: Int) -> (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, limit: Self) -> Self

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(_: (Wrapped) throws -> U!) rethrows -> U!

Removed ImplicitlyUnwrappedOptional.init()

Removed ImplicitlyUnwrappedOptional.init(_: Wrapped?)

Removed ImplicitlyUnwrappedOptional.map(_: (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) -> 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(_: (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.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(_: (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.withUnsafeMutablePointers<R>(_: (UnsafeMutablePointer<Value>, UnsafeMutablePointer<Element>) -> R) -> R

Removed ManagedBufferPointer.withUnsafeMutablePointerToElements<R>(_: (UnsafeMutablePointer<Element>) -> R) -> R

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.descendant(_: MirrorPathType, _: MirrorPathType) -> Any?

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.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.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.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.removeAtIndex(_: Self.Index) -> Self.Generator.Element

Removed RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element

Removed RangeReplaceableCollectionType.removeFirst(_: Int)

Removed RangeReplaceableCollectionType.removeLast() -> Self.Generator.Element

Removed RangeReplaceableCollectionType.removeLast(_: Int)

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 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.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.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.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 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.insert(_: Element)

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, 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(arrayLiteral: Self.Element)

Removed SetAlgebraType.insert(_: Self.Element)

Removed SetAlgebraType.intersect(_: Self) -> Self

Removed SetAlgebraType.intersectInPlace(_: Self)

Removed SetAlgebraType.isDisjointWith(_: Self) -> Bool

Removed SetAlgebraType.isEmpty

Removed SetAlgebraType.isStrictSubsetOf(_: Self) -> Bool

Removed SetAlgebraType.isStrictSupersetOf(_: Self) -> Bool

Removed SetAlgebraType.isSubsetOf(_: Self) -> Bool

Removed SetAlgebraType.isSupersetOf(_: Self) -> Bool

Removed SetAlgebraType.remove(_: Self.Element) -> Self.Element?

Removed SetAlgebraType.subtract(_: Self) -> 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.fromOpaque(_: COpaquePointer) -> Unmanaged<Instance> [static]

Removed Unmanaged.toOpaque() -> COpaquePointer

Removed UnsafeBufferPointer.generate() -> UnsafeBufferPointerGenerator<Element>

Removed UnsafeBufferPointer.init(start: UnsafePointer<Element>, count: Int)

Removed UnsafeBufferPointerGenerator [struct]

Removed UnsafeBufferPointerGenerator.next() -> Element?

Removed UnsafeMutableBufferPointer.generate() -> UnsafeBufferPointerGenerator<Element>

Removed UnsafeMutableBufferPointer.init(start: UnsafeMutablePointer<Element>, count: Int)

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(_: COpaquePointer)

Removed UnsafeMutablePointer.init(_: UnsafePointer)

Removed UnsafeMutablePointer.init(_: UnsafeMutablePointer)

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(_: UnsafeMutablePointer)

Removed UnsafePointer.init(_: UnsafePointer)

Removed UnsafePointer.init(_: COpaquePointer)

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 !=(_: Float, _: Float) -> Bool

Removed !=(_: T, _: T) -> Bool

Removed !=(_: [Key : Value], _: [Key : Value]) -> Bool

Removed !=(_: Any.Type?, _: Any.Type?) -> 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 ++(_: 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 ..<(_: 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 ==(_: Any.Type?, _: Any.Type?) -> 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 fatalError(_: () -> String, file: StaticString, line: UInt)

Removed FloatLiteralConvertible.FloatLiteralType

Removed ForwardIndexType.Distance

Removed GeneratorType.Element

Removed getVaList(_: [CVarArgType]) -> CVaListPointer

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 preconditionFailure(_: () -> String, file: StaticString, line: UInt)

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 zip<Sequence1 : SequenceType, Sequence2 : SequenceType>(_: Sequence1, _: Sequence2) -> Zip2Sequence<Sequence1, Sequence2>

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) -> Bool

Added AnyBidirectionalCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added AnyBidirectionalCollection.count

Added AnyBidirectionalCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax

Added AnyBidirectionalCollection.dropFirst() -> AnyBidirectionalCollection<Element>

Added AnyBidirectionalCollection.dropFirst(_: Int) -> AnyBidirectionalCollection<Element>

Added AnyBidirectionalCollection.dropLast() -> AnyBidirectionalCollection<Element>

Added AnyBidirectionalCollection.dropLast(_: Int) -> AnyBidirectionalCollection<Element>

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.enumerated() -> EnumeratedSequence<AnyBidirectionalCollection<Element>>

Added AnyBidirectionalCollection.filter(_: (Element) throws -> Bool) rethrows -> [Element]

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.forEach(_: (Element) throws -> Swift.Void) rethrows

Added AnyBidirectionalCollection.formIndex(_: AnyIndex, offsetBy: IntMax)

Added AnyBidirectionalCollection.formIndex(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> Bool

Added AnyBidirectionalCollection.formIndex(after: AnyIndex)

Added AnyBidirectionalCollection.formIndex(before: AnyIndex)

Added AnyBidirectionalCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex

Added AnyBidirectionalCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?

Added AnyBidirectionalCollection.index(after: AnyIndex) -> AnyIndex

Added AnyBidirectionalCollection.index(before: 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.init(_: AnyCollection<Element>)

Added AnyBidirectionalCollection.isEmpty

Added AnyBidirectionalCollection.joined() -> FlattenCollection<AnyBidirectionalCollection<Element>>

Added AnyBidirectionalCollection.joined() -> FlattenSequence<AnyBidirectionalCollection<Element>>

Added AnyBidirectionalCollection.joined() -> FlattenBidirectionalCollection<AnyBidirectionalCollection<Element>>

Added AnyBidirectionalCollection.joined(separator: String) -> String

Added AnyBidirectionalCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<AnyBidirectionalCollection<Element>>

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.makeIterator() -> AnyIterator<Element>

Added AnyBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added AnyBidirectionalCollection.max() -> Element?

Added AnyBidirectionalCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added AnyBidirectionalCollection.min() -> Element?

Added AnyBidirectionalCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added AnyBidirectionalCollection.popFirst() -> Element?

Added AnyBidirectionalCollection.popLast() -> Element?

Added AnyBidirectionalCollection.prefix(_: Int) -> AnyBidirectionalCollection<Element>

Added AnyBidirectionalCollection.prefix(through: AnyIndex) -> AnyBidirectionalCollection<Element>

Added AnyBidirectionalCollection.prefix(upTo: AnyIndex) -> AnyBidirectionalCollection<Element>

Added AnyBidirectionalCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added AnyBidirectionalCollection.removeFirst() -> Element

Added AnyBidirectionalCollection.removeFirst(_: Int)

Added AnyBidirectionalCollection.removeLast() -> Element

Added AnyBidirectionalCollection.removeLast(_: Int)

Added AnyBidirectionalCollection.reversed() -> ReversedCollection<AnyBidirectionalCollection<Element>>

Added AnyBidirectionalCollection.sorted() -> [Element]

Added AnyBidirectionalCollection.sorted(by: (Element, Element) -> Bool) -> [Element]

Added AnyBidirectionalCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnyBidirectionalCollection<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(_: AnyIndex) -> Element

Added AnyBidirectionalCollection.subscript(_: ClosedRange<AnyIndex>) -> AnyBidirectionalCollection<Element>

Added AnyBidirectionalCollection.subscript(_: Range<AnyIndex>) -> AnyBidirectionalCollection<Element>

Added AnyBidirectionalCollection.suffix(_: Int) -> AnyBidirectionalCollection<Element>

Added AnyBidirectionalCollection.suffix(from: AnyIndex) -> AnyBidirectionalCollection<Element>

Added AnyBidirectionalCollection.underestimatedCount

Added AnyCollection [struct]

Added AnyCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added AnyCollection.count

Added AnyCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax

Added AnyCollection.dropFirst() -> AnyCollection<Element>

Added AnyCollection.dropFirst(_: Int) -> AnyCollection<Element>

Added AnyCollection.dropLast() -> AnyCollection<Element>

Added AnyCollection.dropLast(_: Int) -> AnyCollection<Element>

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.endIndex

Added AnyCollection.enumerated() -> EnumeratedSequence<AnyCollection<Element>>

Added AnyCollection.filter(_: (Element) throws -> Bool) rethrows -> [Element]

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.formIndex(after: AnyIndex)

Added AnyCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex

Added AnyCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?

Added AnyCollection.index(after: AnyIndex) -> AnyIndex

Added AnyCollection.index(of: Element) -> AnyIndex?

Added AnyCollection.index(where: (Element) throws -> Bool) rethrows -> AnyIndex?

Added AnyCollection.indices

Added AnyCollection.init(_: AnyRandomAccessCollection<Element>)

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(_: AnyBidirectionalCollection<Element>)

Added AnyCollection.init(_: AnyCollection<Element>)

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.isEmpty

Added AnyCollection.joined() -> FlattenSequence<AnyCollection<Element>>

Added AnyCollection.joined() -> FlattenCollection<AnyCollection<Element>>

Added AnyCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<AnyCollection<Element>>

Added AnyCollection.joined(separator: String) -> String

Added AnyCollection.lazy

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.makeIterator() -> AnyIterator<Element>

Added AnyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added AnyCollection.max() -> Element?

Added AnyCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added AnyCollection.min() -> Element?

Added AnyCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added AnyCollection.popFirst() -> Element?

Added AnyCollection.prefix(_: Int) -> AnyCollection<Element>

Added AnyCollection.prefix(through: AnyIndex) -> AnyCollection<Element>

Added AnyCollection.prefix(upTo: AnyIndex) -> AnyCollection<Element>

Added AnyCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added AnyCollection.removeFirst() -> Element

Added AnyCollection.removeFirst(_: Int)

Added AnyCollection.reversed() -> [Element]

Added AnyCollection.sorted() -> [Element]

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.startIndex

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(_: Range<AnyIndex>) -> AnyCollection<Element>

Added AnyCollection.subscript(_: ClosedRange<AnyIndex>) -> AnyCollection<Element>

Added AnyCollection.subscript(_: AnyIndex) -> Element

Added AnyCollection.suffix(_: Int) -> AnyCollection<Element>

Added AnyCollection.suffix(from: AnyIndex) -> AnyCollection<Element>

Added AnyCollection.underestimatedCount

Added AnyHashable [struct]

Added AnyHashable.base

Added AnyHashable.customMirror

Added AnyHashable.debugDescription

Added AnyHashable.description

Added AnyHashable.hashValue

Added AnyHashable.init<H : Hashable>(_: H)

Added AnyIndex [struct]

Added AnyIndex.init<BaseIndex : Comparable>(_: BaseIndex)

Added AnyIterator [struct]

Added AnyIterator.init(_: I)

Added AnyIterator.init(_: () -> Element?)

Added AnyIterator.next() -> Element?

Added AnyRandomAccessCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added AnyRandomAccessCollection.count

Added AnyRandomAccessCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax

Added AnyRandomAccessCollection.dropFirst() -> AnyRandomAccessCollection<Element>

Added AnyRandomAccessCollection.dropFirst(_: Int) -> AnyRandomAccessCollection<Element>

Added AnyRandomAccessCollection.dropLast() -> AnyRandomAccessCollection<Element>

Added AnyRandomAccessCollection.dropLast(_: Int) -> AnyRandomAccessCollection<Element>

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.enumerated() -> EnumeratedSequence<AnyRandomAccessCollection<Element>>

Added AnyRandomAccessCollection.filter(_: (Element) throws -> Bool) rethrows -> [Element]

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.forEach(_: (Element) throws -> Swift.Void) rethrows

Added AnyRandomAccessCollection.formIndex(_: AnyIndex, offsetBy: IntMax)

Added AnyRandomAccessCollection.formIndex(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> Bool

Added AnyRandomAccessCollection.formIndex(after: AnyIndex)

Added AnyRandomAccessCollection.formIndex(before: AnyIndex)

Added AnyRandomAccessCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex

Added AnyRandomAccessCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?

Added AnyRandomAccessCollection.index(after: AnyIndex) -> AnyIndex

Added AnyRandomAccessCollection.index(before: 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.init(_: AnyCollection<Element>)

Added AnyRandomAccessCollection.isEmpty

Added AnyRandomAccessCollection.joined() -> FlattenSequence<AnyRandomAccessCollection<Element>>

Added AnyRandomAccessCollection.joined() -> FlattenCollection<AnyRandomAccessCollection<Element>>

Added AnyRandomAccessCollection.joined() -> FlattenBidirectionalCollection<AnyRandomAccessCollection<Element>>

Added AnyRandomAccessCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<AnyRandomAccessCollection<Element>>

Added AnyRandomAccessCollection.joined(separator: String) -> String

Added AnyRandomAccessCollection.last

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.makeIterator() -> AnyIterator<Element>

Added AnyRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added AnyRandomAccessCollection.max() -> Element?

Added AnyRandomAccessCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added AnyRandomAccessCollection.min() -> Element?

Added AnyRandomAccessCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added AnyRandomAccessCollection.popFirst() -> Element?

Added AnyRandomAccessCollection.popLast() -> Element?

Added AnyRandomAccessCollection.prefix(_: Int) -> AnyRandomAccessCollection<Element>

Added AnyRandomAccessCollection.prefix(through: AnyIndex) -> AnyRandomAccessCollection<Element>

Added AnyRandomAccessCollection.prefix(upTo: AnyIndex) -> AnyRandomAccessCollection<Element>

Added AnyRandomAccessCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added AnyRandomAccessCollection.removeFirst() -> Element

Added AnyRandomAccessCollection.removeFirst(_: Int)

Added AnyRandomAccessCollection.removeLast() -> Element

Added AnyRandomAccessCollection.removeLast(_: Int)

Added AnyRandomAccessCollection.reversed() -> ReversedRandomAccessCollection<AnyRandomAccessCollection<Element>>

Added AnyRandomAccessCollection.sorted() -> [Element]

Added AnyRandomAccessCollection.sorted(by: (Element, Element) -> Bool) -> [Element]

Added AnyRandomAccessCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnyRandomAccessCollection<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(_: Range<AnyIndex>) -> AnyRandomAccessCollection<Element>

Added AnyRandomAccessCollection.subscript(_: ClosedRange<AnyIndex>) -> AnyRandomAccessCollection<Element>

Added AnyRandomAccessCollection.subscript(_: AnyIndex) -> Element

Added AnyRandomAccessCollection.suffix(_: Int) -> AnyRandomAccessCollection<Element>

Added AnyRandomAccessCollection.suffix(from: AnyIndex) -> AnyRandomAccessCollection<Element>

Added AnyRandomAccessCollection.underestimatedCount

Added AnySequence.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added AnySequence.dropFirst() -> AnySequence<Element>

Added AnySequence.dropLast() -> AnySequence<Element>

Added AnySequence.dropLast(_: Int) -> AnySequence<Element>

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.enumerated() -> EnumeratedSequence<AnySequence<Element>>

Added AnySequence.filter(_: (Element) throws -> Bool) rethrows -> [Element]

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.forEach(_: (Element) throws -> Swift.Void) rethrows

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)

Added AnySequence.joined() -> FlattenSequence<AnySequence<Element>>

Added AnySequence.joined(separator: String) -> String

Added AnySequence.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<AnySequence<Element>>

Added AnySequence.lazy

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.makeIterator() -> AnyIterator<Element>

Added AnySequence.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added AnySequence.max() -> Element?

Added AnySequence.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added AnySequence.min() -> Element?

Added AnySequence.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added AnySequence.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added AnySequence.reversed() -> [Element]

Added AnySequence.sorted() -> [Element]

Added AnySequence.sorted(by: (Element, Element) -> Bool) -> [Element]

Added AnySequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<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.suffix(_: Int) -> AnySequence<Element>

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.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added Array.count

Added Array.customMirror

Added Array.distance(from: Int, to: Int) -> Int

Added Array.dropFirst() -> ArraySlice<Element>

Added Array.dropFirst(_: Int) -> ArraySlice<Element>

Added Array.dropLast() -> ArraySlice<Element>

Added Array.dropLast(_: Int) -> ArraySlice<Element>

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.enumerated() -> EnumeratedSequence<Array<Element>>

Added Array.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added Array.first

Added Array.first(where: (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.forEach(_: (Element) throws -> Void) rethrows

Added Array.formIndex(_: Int, offsetBy: Int)

Added Array.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool

Added Array.formIndex(after: Int)

Added Array.formIndex(before: Int)

Added Array.index(_: Int, offsetBy: Int) -> Int

Added Array.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?

Added Array.index(after: Int) -> Int

Added Array.index(before: Int) -> Int

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.init(repeating: Element, count: Int)

Added Array.insert(_: Element, at: Int)

Added Array.isEmpty

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.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<Array<Element>>

Added Array.last

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.makeIterator() -> IndexingIterator<Array<Element>>

Added Array.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added Array.max() -> Element?

Added Array.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added Array.min() -> Element?

Added Array.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added Array.partition(by: (Element) throws -> Bool) rethrows -> Int

Added Array.prefix(_: Int) -> ArraySlice<Element>

Added Array.prefix(through: Int) -> ArraySlice<Element>

Added Array.prefix(upTo: Int) -> ArraySlice<Element>

Added Array.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added Array.remove(at: Int) -> Element

Added Array.removeAll(keepingCapacity: Bool)

Added Array.replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_: Range<Int>, with: C)

Added Array.reversed() -> ReversedRandomAccessCollection<Array<Element>>

Added Array.sort()

Added Array.sort(by: (Element, Element) -> Bool)

Added Array.sorted() -> [Element]

Added Array.sorted(by: (Element, Element) -> Bool) -> [Element]

Added Array.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<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(_: CountableClosedRange<Int>) -> ArraySlice<Element>

Added Array.suffix(_: Int) -> ArraySlice<Element>

Added Array.suffix(from: Int) -> ArraySlice<Element>

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.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added ArraySlice.count

Added ArraySlice.customMirror

Added ArraySlice.distance(from: Int, to: Int) -> Int

Added ArraySlice.dropFirst() -> ArraySlice<Element>

Added ArraySlice.dropFirst(_: Int) -> ArraySlice<Element>

Added ArraySlice.dropLast() -> ArraySlice<Element>

Added ArraySlice.dropLast(_: Int) -> ArraySlice<Element>

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.enumerated() -> EnumeratedSequence<ArraySlice<Element>>

Added ArraySlice.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added ArraySlice.first

Added ArraySlice.first(where: (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.forEach(_: (Element) throws -> Void) rethrows

Added ArraySlice.formIndex(_: Int, offsetBy: Int)

Added ArraySlice.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool

Added ArraySlice.formIndex(after: Int)

Added ArraySlice.formIndex(before: Int)

Added ArraySlice.index(_: Int, offsetBy: Int) -> Int

Added ArraySlice.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?

Added ArraySlice.index(after: Int) -> Int

Added ArraySlice.index(before: Int) -> Int

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.init(repeating: Element, count: Int)

Added ArraySlice.insert(_: Element, at: Int)

Added ArraySlice.isEmpty

Added ArraySlice.joined() -> FlattenSequence<ArraySlice<Element>>

Added ArraySlice.joined() -> FlattenCollection<ArraySlice<Element>>

Added ArraySlice.joined() -> FlattenBidirectionalCollection<ArraySlice<Element>>

Added ArraySlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<ArraySlice<Element>>

Added ArraySlice.joined(separator: String) -> String

Added ArraySlice.last

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.makeIterator() -> IndexingIterator<ArraySlice<Element>>

Added ArraySlice.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added ArraySlice.max() -> Element?

Added ArraySlice.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added ArraySlice.min() -> Element?

Added ArraySlice.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added ArraySlice.partition(by: (Element) throws -> Bool) rethrows -> Int

Added ArraySlice.popFirst() -> Element?

Added ArraySlice.popLast() -> Element?

Added ArraySlice.prefix(_: Int) -> ArraySlice<Element>

Added ArraySlice.prefix(through: Int) -> ArraySlice<Element>

Added ArraySlice.prefix(upTo: Int) -> ArraySlice<Element>

Added ArraySlice.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added ArraySlice.remove(at: Int) -> Element

Added ArraySlice.removeAll(keepingCapacity: Bool)

Added ArraySlice.removeFirst() -> Element

Added ArraySlice.removeFirst(_: Int)

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.reversed() -> ReversedRandomAccessCollection<ArraySlice<Element>>

Added ArraySlice.sort()

Added ArraySlice.sort(by: (Element, Element) -> Bool)

Added ArraySlice.sorted() -> [Element]

Added ArraySlice.sorted(by: (Element, Element) -> Bool) -> [Element]

Added ArraySlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<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(_: 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.suffix(_: Int) -> ArraySlice<Element>

Added ArraySlice.suffix(from: Int) -> ArraySlice<Element>

Added ArraySlice.underestimatedCount

Added AutoreleasingUnsafeMutablePointer.init(_: UnsafeMutablePointer?)

Added AutoreleasingUnsafeMutablePointer.pointee

Added BidirectionalCollection

Added BidirectionalCollection.dropLast(_: Int) -> Self.SubSequence

Added BidirectionalCollection.formIndex(before: Self.Index)

Added BidirectionalCollection.index(before: Self.Index) -> Self.Index

Added BidirectionalCollection.indices

Added BidirectionalCollection.joined() -> FlattenBidirectionalCollection<Self>

Added BidirectionalCollection.last

Added BidirectionalCollection.lazy

Added BidirectionalCollection.popLast() -> Self.Iterator.Element?

Added BidirectionalCollection.removeLast() -> Self.Iterator.Element

Added BidirectionalCollection.removeLast(_: Int)

Added BidirectionalCollection.reversed() -> ReversedCollection<Self>

Added BidirectionalCollection.subscript(_: Range<Self.Index>) -> BidirectionalSlice<Self>

Added BidirectionalCollection.suffix(_: Int) -> Self.SubSequence

Added BidirectionalIndexable

Added BidirectionalIndexable.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance

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.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.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 BinaryFloatingPoint

Added BinaryFloatingPoint.binade

Added BinaryFloatingPoint.exponentBitCount

Added BinaryFloatingPoint.exponentBitPattern

Added BinaryFloatingPoint.init(_: Float)

Added BinaryFloatingPoint.init(_: Double)

Added BinaryFloatingPoint.init(sign: FloatingPointSign, exponentBitPattern: Self.RawExponent, significandBitPattern: Self.RawSignificand)

Added BinaryFloatingPoint.init(signOf: Self, magnitudeOf: Self)

Added BinaryFloatingPoint.isTotallyOrdered(belowOrEqualTo: Self) -> Bool

Added BinaryFloatingPoint.radix

Added BinaryFloatingPoint.significandBitCount

Added BinaryFloatingPoint.significandBitPattern

Added BinaryFloatingPoint.significandWidth

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 Bool.customMirror

Added Bool.customPlaygroundQuickLook

Added Bool.init(_: Bool)

Added Bool.init(_: String)

Added Character.customMirror

Added Character.customPlaygroundQuickLook

Added Character.description

Added Character.write<Target : TextOutputStream>(to: Target)

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.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.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._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.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.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 ClosedRange [struct]

Added ClosedRange.clamped(to: ClosedRange<Bound>) -> ClosedRange<Bound>

Added ClosedRange.contains(_: Bound) -> Bool

Added ClosedRange.customMirror

Added ClosedRange.debugDescription

Added ClosedRange.description

Added ClosedRange.init(uncheckedBounds: (lower: Bound, upper: Bound))

Added ClosedRange.isEmpty

Added ClosedRange.lowerBound

Added ClosedRange.overlaps(_: ClosedRange<Bound>) -> Bool

Added ClosedRange.overlaps(_: Range<Bound>) -> Bool

Added ClosedRange.upperBound

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

Added Collection.count

Added Collection.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance

Added Collection.dropFirst(_: Int) -> Self.SubSequence

Added Collection.dropLast(_: Int) -> Self.SubSequence

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.indices

Added Collection.isEmpty

Added Collection.joined() -> FlattenCollection<Self>

Added Collection.lazy

Added Collection.makeIterator() -> IndexingIterator<Self>

Added Collection.makeIterator() -> Self.Iterator

Added Collection.map<T>(_: (Self.Iterator.Element) throws -> T) rethrows -> [T]

Added Collection.popFirst() -> Self.Iterator.Element?

Added Collection.prefix(_: Int) -> Self.SubSequence

Added Collection.prefix(through: Self.Index) -> Self.SubSequence

Added Collection.prefix(upTo: Self.Index) -> Self.SubSequence

Added Collection.removeFirst() -> Self.Iterator.Element

Added Collection.removeFirst(_: Int)

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(_: Self.Index) -> Self.Iterator.Element

Added Collection.subscript(_: Range<Self.Index>) -> Slice<Self>

Added Collection.subscript(_: Range<Self.Index>) -> Self.SubSequence

Added Collection.suffix(_: Int) -> Self.SubSequence

Added Collection.suffix(from: Self.Index) -> Self.SubSequence

Added Collection.underestimatedCount

Added CollectionOfOne.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added CollectionOfOne.count

Added CollectionOfOne.customMirror

Added CollectionOfOne.debugDescription

Added CollectionOfOne.distance(from: Int, to: Int) -> Int

Added CollectionOfOne.dropFirst() -> MutableRandomAccessSlice<CollectionOfOne<Element>>

Added CollectionOfOne.dropFirst(_: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>

Added CollectionOfOne.dropLast() -> MutableRandomAccessSlice<CollectionOfOne<Element>>

Added CollectionOfOne.dropLast(_: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>

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.enumerated() -> EnumeratedSequence<CollectionOfOne<Element>>

Added CollectionOfOne.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added CollectionOfOne.first

Added CollectionOfOne.first(where: (Element) throws -> Bool) rethrows -> Element?

Added CollectionOfOne.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]

Added CollectionOfOne.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Added CollectionOfOne.forEach(_: (Element) throws -> Void) rethrows

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(after: Int) -> Int

Added CollectionOfOne.index(before: Int) -> Int

Added CollectionOfOne.index(of: Element) -> Int?

Added CollectionOfOne.index(where: (Element) throws -> Bool) rethrows -> Int?

Added CollectionOfOne.indices

Added CollectionOfOne.isEmpty

Added CollectionOfOne.joined() -> FlattenCollection<CollectionOfOne<Element>>

Added CollectionOfOne.joined() -> FlattenBidirectionalCollection<CollectionOfOne<Element>>

Added CollectionOfOne.joined() -> FlattenSequence<CollectionOfOne<Element>>

Added CollectionOfOne.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<CollectionOfOne<Element>>

Added CollectionOfOne.joined(separator: String) -> String

Added CollectionOfOne.last

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.makeIterator() -> IteratorOverOne<Element>

Added CollectionOfOne.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added CollectionOfOne.max() -> Element?

Added CollectionOfOne.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added CollectionOfOne.min() -> Element?

Added CollectionOfOne.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added CollectionOfOne.partition(by: (Element) throws -> Bool) rethrows -> Int

Added CollectionOfOne.prefix(_: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>

Added CollectionOfOne.prefix(through: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>

Added CollectionOfOne.prefix(upTo: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>

Added CollectionOfOne.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added CollectionOfOne.reversed() -> ReversedRandomAccessCollection<CollectionOfOne<Element>>

Added CollectionOfOne.sort()

Added CollectionOfOne.sort(by: (Element, Element) -> Bool)

Added CollectionOfOne.sorted() -> [Element]

Added CollectionOfOne.sorted(by: (Element, Element) -> Bool) -> [Element]

Added CollectionOfOne.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<CollectionOfOne<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(_: Int) -> Element

Added CollectionOfOne.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>

Added CollectionOfOne.suffix(_: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>

Added CollectionOfOne.suffix(from: Int) -> MutableRandomAccessSlice<CollectionOfOne<Element>>

Added CollectionOfOne.underestimatedCount

Added CommandLine [enum]

Added CommandLine.argc

Added CommandLine.arguments

Added CommandLine.unsafeArgv

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.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added ContiguousArray.count

Added ContiguousArray.customMirror

Added ContiguousArray.distance(from: Int, to: Int) -> Int

Added ContiguousArray.dropFirst() -> ArraySlice<Element>

Added ContiguousArray.dropFirst(_: Int) -> ArraySlice<Element>

Added ContiguousArray.dropLast() -> ArraySlice<Element>

Added ContiguousArray.dropLast(_: Int) -> ArraySlice<Element>

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.enumerated() -> EnumeratedSequence<ContiguousArray<Element>>

Added ContiguousArray.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added ContiguousArray.first

Added ContiguousArray.first(where: (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.forEach(_: (Element) throws -> Void) rethrows

Added ContiguousArray.formIndex(_: Int, offsetBy: Int)

Added ContiguousArray.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool

Added ContiguousArray.formIndex(after: Int)

Added ContiguousArray.formIndex(before: Int)

Added ContiguousArray.index(_: Int, offsetBy: Int) -> Int

Added ContiguousArray.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?

Added ContiguousArray.index(after: Int) -> Int

Added ContiguousArray.index(before: Int) -> Int

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.insert(_: Element, at: Int)

Added ContiguousArray.isEmpty

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.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<ContiguousArray<Element>>

Added ContiguousArray.last

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.makeIterator() -> IndexingIterator<ContiguousArray<Element>>

Added ContiguousArray.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added ContiguousArray.max() -> Element?

Added ContiguousArray.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added ContiguousArray.min() -> Element?

Added ContiguousArray.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added ContiguousArray.partition(by: (Element) throws -> Bool) rethrows -> Int

Added ContiguousArray.prefix(_: Int) -> ArraySlice<Element>

Added ContiguousArray.prefix(through: Int) -> ArraySlice<Element>

Added ContiguousArray.prefix(upTo: Int) -> ArraySlice<Element>

Added ContiguousArray.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

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.reversed() -> ReversedRandomAccessCollection<ContiguousArray<Element>>

Added ContiguousArray.sort()

Added ContiguousArray.sort(by: (Element, Element) -> Bool)

Added ContiguousArray.sorted() -> [Element]

Added ContiguousArray.sorted(by: (Element, Element) -> Bool) -> [Element]

Added ContiguousArray.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [ArraySlice<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(_: CountableClosedRange<Int>) -> ArraySlice<Element>

Added ContiguousArray.suffix(_: Int) -> ArraySlice<Element>

Added ContiguousArray.suffix(from: Int) -> ArraySlice<Element>

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.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.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.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.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(_: ClosedRangeIndex<Bound>) -> Bound

Added CountableClosedRange.suffix(_: Int) -> RandomAccessSlice<CountableClosedRange<Bound>>

Added CountableClosedRange.suffix(from: ClosedRangeIndex<Bound>) -> RandomAccessSlice<CountableClosedRange<Bound>>

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.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.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.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.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.upperBound

Added CustomPlaygroundQuickLookable.customPlaygroundQuickLook

Added CustomReflectable.customMirror

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.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.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.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 DefaultIndices [struct]

Added DefaultIndices.contains(_: Elements.Index) -> Bool

Added DefaultIndices.contains(where: (Elements.Index) throws -> Bool) rethrows -> Bool

Added DefaultIndices.count

Added DefaultIndices.distance(from: Elements.Index, to: Elements.Index) -> Int

Added DefaultIndices.dropFirst() -> DefaultIndices<Elements>

Added DefaultIndices.dropFirst(_: Int) -> DefaultIndices<Elements>

Added DefaultIndices.dropLast() -> DefaultIndices<Elements>

Added DefaultIndices.dropLast(_: Int) -> DefaultIndices<Elements>

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.endIndex

Added DefaultIndices.enumerated() -> EnumeratedSequence<DefaultIndices<Elements>>

Added DefaultIndices.filter(_: (Elements.Index) throws -> Bool) rethrows -> [Elements.Index]

Added DefaultIndices.first

Added DefaultIndices.first(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?

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.forEach(_: (Elements.Index) throws -> Void) rethrows

Added DefaultIndices.formIndex(_: Elements.Index, offsetBy: Int)

Added DefaultIndices.formIndex(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Bool

Added DefaultIndices.formIndex(after: Elements.Index)

Added DefaultIndices.index(_: Elements.Index, offsetBy: Int) -> Elements.Index

Added DefaultIndices.index(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Elements.Index?

Added DefaultIndices.index(after: 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.isEmpty

Added DefaultIndices.joined() -> FlattenCollection<DefaultIndices<Elements>>

Added DefaultIndices.joined() -> FlattenSequence<DefaultIndices<Elements>>

Added DefaultIndices.joined(separator: String) -> String

Added DefaultIndices.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<DefaultIndices<Elements>>

Added DefaultIndices.lazy

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.makeIterator() -> IndexingIterator<DefaultIndices<Elements>>

Added DefaultIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]

Added DefaultIndices.max() -> Elements.Index?

Added DefaultIndices.max(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?

Added DefaultIndices.min() -> Elements.Index?

Added DefaultIndices.min(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?

Added DefaultIndices.popFirst() -> Elements.Index?

Added DefaultIndices.prefix(_: Int) -> DefaultIndices<Elements>

Added DefaultIndices.prefix(through: Elements.Index) -> DefaultIndices<Elements>

Added DefaultIndices.prefix(upTo: Elements.Index) -> DefaultIndices<Elements>

Added DefaultIndices.reduce<Result>(_: Result, _: (Result, Elements.Index) throws -> Result) rethrows -> Result

Added DefaultIndices.removeFirst() -> Elements.Index

Added DefaultIndices.removeFirst(_: Int)

Added DefaultIndices.reversed() -> [Elements.Index]

Added DefaultIndices.sorted() -> [Elements.Index]

Added DefaultIndices.sorted(by: (Elements.Index, Elements.Index) -> Bool) -> [Elements.Index]

Added DefaultIndices.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Elements.Index) throws -> Bool) rethrows -> [DefaultIndices<Elements>]

Added DefaultIndices.split(separator: Elements.Index, maxSplits: Int, omittingEmptySubsequences: Bool) -> [DefaultIndices<Elements>]

Added DefaultIndices.startIndex

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.suffix(_: Int) -> DefaultIndices<Elements>

Added DefaultIndices.suffix(from: Elements.Index) -> DefaultIndices<Elements>

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.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.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.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 Dictionary.contains(where: (Key, Value) throws -> Bool) rethrows -> Bool

Added Dictionary.count

Added Dictionary.customMirror

Added Dictionary.distance(from: DictionaryIndex<Key, Value>, to: DictionaryIndex<Key, Value>) -> Int

Added Dictionary.dropFirst() -> Slice<Dictionary<Key, Value>>

Added Dictionary.dropFirst(_: Int) -> Slice<Dictionary<Key, Value>>

Added Dictionary.dropLast() -> Slice<Dictionary<Key, Value>>

Added Dictionary.dropLast(_: Int) -> Slice<Dictionary<Key, Value>>

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.enumerated() -> EnumeratedSequence<Dictionary<Key, Value>>

Added Dictionary.filter(_: (Key, Value) throws -> Bool) rethrows -> [(key: Key, value: Value)]

Added Dictionary.first

Added Dictionary.first(where: (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.forEach(_: (Key, Value) throws -> Void) rethrows

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(forKey: Key) -> DictionaryIndex<Key, Value>?

Added Dictionary.index(where: (Key, Value) throws -> Bool) rethrows -> DictionaryIndex<Key, Value>?

Added Dictionary.indices

Added Dictionary.isEmpty

Added Dictionary.lazy

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.makeIterator() -> DictionaryIterator<Key, Value>

Added Dictionary.map<T>(_: (Key, Value) throws -> T) rethrows -> [T]

Added Dictionary.max(by: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> (key: Key, value: Value)?

Added Dictionary.min(by: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> (key: Key, value: Value)?

Added Dictionary.popFirst() -> (key: Key, value: Value)?

Added Dictionary.prefix(_: Int) -> Slice<Dictionary<Key, Value>>

Added Dictionary.prefix(through: DictionaryIndex<Key, Value>) -> Slice<Dictionary<Key, Value>>

Added Dictionary.prefix(upTo: DictionaryIndex<Key, Value>) -> Slice<Dictionary<Key, Value>>

Added Dictionary.reduce<Result>(_: Result, _: (Result, (key: Key, value: Value)) throws -> Result) rethrows -> Result

Added Dictionary.remove(at: DictionaryIndex<Key, Value>) -> (key: Key, value: Value)

Added Dictionary.removeAll(keepingCapacity: Bool)

Added Dictionary.removeValue<ConcreteKey : Hashable>(forKey: ConcreteKey) -> Value?

Added Dictionary.removeValue(forKey: Key) -> Value?

Added Dictionary.reversed() -> [(key: Key, value: Value)]

Added Dictionary.sorted(by: ((key: Key, value: Value), (key: Key, value: Value)) -> Bool) -> [(key: Key, value: Value)]

Added Dictionary.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Key, Value) throws -> Bool) rethrows -> [Slice<Dictionary<Key, 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.suffix(_: Int) -> Slice<Dictionary<Key, Value>>

Added Dictionary.suffix(from: DictionaryIndex<Key, Value>) -> Slice<Dictionary<Key, Value>>

Added Dictionary.underestimatedCount

Added Dictionary.updateValue<ConcreteKey : Hashable>(_: Value, forKey: ConcreteKey) -> Value?

Added DictionaryIterator [struct]

Added DictionaryIterator.customMirror

Added DictionaryIterator.next() -> (key: Key, value: Value)?

Added DictionaryLiteral.subscript(_: Int) -> (key: Key, value: Value)

Added Double.add(_: Double)

Added Double.addProduct(_: Double, _: Double)

Added Double.advanced(by: Double) -> Double

Added Double.binade

Added Double.bitPattern

Added Double.customMirror

Added Double.customPlaygroundQuickLook

Added Double.distance(to: Double) -> Double

Added Double.divide(by: Double)

Added Double.exponent

Added Double.exponentBitCount

Added Double.exponentBitPattern

Added Double.formRemainder(dividingBy: Double)

Added Double.formSquareRoot()

Added Double.formTruncatingRemainder(dividingBy: Double)

Added Double.greatestFiniteMagnitude

Added Double.init(bitPattern: UInt64)

Added Double.init(exactly: Double)

Added Double.init(exactly: Float)

Added Double.init(nan: Double.RawSignificand, signaling: Bool)

Added Double.init(sign: FloatingPointSign, exponent: Int, significand: Double)

Added Double.init(sign: FloatingPointSign, exponentBitPattern: UInt, significandBitPattern: UInt64)

Added Double.isCanonical

Added Double.isEqual(to: Double) -> Bool

Added Double.isLess(than: Double) -> Bool

Added Double.isLessThanOrEqualTo(_: Double) -> Bool

Added Double.isSignalingNaN

Added Double.leastNonzeroMagnitude

Added Double.leastNormalMagnitude

Added Double.multiply(by: Double)

Added Double.nan

Added Double.negate()

Added Double.nextUp

Added Double.pi

Added Double.round(_: FloatingPointRoundingRule)

Added Double.sign

Added Double.signalingNaN

Added Double.significand

Added Double.significandBitCount

Added Double.significandBitPattern

Added Double.significandWidth

Added Double.subtract(_: Double)

Added Double.ulp

Added EmptyCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added EmptyCollection.count

Added EmptyCollection.distance(from: EmptyCollection.Index, to: EmptyCollection.Index) -> EmptyCollection.IndexDistance

Added EmptyCollection.dropFirst() -> EmptyCollection<Element>

Added EmptyCollection.dropFirst(_: Int) -> EmptyCollection<Element>

Added EmptyCollection.dropLast() -> EmptyCollection<Element>

Added EmptyCollection.dropLast(_: Int) -> EmptyCollection<Element>

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.enumerated() -> EnumeratedSequence<EmptyCollection<Element>>

Added EmptyCollection.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added EmptyCollection.first

Added EmptyCollection.first(where: (Element) throws -> Bool) rethrows -> Element?

Added EmptyCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]

Added EmptyCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Added EmptyCollection.forEach(_: (Element) throws -> Void) rethrows

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(_: EmptyCollection.Index, offsetBy: EmptyCollection.IndexDistance) -> EmptyCollection.Index

Added EmptyCollection.index(_: EmptyCollection.Index, offsetBy: EmptyCollection.IndexDistance, limitedBy: EmptyCollection.Index) -> EmptyCollection.Index?

Added EmptyCollection.index(after: EmptyCollection.Index) -> EmptyCollection.Index

Added EmptyCollection.index(before: EmptyCollection.Index) -> EmptyCollection.Index

Added EmptyCollection.index(of: Element) -> Int?

Added EmptyCollection.index(where: (Element) throws -> Bool) rethrows -> Int?

Added EmptyCollection.indices

Added EmptyCollection.isEmpty

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.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<EmptyCollection<Element>>

Added EmptyCollection.last

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.makeIterator() -> EmptyIterator<Element>

Added EmptyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added EmptyCollection.max() -> Element?

Added EmptyCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added EmptyCollection.min() -> Element?

Added EmptyCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added EmptyCollection.partition(by: (Element) throws -> Bool) rethrows -> Int

Added EmptyCollection.popFirst() -> Element?

Added EmptyCollection.popLast() -> Element?

Added EmptyCollection.prefix(_: Int) -> EmptyCollection<Element>

Added EmptyCollection.prefix(through: Int) -> EmptyCollection<Element>

Added EmptyCollection.prefix(upTo: Int) -> EmptyCollection<Element>

Added EmptyCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added EmptyCollection.removeFirst() -> Element

Added EmptyCollection.removeFirst(_: Int)

Added EmptyCollection.removeLast() -> Element

Added EmptyCollection.removeLast(_: Int)

Added EmptyCollection.reversed() -> ReversedRandomAccessCollection<EmptyCollection<Element>>

Added EmptyCollection.sort()

Added EmptyCollection.sort(by: (Element, Element) -> Bool)

Added EmptyCollection.sorted() -> [Element]

Added EmptyCollection.sorted(by: (Element, Element) -> Bool) -> [Element]

Added EmptyCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [EmptyCollection<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(_: CountableClosedRange<Int>) -> EmptyCollection<Element>

Added EmptyCollection.subscript(_: Range<EmptyCollection.Index>) -> EmptyCollection<Element>

Added EmptyCollection.subscript(_: CountableClosedRange<Int>) -> EmptyCollection<Element>

Added EmptyCollection.subscript(_: ClosedRange<Int>) -> EmptyCollection<Element>

Added EmptyCollection.subscript(_: Range<Int>) -> MutableSlice<EmptyCollection<Element>>

Added EmptyCollection.suffix(_: Int) -> EmptyCollection<Element>

Added EmptyCollection.suffix(from: Int) -> EmptyCollection<Element>

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 [struct]

Added EnumeratedIterator.contains(where: (Int, Base.Element) throws -> Bool) rethrows -> Bool

Added EnumeratedIterator.dropFirst() -> AnySequence<(offset: Int, element: Base.Element)>

Added EnumeratedIterator.dropFirst(_: Int) -> AnySequence<(offset: Int, element: Base.Element)>

Added EnumeratedIterator.dropLast() -> AnySequence<(offset: Int, element: Base.Element)>

Added EnumeratedIterator.dropLast(_: Int) -> AnySequence<(offset: Int, element: Base.Element)>

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.enumerated() -> EnumeratedSequence<EnumeratedIterator<Base>>

Added EnumeratedIterator.filter(_: (Int, Base.Element) throws -> Bool) rethrows -> [(offset: Int, element: Base.Element)]

Added EnumeratedIterator.first(where: (Int, Base.Element) throws -> Bool) rethrows -> (offset: Int, element: Base.Element)?

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.forEach(_: (Int, Base.Element) throws -> Void) rethrows

Added EnumeratedIterator.lazy

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.makeIterator() -> EnumeratedIterator<Base>

Added EnumeratedIterator.map<T>(_: (Int, Base.Element) throws -> T) rethrows -> [T]

Added EnumeratedIterator.max(by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> (offset: Int, element: Base.Element)?

Added EnumeratedIterator.min(by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> (offset: Int, element: Base.Element)?

Added EnumeratedIterator.next() -> (offset: Int, element: Base.Element)?

Added EnumeratedIterator.prefix(_: Int) -> AnySequence<(offset: Int, element: Base.Element)>

Added EnumeratedIterator.reduce<Result>(_: Result, _: (Result, (offset: Int, element: Base.Element)) throws -> Result) rethrows -> Result

Added EnumeratedIterator.reversed() -> [(offset: Int, element: Base.Element)]

Added EnumeratedIterator.sorted(by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) -> Bool) -> [(offset: Int, element: Base.Element)]

Added EnumeratedIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Int, Base.Element) throws -> Bool) rethrows -> [AnySequence<(offset: Int, element: Base.Element)>]

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 EnumeratedIterator.suffix(_: Int) -> AnySequence<(offset: Int, element: Base.Element)>

Added EnumeratedIterator.underestimatedCount

Added EnumeratedSequence [struct]

Added EnumeratedSequence.contains(where: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> Bool

Added EnumeratedSequence.dropFirst() -> AnySequence<(offset: Int, element: Base.Iterator.Element)>

Added EnumeratedSequence.dropFirst(_: Int) -> AnySequence<(offset: Int, element: Base.Iterator.Element)>

Added EnumeratedSequence.dropLast() -> AnySequence<(offset: Int, element: Base.Iterator.Element)>

Added EnumeratedSequence.dropLast(_: Int) -> AnySequence<(offset: Int, element: Base.Iterator.Element)>

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.enumerated() -> EnumeratedSequence<EnumeratedSequence<Base>>

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.lazy

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.makeIterator() -> EnumeratedIterator<Base.Iterator>

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.prefix(_: Int) -> AnySequence<(offset: Int, element: Base.Iterator.Element)>

Added EnumeratedSequence.reduce<Result>(_: Result, _: (Result, (offset: Int, element: Base.Iterator.Element)) throws -> Result) rethrows -> Result

Added EnumeratedSequence.reversed() -> [(offset: Int, element: Base.Iterator.Element)]

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 EnumeratedSequence.suffix(_: Int) -> AnySequence<(offset: Int, element: Base.Iterator.Element)>

Added EnumeratedSequence.underestimatedCount

Added Error

Added ExpressibleByArrayLiteral

Added ExpressibleByArrayLiteral.init(arrayLiteral: Self.Element)

Added ExpressibleByBooleanLiteral

Added ExpressibleByBooleanLiteral.init(booleanLiteral: Self.BooleanLiteralType)

Added ExpressibleByDictionaryLiteral

Added ExpressibleByDictionaryLiteral.init(dictionaryLiteral: (Self.Key, Self.Value))

Added ExpressibleByExtendedGraphemeClusterLiteral

Added ExpressibleByExtendedGraphemeClusterLiteral.init(extendedGraphemeClusterLiteral: Self.ExtendedGraphemeClusterLiteralType)

Added ExpressibleByFloatLiteral

Added ExpressibleByFloatLiteral.init(floatLiteral: Self.FloatLiteralType)

Added ExpressibleByIntegerLiteral

Added ExpressibleByIntegerLiteral.init(integerLiteral: Self.IntegerLiteralType)

Added ExpressibleByNilLiteral

Added ExpressibleByNilLiteral.init(nilLiteral: ())

Added ExpressibleByStringInterpolation

Added ExpressibleByStringInterpolation.init(stringInterpolation: Self)

Added ExpressibleByStringInterpolation.init<T>(stringInterpolationSegment: T)

Added ExpressibleByStringLiteral

Added ExpressibleByStringLiteral.init(stringLiteral: Self.StringLiteralType)

Added ExpressibleByUnicodeScalarLiteral

Added ExpressibleByUnicodeScalarLiteral.init(unicodeScalarLiteral: Self.UnicodeScalarLiteralType)

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.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.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 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.dropFirst() -> Slice<FlattenCollection<Base>>

Added FlattenCollection.dropFirst(_: Int) -> Slice<FlattenCollection<Base>>

Added FlattenCollection.dropLast() -> Slice<FlattenCollection<Base>>

Added FlattenCollection.dropLast(_: Int) -> Slice<FlattenCollection<Base>>

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.enumerated() -> EnumeratedSequence<FlattenCollection<Base>>

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.isEmpty

Added FlattenCollection.joined() -> FlattenCollection<FlattenCollection<Base>>

Added FlattenCollection.joined() -> FlattenSequence<FlattenCollection<Base>>

Added FlattenCollection.joined(separator: String) -> String

Added FlattenCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<FlattenCollection<Base>>

Added FlattenCollection.lazy

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.makeIterator() -> FlattenIterator<Base.Iterator>

Added FlattenCollection.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]

Added FlattenCollection.max() -> Base.Iterator.Element.Iterator.Element?

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() -> 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(_: Int) -> Slice<FlattenCollection<Base>>

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.reversed() -> [Base.Iterator.Element.Iterator.Element]

Added FlattenCollection.sorted() -> [Base.Iterator.Element.Iterator.Element]

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(_: Int) -> Slice<FlattenCollection<Base>>

Added FlattenCollection.suffix(from: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>>

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.dropFirst() -> AnySequence<Base.Iterator.Element.Iterator.Element>

Added FlattenSequence.dropFirst(_: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>

Added FlattenSequence.dropLast() -> AnySequence<Base.Iterator.Element.Iterator.Element>

Added FlattenSequence.dropLast(_: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>

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.enumerated() -> EnumeratedSequence<FlattenSequence<Base>>

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.joined() -> FlattenSequence<FlattenSequence<Base>>

Added FlattenSequence.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<FlattenSequence<Base>>

Added FlattenSequence.joined(separator: String) -> String

Added FlattenSequence.lazy

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.makeIterator() -> FlattenIterator<Base.Iterator>

Added FlattenSequence.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]

Added FlattenSequence.max() -> Base.Iterator.Element.Iterator.Element?

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() -> 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.prefix(_: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>

Added FlattenSequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result

Added FlattenSequence.reversed() -> [Base.Iterator.Element.Iterator.Element]

Added FlattenSequence.sorted() -> [Base.Iterator.Element.Iterator.Element]

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 FlattenSequence.suffix(_: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>

Added FlattenSequence.underestimatedCount

Added Float.add(_: Float)

Added Float.addProduct(_: Float, _: Float)

Added Float.advanced(by: Float) -> Float

Added Float.binade

Added Float.bitPattern

Added Float.customMirror

Added Float.customPlaygroundQuickLook

Added Float.distance(to: Float) -> Float

Added Float.divide(by: Float)

Added Float.exponent

Added Float.exponentBitCount

Added Float.exponentBitPattern

Added Float.formRemainder(dividingBy: Float)

Added Float.formSquareRoot()

Added Float.formTruncatingRemainder(dividingBy: Float)

Added Float.greatestFiniteMagnitude

Added Float.init(bitPattern: UInt32)

Added Float.init(exactly: Float)

Added Float.init(exactly: Double)

Added Float.init(nan: Float.RawSignificand, signaling: Bool)

Added Float.init(sign: FloatingPointSign, exponent: Int, significand: Float)

Added Float.init(sign: FloatingPointSign, exponentBitPattern: UInt, significandBitPattern: UInt32)

Added Float.isCanonical

Added Float.isEqual(to: Float) -> Bool

Added Float.isLess(than: Float) -> Bool

Added Float.isLessThanOrEqualTo(_: Float) -> Bool

Added Float.isSignalingNaN

Added Float.leastNonzeroMagnitude

Added Float.leastNormalMagnitude

Added Float.multiply(by: Float)

Added Float.nan

Added Float.negate()

Added Float.nextUp

Added Float.pi

Added Float.round(_: FloatingPointRoundingRule)

Added Float.sign

Added Float.signalingNaN

Added Float.significand

Added Float.significandBitCount

Added Float.significandBitPattern

Added Float.significandWidth

Added Float.subtract(_: Float)

Added Float.ulp

Added FloatingPoint

Added FloatingPoint.add(_: Self)

Added FloatingPoint.adding(_: Self) -> Self

Added FloatingPoint.addingProduct(_: Self, _: Self) -> Self

Added FloatingPoint.addProduct(_: Self, _: Self)

Added FloatingPoint.divide(by: Self)

Added FloatingPoint.divided(by: Self) -> Self

Added FloatingPoint.exponent

Added FloatingPoint.floatingPointClass

Added FloatingPoint.formRemainder(dividingBy: Self)

Added FloatingPoint.formSquareRoot()

Added FloatingPoint.formTruncatingRemainder(dividingBy: Self)

Added FloatingPoint.greatestFiniteMagnitude

Added FloatingPoint.infinity

Added FloatingPoint.init(_: Int16)

Added FloatingPoint.init(_: UInt8)

Added FloatingPoint.init(_: UInt64)

Added FloatingPoint.init(_: Int64)

Added FloatingPoint.init(_: Int8)

Added FloatingPoint.init(_: Int32)

Added FloatingPoint.init(_: Int)

Added FloatingPoint.init(_: UInt16)

Added FloatingPoint.init(_: UInt32)

Added FloatingPoint.init(_: UInt)

Added FloatingPoint.init(sign: FloatingPointSign, exponent: Self.Exponent, significand: Self)

Added FloatingPoint.init(signOf: Self, magnitudeOf: Self)

Added FloatingPoint.isCanonical

Added FloatingPoint.isEqual(to: Self) -> Bool

Added FloatingPoint.isFinite

Added FloatingPoint.isInfinite

Added FloatingPoint.isLess(than: Self) -> Bool

Added FloatingPoint.isLessThanOrEqualTo(_: Self) -> Bool

Added FloatingPoint.isNaN

Added FloatingPoint.isNormal

Added FloatingPoint.isSignalingNaN

Added FloatingPoint.isSubnormal

Added FloatingPoint.isTotallyOrdered(belowOrEqualTo: Self) -> Bool

Added FloatingPoint.isZero

Added FloatingPoint.leastNonzeroMagnitude

Added FloatingPoint.leastNormalMagnitude

Added FloatingPoint.maximum(_: Self, _: Self) -> Self [class]

Added FloatingPoint.maximumMagnitude(_: Self, _: Self) -> Self [class]

Added FloatingPoint.minimum(_: Self, _: Self) -> Self [class]

Added FloatingPoint.minimumMagnitude(_: Self, _: Self) -> Self [class]

Added FloatingPoint.multiplied(by: Self) -> Self

Added FloatingPoint.multiply(by: Self)

Added FloatingPoint.nan

Added FloatingPoint.negate()

Added FloatingPoint.negated() -> Self

Added FloatingPoint.nextDown

Added FloatingPoint.nextUp

Added FloatingPoint.pi

Added FloatingPoint.radix

Added FloatingPoint.remainder(dividingBy: Self) -> Self

Added FloatingPoint.round()

Added FloatingPoint.round(_: FloatingPointRoundingRule)

Added FloatingPoint.rounded() -> Self

Added FloatingPoint.rounded(_: FloatingPointRoundingRule) -> Self

Added FloatingPoint.sign

Added FloatingPoint.signalingNaN

Added FloatingPoint.significand

Added FloatingPoint.squareRoot() -> Self

Added FloatingPoint.subtract(_: Self)

Added FloatingPoint.subtracting(_: Self) -> Self

Added FloatingPoint.truncatingRemainder(dividingBy: Self) -> Self

Added FloatingPoint.ulp

Added FloatingPoint.ulpOfOne

Added FloatingPointClassification.negativeInfinity

Added FloatingPointClassification.negativeNormal

Added FloatingPointClassification.negativeSubnormal

Added FloatingPointClassification.negativeZero

Added FloatingPointClassification.positiveInfinity

Added FloatingPointClassification.positiveNormal

Added FloatingPointClassification.positiveSubnormal

Added FloatingPointClassification.positiveZero

Added FloatingPointClassification.quietNaN

Added FloatingPointClassification.signalingNaN

Added FloatingPointRoundingRule [enum]

Added FloatingPointRoundingRule.awayFromZero

Added FloatingPointRoundingRule.down

Added FloatingPointRoundingRule.toNearestOrAwayFromZero

Added FloatingPointRoundingRule.toNearestOrEven

Added FloatingPointRoundingRule.towardZero

Added FloatingPointRoundingRule.up

Added FloatingPointSign [enum]

Added FloatingPointSign.minus

Added FloatingPointSign.plus

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.formIndex(_: Self.Index, offsetBy: Self.IndexDistance)

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, 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 [struct]

Added IndexingIterator.contains(where: (Elements._Element) throws -> Bool) rethrows -> Bool

Added IndexingIterator.dropFirst() -> AnySequence<Elements._Element>

Added IndexingIterator.dropFirst(_: Int) -> AnySequence<Elements._Element>

Added IndexingIterator.dropLast() -> AnySequence<Elements._Element>

Added IndexingIterator.dropLast(_: Int) -> AnySequence<Elements._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.enumerated() -> EnumeratedSequence<IndexingIterator<Elements>>

Added IndexingIterator.filter(_: (Elements._Element) throws -> Bool) rethrows -> [Elements._Element]

Added IndexingIterator.first(where: (Elements._Element) throws -> Bool) rethrows -> Elements._Element?

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.forEach(_: (Elements._Element) throws -> Void) rethrows

Added IndexingIterator.joined() -> FlattenSequence<IndexingIterator<Elements>>

Added IndexingIterator.joined(separator: String) -> String

Added IndexingIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<IndexingIterator<Elements>>

Added IndexingIterator.lazy

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.makeIterator() -> IndexingIterator<Elements>

Added IndexingIterator.map<T>(_: (Elements._Element) throws -> T) rethrows -> [T]

Added IndexingIterator.max() -> Elements._Element?

Added IndexingIterator.max(by: (Elements._Element, Elements._Element) throws -> Bool) rethrows -> Elements._Element?

Added IndexingIterator.min() -> Elements._Element?

Added IndexingIterator.min(by: (Elements._Element, Elements._Element) throws -> Bool) rethrows -> Elements._Element?

Added IndexingIterator.next() -> Elements._Element?

Added IndexingIterator.prefix(_: Int) -> AnySequence<Elements._Element>

Added IndexingIterator.reduce<Result>(_: Result, _: (Result, Elements._Element) throws -> Result) rethrows -> Result

Added IndexingIterator.reversed() -> [Elements._Element]

Added IndexingIterator.sorted() -> [Elements._Element]

Added IndexingIterator.sorted(by: (Elements._Element, Elements._Element) -> Bool) -> [Elements._Element]

Added IndexingIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Elements._Element) throws -> Bool) rethrows -> [AnySequence<Elements._Element>]

Added IndexingIterator.split(separator: Elements._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Elements._Element>]

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 IndexingIterator.suffix(_: Int) -> AnySequence<Elements._Element>

Added IndexingIterator.underestimatedCount

Added Int.advanced(by: Int) -> Int

Added Int.customMirror

Added Int.customPlaygroundQuickLook

Added Int.distance(to: Int) -> Int

Added Int.init(bitPattern: UnsafePointer?)

Added Int.init(bitPattern: ObjectIdentifier)

Added Int.init(bitPattern: UnsafeMutableRawPointer?)

Added Int.init(bitPattern: UnsafeMutablePointer?)

Added Int.init(bitPattern: OpaquePointer?)

Added Int.init(bitPattern: UnsafeRawPointer?)

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.advanced(by: Int) -> Int16

Added Int16.customMirror

Added Int16.customPlaygroundQuickLook

Added Int16.distance(to: Int16) -> Int

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.advanced(by: Int) -> Int32

Added Int32.customMirror

Added Int32.customPlaygroundQuickLook

Added Int32.distance(to: Int32) -> Int

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.advanced(by: Int) -> Int64

Added Int64.customMirror

Added Int64.customPlaygroundQuickLook

Added Int64.distance(to: Int64) -> Int

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.advanced(by: Int) -> Int8

Added Int8.customMirror

Added Int8.customPlaygroundQuickLook

Added Int8.distance(to: Int8) -> Int

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 [struct]

Added IteratorOverOne.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added IteratorOverOne.dropFirst() -> AnySequence<Element>

Added IteratorOverOne.dropFirst(_: Int) -> AnySequence<Element>

Added IteratorOverOne.dropLast() -> AnySequence<Element>

Added IteratorOverOne.dropLast(_: Int) -> AnySequence<Element>

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.enumerated() -> EnumeratedSequence<IteratorOverOne<Element>>

Added IteratorOverOne.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added IteratorOverOne.first(where: (Element) throws -> Bool) rethrows -> Element?

Added IteratorOverOne.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Added IteratorOverOne.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]

Added IteratorOverOne.forEach(_: (Element) throws -> Void) rethrows

Added IteratorOverOne.joined() -> FlattenSequence<IteratorOverOne<Element>>

Added IteratorOverOne.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<IteratorOverOne<Element>>

Added IteratorOverOne.joined(separator: String) -> String

Added IteratorOverOne.lazy

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.makeIterator() -> IteratorOverOne<Element>

Added IteratorOverOne.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added IteratorOverOne.max() -> Element?

Added IteratorOverOne.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added IteratorOverOne.min() -> Element?

Added IteratorOverOne.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added IteratorOverOne.next() -> Element?

Added IteratorOverOne.prefix(_: Int) -> AnySequence<Element>

Added IteratorOverOne.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added IteratorOverOne.reversed() -> [Element]

Added IteratorOverOne.sorted() -> [Element]

Added IteratorOverOne.sorted(by: (Element, Element) -> Bool) -> [Element]

Added IteratorOverOne.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]

Added IteratorOverOne.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]

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 IteratorOverOne.suffix(_: Int) -> AnySequence<Element>

Added IteratorOverOne.underestimatedCount

Added IteratorProtocol

Added IteratorProtocol.next() -> Self.Element?

Added IteratorSequence [struct]

Added IteratorSequence.contains(where: (Base.Element) throws -> Bool) rethrows -> Bool

Added IteratorSequence.dropFirst() -> AnySequence<Base.Element>

Added IteratorSequence.dropFirst(_: Int) -> AnySequence<Base.Element>

Added IteratorSequence.dropLast() -> AnySequence<Base.Element>

Added IteratorSequence.dropLast(_: Int) -> AnySequence<Base.Element>

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.enumerated() -> EnumeratedSequence<IteratorSequence<Base>>

Added IteratorSequence.filter(_: (Base.Element) throws -> Bool) rethrows -> [Base.Element]

Added IteratorSequence.first(where: (Base.Element) throws -> Bool) rethrows -> Base.Element?

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.forEach(_: (Base.Element) throws -> Void) rethrows

Added IteratorSequence.init(_: Base)

Added IteratorSequence.joined() -> FlattenSequence<IteratorSequence<Base>>

Added IteratorSequence.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<IteratorSequence<Base>>

Added IteratorSequence.joined(separator: String) -> String

Added IteratorSequence.lazy

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.makeIterator() -> IteratorSequence<Base>

Added IteratorSequence.map<T>(_: (Base.Element) throws -> T) rethrows -> [T]

Added IteratorSequence.max() -> Base.Element?

Added IteratorSequence.max(by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Base.Element?

Added IteratorSequence.min() -> Base.Element?

Added IteratorSequence.min(by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Base.Element?

Added IteratorSequence.next() -> Base.Element?

Added IteratorSequence.prefix(_: Int) -> AnySequence<Base.Element>

Added IteratorSequence.reduce<Result>(_: Result, _: (Result, Base.Element) throws -> Result) rethrows -> Result

Added IteratorSequence.reversed() -> [Base.Element]

Added IteratorSequence.sorted() -> [Base.Element]

Added IteratorSequence.sorted(by: (Base.Element, Base.Element) -> Bool) -> [Base.Element]

Added IteratorSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Element) throws -> Bool) rethrows -> [AnySequence<Base.Element>]

Added IteratorSequence.split(separator: Base.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Element>]

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 IteratorSequence.suffix(_: Int) -> AnySequence<Base.Element>

Added IteratorSequence.underestimatedCount

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 [struct]

Added JoinedSequence.contains(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool

Added JoinedSequence.dropFirst() -> AnySequence<Base.Iterator.Element.Iterator.Element>

Added JoinedSequence.dropFirst(_: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>

Added JoinedSequence.dropLast() -> AnySequence<Base.Iterator.Element.Iterator.Element>

Added JoinedSequence.dropLast(_: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>

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.enumerated() -> EnumeratedSequence<JoinedSequence<Base>>

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.init<Separator : Sequence where Separator.Iterator.Element == Base.Iterator.Element.Iterator.Element>(base: Base, separator: Separator)

Added JoinedSequence.joined() -> FlattenSequence<JoinedSequence<Base>>

Added JoinedSequence.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<JoinedSequence<Base>>

Added JoinedSequence.joined(separator: String) -> String

Added JoinedSequence.lazy

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.makeIterator() -> JoinedIterator<Base.Iterator>

Added JoinedSequence.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]

Added JoinedSequence.max() -> Base.Iterator.Element.Iterator.Element?

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() -> 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.prefix(_: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>

Added JoinedSequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result

Added JoinedSequence.reversed() -> [Base.Iterator.Element.Iterator.Element]

Added JoinedSequence.sorted() -> [Base.Iterator.Element.Iterator.Element]

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 JoinedSequence.suffix(_: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element>

Added JoinedSequence.underestimatedCount

Added LazyBidirectionalCollection [struct]

Added LazyBidirectionalCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool

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.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(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.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.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(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>

Added LazyBidirectionalCollection.map(_: (Base.Iterator.Element) -> U) -> LazyMapBidirectionalCollection<Base, U>

Added LazyBidirectionalCollection.map(_: (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 LazyCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool

Added LazyCollection.count

Added LazyCollection.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance

Added LazyCollection.dropFirst() -> LazyCollection<Slice<Base>>

Added LazyCollection.dropFirst(_: Int) -> LazyCollection<Slice<Base>>

Added LazyCollection.dropLast() -> LazyCollection<Slice<Base>>

Added LazyCollection.dropLast(_: Int) -> LazyCollection<Slice<Base>>

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.enumerated() -> EnumeratedSequence<LazyCollection<Base>>

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.indices

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.joined(separator: String) -> String

Added LazyCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyCollection<Base>>

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.makeIterator() -> Base.Iterator

Added LazyCollection.map(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<Base, U>

Added LazyCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]

Added LazyCollection.map(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>

Added LazyCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]

Added LazyCollection.max() -> Base.Iterator.Element?

Added LazyCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?

Added LazyCollection.min() -> 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.prefix(_: Int) -> LazyCollection<Slice<Base>>

Added LazyCollection.prefix(through: Base.Index) -> LazyCollection<Slice<Base>>

Added LazyCollection.prefix(upTo: Base.Index) -> LazyCollection<Slice<Base>>

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.reversed() -> [Base.Iterator.Element]

Added LazyCollection.sorted() -> [Base.Iterator.Element]

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.suffix(_: Int) -> LazyCollection<Slice<Base>>

Added LazyCollection.suffix(from: Base.Index) -> LazyCollection<Slice<Base>>

Added LazyCollection.underestimatedCount

Added LazyCollectionProtocol

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(_: (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.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.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(_: (Base.Iterator.Element) -> U) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<Base>, U>

Added LazyFilterBidirectionalCollection.map(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<LazyFilterBidirectionalCollection<Base>, U>

Added LazyFilterBidirectionalCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]

Added LazyFilterBidirectionalCollection.map(_: (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.suffix(_: Int) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>

Added LazyFilterBidirectionalCollection.suffix(from: LazyFilterIndex<Base>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>

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.dropFirst() -> Slice<LazyFilterCollection<Base>>

Added LazyFilterCollection.dropFirst(_: Int) -> Slice<LazyFilterCollection<Base>>

Added LazyFilterCollection.dropLast() -> Slice<LazyFilterCollection<Base>>

Added LazyFilterCollection.dropLast(_: Int) -> Slice<LazyFilterCollection<Base>>

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.enumerated() -> EnumeratedSequence<LazyFilterCollection<Base>>

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.formIndex(after: LazyFilterIndex<Base>)

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(after: 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.isEmpty

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.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyFilterCollection<Base>>

Added LazyFilterCollection.joined(separator: String) -> String

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.makeIterator() -> LazyFilterIterator<Base.Iterator>

Added LazyFilterCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]

Added LazyFilterCollection.map(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterCollection<Base>, U>

Added LazyFilterCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]

Added LazyFilterCollection.map(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<LazyFilterCollection<Base>, U>

Added LazyFilterCollection.max() -> Base.Iterator.Element?

Added LazyFilterCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?

Added LazyFilterCollection.min() -> Base.Iterator.Element?

Added LazyFilterCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?

Added LazyFilterCollection.prefix(_: Int) -> Slice<LazyFilterCollection<Base>>

Added LazyFilterCollection.prefix(through: LazyFilterIndex<Base>) -> Slice<LazyFilterCollection<Base>>

Added LazyFilterCollection.prefix(upTo: LazyFilterIndex<Base>) -> Slice<LazyFilterCollection<Base>>

Added LazyFilterCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result

Added LazyFilterCollection.reversed() -> [Base.Iterator.Element]

Added LazyFilterCollection.sorted() -> [Base.Iterator.Element]

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.suffix(_: Int) -> Slice<LazyFilterCollection<Base>>

Added LazyFilterCollection.suffix(from: LazyFilterIndex<Base>) -> Slice<LazyFilterCollection<Base>>

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.dropFirst() -> AnySequence<Base.Iterator.Element>

Added LazyFilterSequence.dropFirst(_: Int) -> AnySequence<Base.Iterator.Element>

Added LazyFilterSequence.dropLast() -> AnySequence<Base.Iterator.Element>

Added LazyFilterSequence.dropLast(_: Int) -> AnySequence<Base.Iterator.Element>

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.enumerated() -> EnumeratedSequence<LazyFilterSequence<Base>>

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.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyFilterSequence<Base>>

Added LazyFilterSequence.joined(separator: String) -> String

Added LazyFilterSequence.lazy

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.makeIterator() -> LazyFilterIterator<Base.Iterator>

Added LazyFilterSequence.map(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterSequence<Base>, U>

Added LazyFilterSequence.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]

Added LazyFilterSequence.max() -> Base.Iterator.Element?

Added LazyFilterSequence.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?

Added LazyFilterSequence.min() -> Base.Iterator.Element?

Added LazyFilterSequence.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?

Added LazyFilterSequence.prefix(_: Int) -> AnySequence<Base.Iterator.Element>

Added LazyFilterSequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result

Added LazyFilterSequence.reversed() -> [Base.Iterator.Element]

Added LazyFilterSequence.sorted() -> [Base.Iterator.Element]

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 LazyFilterSequence.suffix(_: Int) -> AnySequence<Base.Iterator.Element>

Added LazyFilterSequence.underestimatedCount

Added LazyMapBidirectionalCollection [struct]

Added LazyMapBidirectionalCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool

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.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(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.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.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(_: (Element) -> U) -> LazyMapBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>, U>

Added LazyMapBidirectionalCollection.map(_: (Element) -> U) -> LazyMapSequence<LazyMapBidirectionalCollection<Base, Element>, U>

Added LazyMapBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added LazyMapBidirectionalCollection.map(_: (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 LazyMapCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added LazyMapCollection.count

Added LazyMapCollection.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance

Added LazyMapCollection.dropFirst() -> Slice<LazyMapCollection<Base, Element>>

Added LazyMapCollection.dropFirst(_: Int) -> Slice<LazyMapCollection<Base, Element>>

Added LazyMapCollection.dropLast() -> Slice<LazyMapCollection<Base, Element>>

Added LazyMapCollection.dropLast(_: Int) -> Slice<LazyMapCollection<Base, Element>>

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.enumerated() -> EnumeratedSequence<LazyMapCollection<Base, Element>>

Added LazyMapCollection.filter(_: (Element) -> Bool) -> LazyFilterCollection<LazyMapCollection<Base, Element>>

Added LazyMapCollection.first

Added LazyMapCollection.first(where: (Element) throws -> Bool) rethrows -> Element?

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.forEach(_: (Element) throws -> Void) rethrows

Added LazyMapCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)

Added LazyMapCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool

Added LazyMapCollection.formIndex(after: Base.Index)

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(after: Base.Index) -> Base.Index

Added LazyMapCollection.index(of: Element) -> Base.Index?

Added LazyMapCollection.index(where: (Element) throws -> Bool) rethrows -> Base.Index?

Added LazyMapCollection.indices

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.joined(separator: String) -> String

Added LazyMapCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyMapCollection<Base, Element>>

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.makeIterator() -> LazyMapIterator<Base.Iterator, Element>

Added LazyMapCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added LazyMapCollection.map(_: (Element) -> U) -> LazyMapCollection<LazyMapCollection<Base, Element>, U>

Added LazyMapCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added LazyMapCollection.map(_: (Element) -> U) -> LazyMapSequence<LazyMapCollection<Base, Element>, U>

Added LazyMapCollection.max() -> Element?

Added LazyMapCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added LazyMapCollection.min() -> Element?

Added LazyMapCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added LazyMapCollection.prefix(_: Int) -> Slice<LazyMapCollection<Base, Element>>

Added LazyMapCollection.prefix(through: Base.Index) -> Slice<LazyMapCollection<Base, Element>>

Added LazyMapCollection.prefix(upTo: Base.Index) -> Slice<LazyMapCollection<Base, Element>>

Added LazyMapCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added LazyMapCollection.reversed() -> [Element]

Added LazyMapCollection.sorted() -> [Element]

Added LazyMapCollection.sorted(by: (Element, Element) -> Bool) -> [Element]

Added LazyMapCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [Slice<LazyMapCollection<Base, Element>>]

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(_: CountableClosedRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>>

Added LazyMapCollection.subscript(_: ClosedRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>>

Added LazyMapCollection.suffix(_: Int) -> Slice<LazyMapCollection<Base, Element>>

Added LazyMapCollection.suffix(from: Base.Index) -> Slice<LazyMapCollection<Base, Element>>

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.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.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(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.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.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(_: (Element) -> U) -> LazyMapRandomAccessCollection<LazyMapRandomAccessCollection<Base, Element>, U>

Added LazyMapRandomAccessCollection.map(_: (Element) -> U) -> LazyMapBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>, U>

Added LazyMapRandomAccessCollection.map(_: (Element) -> U) -> LazyMapSequence<LazyMapRandomAccessCollection<Base, Element>, U>

Added LazyMapRandomAccessCollection.map(_: (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 LazyMapSequence.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added LazyMapSequence.dropFirst() -> AnySequence<Element>

Added LazyMapSequence.dropFirst(_: Int) -> AnySequence<Element>

Added LazyMapSequence.dropLast() -> AnySequence<Element>

Added LazyMapSequence.dropLast(_: Int) -> AnySequence<Element>

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.enumerated() -> EnumeratedSequence<LazyMapSequence<Base, Element>>

Added LazyMapSequence.filter(_: (Element) -> Bool) -> LazyFilterSequence<LazyMapSequence<Base, Element>>

Added LazyMapSequence.first(where: (Element) throws -> Bool) rethrows -> Element?

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.forEach(_: (Element) throws -> Void) rethrows

Added LazyMapSequence.joined() -> FlattenSequence<LazyMapSequence<Base, Element>>

Added LazyMapSequence.joined() -> LazySequence<FlattenSequence<LazyMapSequence<Base, Element>>>

Added LazyMapSequence.joined(separator: String) -> String

Added LazyMapSequence.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyMapSequence<Base, Element>>

Added LazyMapSequence.lazy

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.makeIterator() -> LazyMapIterator<Base.Iterator, Element>

Added LazyMapSequence.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added LazyMapSequence.map(_: (Element) -> U) -> LazyMapSequence<LazyMapSequence<Base, Element>, U>

Added LazyMapSequence.max() -> Element?

Added LazyMapSequence.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added LazyMapSequence.min() -> Element?

Added LazyMapSequence.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added LazyMapSequence.prefix(_: Int) -> AnySequence<Element>

Added LazyMapSequence.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added LazyMapSequence.reversed() -> [Element]

Added LazyMapSequence.sorted() -> [Element]

Added LazyMapSequence.sorted(by: (Element, Element) -> Bool) -> [Element]

Added LazyMapSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]

Added LazyMapSequence.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]

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.suffix(_: Int) -> AnySequence<Element>

Added LazyMapSequence.underestimatedCount

Added LazyRandomAccessCollection [struct]

Added LazyRandomAccessCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool

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.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(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.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.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(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<Base, U>

Added LazyRandomAccessCollection.map(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>

Added LazyRandomAccessCollection.map(_: (Base.Iterator.Element) -> U) -> LazyMapBidirectionalCollection<Base, U>

Added LazyRandomAccessCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]

Added LazyRandomAccessCollection.map(_: (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 LazySequence.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool

Added LazySequence.dropFirst() -> AnySequence<Base.Iterator.Element>

Added LazySequence.dropFirst(_: Int) -> AnySequence<Base.Iterator.Element>

Added LazySequence.dropLast() -> AnySequence<Base.Iterator.Element>

Added LazySequence.dropLast(_: Int) -> AnySequence<Base.Iterator.Element>

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.enumerated() -> EnumeratedSequence<LazySequence<Base>>

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.joined(separator: String) -> String

Added LazySequence.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazySequence<Base>>

Added LazySequence.lazy

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.makeIterator() -> Base.Iterator

Added LazySequence.map(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>

Added LazySequence.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]

Added LazySequence.max() -> Base.Iterator.Element?

Added LazySequence.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?

Added LazySequence.min() -> Base.Iterator.Element?

Added LazySequence.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?

Added LazySequence.prefix(_: Int) -> AnySequence<Base.Iterator.Element>

Added LazySequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result

Added LazySequence.reversed() -> [Base.Iterator.Element]

Added LazySequence.sorted() -> [Base.Iterator.Element]

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.suffix(_: Int) -> AnySequence<Base.Iterator.Element>

Added LazySequence.underestimatedCount

Added LazySequenceProtocol

Added LazySequenceProtocol.elements

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.joined() -> LazySequence<FlattenSequence<Self.Elements>>

Added LazySequenceProtocol.lazy

Added LazySequenceProtocol.map(_: (Self.Elements.Iterator.Element) -> U) -> LazyMapSequence<Self.Elements, U>

Added LosslessStringConvertible

Added LosslessStringConvertible.init(_: String)

Added ManagedBuffer.capacity

Added ManagedBuffer.create(minimumCapacity: Int, makingHeaderWith: (ManagedBuffer<Header, Element>) throws -> Header) rethrows -> ManagedBuffer<Header, Element> [class]

Added ManagedBuffer.header

Added ManagedBuffer.withUnsafeMutablePointers<R>(_: (UnsafeMutablePointer<Header>, UnsafeMutablePointer<Element>) throws -> R) rethrows -> R

Added ManagedBuffer.withUnsafeMutablePointerToElements<R>(_: (UnsafeMutablePointer<Element>) throws -> R) rethrows -> R

Added ManagedBuffer.withUnsafeMutablePointerToHeader<R>(_: (UnsafeMutablePointer<Header>) throws -> R) rethrows -> R

Added ManagedBufferPointer.capacity

Added ManagedBufferPointer.header

Added ManagedBufferPointer.init(bufferClass: Swift.AnyClass, minimumCapacity: Int, makingHeaderWith: (AnyObject, (AnyObject) -> Int) throws -> Header) rethrows

Added ManagedBufferPointer.isUniqueReference() -> Bool

Added ManagedBufferPointer.withUnsafeMutablePointers<R>(_: (UnsafeMutablePointer<Header>, UnsafeMutablePointer<Element>) throws -> R) rethrows -> R

Added ManagedBufferPointer.withUnsafeMutablePointerToElements<R>(_: (UnsafeMutablePointer<Element>) throws -> R) rethrows -> R

Added ManagedBufferPointer.withUnsafeMutablePointerToHeader<R>(_: (UnsafeMutablePointer<Header>) throws -> R) rethrows -> R

Added MemoryLayout [enum]

Added MemoryLayout.alignment

Added MemoryLayout.alignment(ofValue: T) -> Int [static]

Added MemoryLayout.size

Added MemoryLayout.size(ofValue: T) -> Int [static]

Added MemoryLayout.stride

Added MemoryLayout.stride(ofValue: T) -> Int [static]

Added Mirror.customMirror

Added Mirror.descendant(_: MirrorPath, _: MirrorPath) -> Any?

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.superclassMirror

Added Mirror.AncestorRepresentation.customized

Added Mirror.AncestorRepresentation.generated

Added Mirror.AncestorRepresentation.suppressed

Added Mirror.DisplayStyle.class

Added Mirror.DisplayStyle.collection

Added Mirror.DisplayStyle.dictionary

Added Mirror.DisplayStyle.enum

Added Mirror.DisplayStyle.optional

Added Mirror.DisplayStyle.set

Added Mirror.DisplayStyle.struct

Added Mirror.DisplayStyle.tuple

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.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.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 MirrorPath

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.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.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.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(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(_: 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 MutableCollection

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 MutableCollection.subscript(_: Self.Index) -> Self.Iterator.Element

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.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.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.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(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(_: 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 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.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.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.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.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.removeAll(keepingCapacity: Bool)

Added MutableRangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element

Added MutableRangeReplaceableBidirectionalSlice.removeFirst(_: Int)

Added MutableRangeReplaceableBidirectionalSlice.removeLast() -> Base._Element

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(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.suffix(_: Int) -> MutableRangeReplaceableBidirectionalSlice<Base>

Added MutableRangeReplaceableBidirectionalSlice.suffix(from: Base.Index) -> MutableRangeReplaceableBidirectionalSlice<Base>

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.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.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.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.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.removeAll(keepingCapacity: Bool)

Added MutableRangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element

Added MutableRangeReplaceableRandomAccessSlice.removeFirst(_: Int)

Added MutableRangeReplaceableRandomAccessSlice.removeLast() -> Base._Element

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(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(_: 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 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.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.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.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.removeAll(keepingCapacity: Bool)

Added MutableRangeReplaceableSlice.removeFirst() -> Base._Element

Added MutableRangeReplaceableSlice.removeFirst(_: Int)

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(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(_: Base.Index) -> Base._Element

Added MutableRangeReplaceableSlice.subscript(_: CountableRange<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 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.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.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(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 Never [enum]

Added ObjectIdentifier.debugDescription

Added OpaquePointer [struct]

Added OpaquePointer.debugDescription

Added OpaquePointer.hashValue

Added OpaquePointer.init(_: UnsafeMutablePointer<T>?)

Added OpaquePointer.init<T>(_: UnsafePointer<T>)

Added OpaquePointer.init<T>(_: UnsafeMutablePointer<T>)

Added OpaquePointer.init(_: UnsafeRawPointer)

Added OpaquePointer.init(_: UnsafeRawPointer?)

Added OpaquePointer.init(_: UnsafePointer<T>?)

Added OpaquePointer.init(_: UnsafeMutableRawPointer?)

Added OpaquePointer.init(_: UnsafeMutableRawPointer)

Added OpaquePointer.init(bitPattern: Int)

Added OpaquePointer.init(bitPattern: UInt)

Added Optional.customMirror

Added Optional.none

Added Optional.some

Added Optional.unsafelyUnwrapped

Added OptionSet

Added OptionSet.contains(_: Self) -> Bool

Added OptionSet.formIntersection(_: Self)

Added OptionSet.formSymmetricDifference(_: Self)

Added OptionSet.formUnion(_: Self)

Added OptionSet.init()

Added OptionSet.init(rawValue: Self.RawValue)

Added OptionSet.insert(_: Self) -> (inserted: Bool, memberAfterInsert: Self)

Added OptionSet.intersection(_: Self) -> Self

Added OptionSet.remove(_: Self) -> Self?

Added OptionSet.symmetricDifference(_: Self) -> Self

Added OptionSet.union(_: Self) -> Self

Added OptionSet.update(with: Self) -> Self?

Added PlaygroundQuickLook.attributedString

Added PlaygroundQuickLook.bezierPath

Added PlaygroundQuickLook.bool

Added PlaygroundQuickLook.color

Added PlaygroundQuickLook.double

Added PlaygroundQuickLook.float

Added PlaygroundQuickLook.image

Added PlaygroundQuickLook.int

Added PlaygroundQuickLook.point

Added PlaygroundQuickLook.range

Added PlaygroundQuickLook.rectangle

Added PlaygroundQuickLook.size

Added PlaygroundQuickLook.sound

Added PlaygroundQuickLook.sprite

Added PlaygroundQuickLook.text

Added PlaygroundQuickLook.uInt

Added PlaygroundQuickLook.url

Added PlaygroundQuickLook.view

Added RandomAccessCollection

Added RandomAccessCollection.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance

Added RandomAccessCollection.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index

Added RandomAccessCollection.index(after: Self.Index) -> Self.Index

Added RandomAccessCollection.index(before: Self.Index) -> Self.Index

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.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.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 Range.clamped(to: Range<Bound>) -> Range<Bound>

Added Range.contains(_: Bound) -> Bool

Added Range.customMirror

Added Range.init(uncheckedBounds: (lower: Bound, upper: Bound))

Added Range.isEmpty

Added Range.lowerBound

Added Range.overlaps(_: ClosedRange<Bound>) -> Bool

Added Range.overlaps(_: Range<Bound>) -> Bool

Added Range.upperBound

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.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.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.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.removeAll(keepingCapacity: Bool)

Added RangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element

Added RangeReplaceableBidirectionalSlice.removeFirst(_: Int)

Added RangeReplaceableBidirectionalSlice.removeLast() -> Base._Element

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 RangeReplaceableCollection

Added RangeReplaceableCollection.append(_: Self.Iterator.Element)

Added RangeReplaceableCollection.append<S : Sequence where S.Iterator.Element == Iterator.Element>(contentsOf: S)

Added RangeReplaceableCollection.init()

Added RangeReplaceableCollection.init<S : Sequence where S.Iterator.Element == Iterator.Element>(_: S)

Added RangeReplaceableCollection.init(repeating: Self.Iterator.Element, count: Int)

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.removeAll(keepingCapacity: Bool)

Added RangeReplaceableCollection.removeFirst() -> Self.Iterator.Element

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 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.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.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.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.removeAll(keepingCapacity: Bool)

Added RangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element

Added RangeReplaceableRandomAccessSlice.removeFirst(_: Int)

Added RangeReplaceableRandomAccessSlice.removeLast() -> Base._Element

Added RangeReplaceableRandomAccessSlice.removeLast(_: Int)

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 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.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.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.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.removeAll(keepingCapacity: Bool)

Added RangeReplaceableSlice.removeFirst() -> Base._Element

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 Repeated [struct]

Added Repeated.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added Repeated.count

Added Repeated.distance(from: Int, to: Int) -> Int

Added Repeated.dropFirst() -> RandomAccessSlice<Repeated<Element>>

Added Repeated.dropFirst(_: Int) -> RandomAccessSlice<Repeated<Element>>

Added Repeated.dropLast() -> RandomAccessSlice<Repeated<Element>>

Added Repeated.dropLast(_: Int) -> RandomAccessSlice<Repeated<Element>>

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.endIndex

Added Repeated.enumerated() -> EnumeratedSequence<Repeated<Element>>

Added Repeated.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added Repeated.first

Added Repeated.first(where: (Element) throws -> Bool) rethrows -> Element?

Added Repeated.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Added Repeated.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]

Added Repeated.forEach(_: (Element) throws -> Void) rethrows

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.isEmpty

Added Repeated.joined() -> FlattenSequence<Repeated<Element>>

Added Repeated.joined() -> FlattenBidirectionalCollection<Repeated<Element>>

Added Repeated.joined() -> FlattenCollection<Repeated<Element>>

Added Repeated.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<Repeated<Element>>

Added Repeated.joined(separator: String) -> String

Added Repeated.last

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.makeIterator() -> IndexingIterator<Repeated<Element>>

Added Repeated.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added Repeated.max() -> Element?

Added Repeated.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added Repeated.min() -> Element?

Added Repeated.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added Repeated.prefix(_: Int) -> RandomAccessSlice<Repeated<Element>>

Added Repeated.prefix(through: Int) -> RandomAccessSlice<Repeated<Element>>

Added Repeated.prefix(upTo: Int) -> RandomAccessSlice<Repeated<Element>>

Added Repeated.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added Repeated.repeatedValue

Added Repeated.reversed() -> ReversedRandomAccessCollection<Repeated<Element>>

Added Repeated.sorted() -> [Element]

Added Repeated.sorted(by: (Element, Element) -> Bool) -> [Element]

Added Repeated.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [RandomAccessSlice<Repeated<Element>>]

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.startIndex

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(_: Int) -> Element

Added Repeated.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Repeated<Element>>

Added Repeated.suffix(_: Int) -> RandomAccessSlice<Repeated<Element>>

Added Repeated.suffix(from: Int) -> RandomAccessSlice<Repeated<Element>>

Added Repeated.underestimatedCount

Added ReversedCollection [struct]

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.dropFirst() -> BidirectionalSlice<ReversedCollection<Base>>

Added ReversedCollection.dropFirst(_: Int) -> BidirectionalSlice<ReversedCollection<Base>>

Added ReversedCollection.dropLast() -> BidirectionalSlice<ReversedCollection<Base>>

Added ReversedCollection.dropLast(_: Int) -> BidirectionalSlice<ReversedCollection<Base>>

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.enumerated() -> EnumeratedSequence<ReversedCollection<Base>>

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.isEmpty

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.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<ReversedCollection<Base>>

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.makeIterator() -> IndexingIterator<ReversedCollection<Base>>

Added ReversedCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]

Added ReversedCollection.max() -> Base.Iterator.Element?

Added ReversedCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?

Added ReversedCollection.min() -> Base.Iterator.Element?

Added ReversedCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?

Added ReversedCollection.prefix(_: Int) -> BidirectionalSlice<ReversedCollection<Base>>

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.reversed() -> ReversedCollection<ReversedCollection<Base>>

Added ReversedCollection.sorted() -> [Base.Iterator.Element]

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(_: Int) -> BidirectionalSlice<ReversedCollection<Base>>

Added ReversedCollection.suffix(from: ReversedIndex<Base>) -> BidirectionalSlice<ReversedCollection<Base>>

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.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.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 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() -> Self.SubSequence

Added Sequence.dropFirst(_: Int) -> Self.SubSequence

Added Sequence.dropFirst(_: Int) -> AnySequence<Self.Iterator.Element>

Added Sequence.dropLast() -> Self.SubSequence

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.enumerated() -> EnumeratedSequence<Self>

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.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.joined() -> FlattenSequence<Self>

Added Sequence.joined(separator: String) -> String

Added Sequence.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<Self>

Added Sequence.lazy

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.max() -> Self.Iterator.Element?

Added Sequence.max(by: (Self.Iterator.Element, Self.Iterator.Element) throws -> Bool) rethrows -> Self.Iterator.Element?

Added Sequence.min() -> 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.reversed() -> [Self.Iterator.Element]

Added Sequence.sorted() -> [Self.Iterator.Element]

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 Set.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added Set.count

Added Set.customMirror

Added Set.distance(from: SetIndex<Element>, to: SetIndex<Element>) -> Int

Added Set.dropFirst() -> Slice<Set<Element>>

Added Set.dropFirst(_: Int) -> Slice<Set<Element>>

Added Set.dropLast() -> Slice<Set<Element>>

Added Set.dropLast(_: Int) -> Slice<Set<Element>>

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.enumerated() -> EnumeratedSequence<Set<Element>>

Added Set.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added Set.first

Added Set.first(where: (Element) throws -> Bool) rethrows -> Element?

Added Set.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Added Set.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]

Added Set.forEach(_: (Element) throws -> Void) rethrows

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.formSymmetricDifference(_: Set<Element>)

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.insert(_: Element) -> (inserted: Bool, memberAfterInsert: Element)

Added Set.intersection<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>

Added Set.intersection(_: Set<Element>) -> Set<Element>

Added Set.isDisjoint<S : Sequence where S.Iterator.Element == Element>(with: S) -> Bool

Added Set.isDisjoint(with: Set<Element>) -> Bool

Added Set.isEmpty

Added Set.isStrictSubset<S : Sequence where S.Iterator.Element == Element>(of: S) -> Bool

Added Set.isStrictSubset(of: Set<Element>) -> Bool

Added Set.isStrictSuperset<S : Sequence where S.Iterator.Element == Element>(of: S) -> Bool

Added Set.isStrictSuperset(of: Set<Element>) -> Bool

Added Set.isSubset(of: Set<Element>) -> 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.isSuperset(of: Set<Element>) -> Bool

Added Set.joined() -> FlattenCollection<Set<Element>>

Added Set.joined() -> FlattenSequence<Set<Element>>

Added Set.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<Set<Element>>

Added Set.joined(separator: String) -> String

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.makeIterator() -> SetIterator<Element>

Added Set.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added Set.max() -> Element?

Added Set.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added Set.min() -> Element?

Added Set.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added Set.prefix(_: Int) -> Slice<Set<Element>>

Added Set.prefix(through: SetIndex<Element>) -> Slice<Set<Element>>

Added Set.prefix(upTo: SetIndex<Element>) -> Slice<Set<Element>>

Added Set.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added Set.remove<ConcreteElement : Hashable>(_: ConcreteElement) -> ConcreteElement?

Added Set.remove(at: SetIndex<Element>) -> Element

Added Set.removeAll(keepingCapacity: Bool)

Added Set.reversed() -> [Element]

Added Set.sorted() -> [Element]

Added Set.sorted(by: (Element, Element) -> Bool) -> [Element]

Added Set.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [Slice<Set<Element>>]

Added Set.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<Set<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.subtract(_: Set<Element>)

Added Set.subtracting(_: Set<Element>) -> Set<Element>

Added Set.subtracting<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>

Added Set.suffix(_: Int) -> Slice<Set<Element>>

Added Set.suffix(from: SetIndex<Element>) -> Slice<Set<Element>>

Added Set.symmetricDifference<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>

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 Set.update(with: Element) -> Element?

Added SetAlgebra

Added SetAlgebra.contains(_: Self.Element) -> Bool

Added SetAlgebra.formIntersection(_: Self)

Added SetAlgebra.formSymmetricDifference(_: Self)

Added SetAlgebra.formUnion(_: Self)

Added SetAlgebra.init()

Added SetAlgebra.init<S : Sequence where S.Iterator.Element == Element>(_: S)

Added SetAlgebra.init(arrayLiteral: Self.Element)

Added SetAlgebra.insert(_: Self.Element) -> (inserted: Bool, memberAfterInsert: Self.Element)

Added SetAlgebra.intersection(_: Self) -> Self

Added SetAlgebra.isDisjoint(with: Self) -> Bool

Added SetAlgebra.isEmpty

Added SetAlgebra.isStrictSubset(of: Self) -> Bool

Added SetAlgebra.isStrictSuperset(of: Self) -> Bool

Added SetAlgebra.isSubset(of: Self) -> Bool

Added SetAlgebra.isSuperset(of: Self) -> Bool

Added SetAlgebra.remove(_: Self.Element) -> Self.Element?

Added SetAlgebra.subtract(_: Self)

Added SetAlgebra.subtracting(_: Self) -> Self

Added SetAlgebra.symmetricDifference(_: Self) -> Self

Added SetAlgebra.union(_: Self) -> Self

Added SetAlgebra.update(with: Self.Element) -> Self.Element?

Added SetIterator [struct]

Added SetIterator.customMirror

Added SetIterator.next() -> Element?

Added SignedInteger

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.base

Added Slice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool

Added Slice.count

Added Slice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance

Added Slice.dropFirst() -> Slice<Base>

Added Slice.dropFirst(_: Int) -> Slice<Base>

Added Slice.dropLast() -> Slice<Base>

Added Slice.dropLast(_: Int) -> Slice<Base>

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.enumerated() -> EnumeratedSequence<Slice<Base>>

Added Slice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]

Added Slice.first

Added Slice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?

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.forEach(_: (Base._Element) throws -> Void) rethrows

Added Slice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)

Added Slice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool

Added Slice.formIndex(after: Base.Index)

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(after: 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.isEmpty

Added Slice.joined() -> FlattenSequence<Slice<Base>>

Added Slice.joined() -> FlattenCollection<Slice<Base>>

Added Slice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<Slice<Base>>

Added Slice.joined(separator: String) -> String

Added Slice.lazy

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.makeIterator() -> IndexingIterator<Slice<Base>>

Added Slice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]

Added Slice.max() -> Base._Element?

Added Slice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?

Added Slice.min() -> Base._Element?

Added Slice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?

Added Slice.popFirst() -> Base._Element?

Added Slice.prefix(_: Int) -> Slice<Base>

Added Slice.prefix(through: Base.Index) -> Slice<Base>

Added Slice.prefix(upTo: Base.Index) -> Slice<Base>

Added Slice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result

Added Slice.removeFirst() -> Base._Element

Added Slice.removeFirst(_: Int)

Added Slice.reversed() -> [Base._Element]

Added Slice.sorted() -> [Base._Element]

Added Slice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]

Added Slice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [Slice<Base>]

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.suffix(_: Int) -> Slice<Base>

Added Slice.suffix(from: Base.Index) -> Slice<Base>

Added Slice.underestimatedCount

Added StaticString.customMirror

Added StaticString.utf8CodeUnitCount

Added Strideable.advanced(by: Self.Stride) -> Self

Added Strideable.distance(to: Self) -> Self.Stride

Added StrideThrough.contains(_: Element) -> Bool

Added StrideThrough.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added StrideThrough.customMirror

Added StrideThrough.dropFirst() -> AnySequence<Element>

Added StrideThrough.dropFirst(_: Int) -> AnySequence<Element>

Added StrideThrough.dropLast() -> AnySequence<Element>

Added StrideThrough.dropLast(_: Int) -> AnySequence<Element>

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.enumerated() -> EnumeratedSequence<StrideThrough<Element>>

Added StrideThrough.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added StrideThrough.first(where: (Element) throws -> Bool) rethrows -> Element?

Added StrideThrough.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Added StrideThrough.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]

Added StrideThrough.forEach(_: (Element) throws -> Void) rethrows

Added StrideThrough.joined() -> FlattenSequence<StrideThrough<Element>>

Added StrideThrough.joined(separator: String) -> String

Added StrideThrough.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<StrideThrough<Element>>

Added StrideThrough.lazy

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.makeIterator() -> StrideThroughIterator<Element>

Added StrideThrough.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added StrideThrough.max() -> Element?

Added StrideThrough.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added StrideThrough.min() -> Element?

Added StrideThrough.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added StrideThrough.prefix(_: Int) -> AnySequence<Element>

Added StrideThrough.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added StrideThrough.reversed() -> [Element]

Added StrideThrough.sorted() -> [Element]

Added StrideThrough.sorted(by: (Element, Element) -> Bool) -> [Element]

Added StrideThrough.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]

Added StrideThrough.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]

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 StrideThrough.suffix(_: Int) -> AnySequence<Element>

Added StrideThrough.underestimatedCount

Added StrideThroughIterator [struct]

Added StrideThroughIterator.next() -> Element?

Added StrideTo.contains(_: Element) -> Bool

Added StrideTo.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added StrideTo.customMirror

Added StrideTo.dropFirst() -> AnySequence<Element>

Added StrideTo.dropFirst(_: Int) -> AnySequence<Element>

Added StrideTo.dropLast() -> AnySequence<Element>

Added StrideTo.dropLast(_: Int) -> AnySequence<Element>

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.enumerated() -> EnumeratedSequence<StrideTo<Element>>

Added StrideTo.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added StrideTo.first(where: (Element) throws -> Bool) rethrows -> Element?

Added StrideTo.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Added StrideTo.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]

Added StrideTo.forEach(_: (Element) throws -> Void) rethrows

Added StrideTo.joined() -> FlattenSequence<StrideTo<Element>>

Added StrideTo.joined(separator: String) -> String

Added StrideTo.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<StrideTo<Element>>

Added StrideTo.lazy

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.makeIterator() -> StrideToIterator<Element>

Added StrideTo.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added StrideTo.max() -> Element?

Added StrideTo.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added StrideTo.min() -> Element?

Added StrideTo.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added StrideTo.prefix(_: Int) -> AnySequence<Element>

Added StrideTo.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added StrideTo.reversed() -> [Element]

Added StrideTo.sorted() -> [Element]

Added StrideTo.sorted(by: (Element, Element) -> Bool) -> [Element]

Added StrideTo.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]

Added StrideTo.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]

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 StrideTo.suffix(_: Int) -> AnySequence<Element>

Added StrideTo.underestimatedCount

Added StrideToIterator [struct]

Added StrideToIterator.next() -> Element?

Added String.append(_: String)

Added String.append<S : Sequence where S.Iterator.Element == Character>(contentsOf: S)

Added String.customMirror

Added String.customPlaygroundQuickLook

Added String.decodeCString<Encoding : UnicodeCodec>(_: UnsafePointer<Encoding.CodeUnit>?, as: Encoding.Type, repairingInvalidCodeUnits: Bool) -> (result: String, repairsMade: Bool)? [static]

Added String.description

Added String.distance(from: String.Index, to: String.Index) -> String.IndexDistance

Added String.index(_: String.Index, offsetBy: String.IndexDistance) -> String.Index

Added String.index(_: String.Index, offsetBy: String.IndexDistance, limitedBy: String.Index) -> String.Index?

Added String.index(after: String.Index) -> String.Index

Added String.index(before: String.Index) -> String.Index

Added String.init<T : UnsignedInteger>(_: T)

Added String.init<S : Sequence where S.Iterator.Element == Character>(_: S)

Added String.init<T : _SignedInteger>(_: T)

Added String.init(_: String)

Added String.init<T : LosslessStringConvertible>(_: T)

Added String.init<T : UnsignedInteger>(_: T, radix: Int, uppercase: Bool)

Added String.init<T : _SignedInteger>(_: T, radix: Int, uppercase: Bool)

Added String.init(cString: UnsafePointer<UInt8>)

Added String.init(cString: UnsafePointer<CChar>)

Added String.init<Subject>(describing: Subject)

Added String.init(repeating: String, count: Int)

Added String.init(validatingUTF8: UnsafePointer<CChar>)

Added String.insert(_: Character, at: String.Index)

Added String.insert<S : Collection where S.Iterator.Element == Character>(contentsOf: S, at: String.Index)

Added String.lowercased() -> String

Added String.remove(at: String.Index) -> Character

Added String.removeAll(keepingCapacity: Bool)

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>(_: Range<String.Index>, with: C)

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.uppercased() -> String

Added String.utf8CString

Added String.write<Target : TextOutputStream>(to: Target)

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.append<S : Sequence where S.Iterator.Element == UnicodeScalar>(contentsOf: S)

Added String.UnicodeScalarView.contains(_: UnicodeScalar) -> Bool

Added String.UnicodeScalarView.contains(where: (UnicodeScalar) throws -> Bool) rethrows -> Bool

Added String.UnicodeScalarView.count

Added String.UnicodeScalarView.customMirror

Added String.UnicodeScalarView.customPlaygroundQuickLook

Added String.UnicodeScalarView.distance(from: String.UnicodeScalarView.Index, to: String.UnicodeScalarView.Index) -> Int

Added String.UnicodeScalarView.dropFirst() -> String.UnicodeScalarView

Added String.UnicodeScalarView.dropFirst(_: Int) -> String.UnicodeScalarView

Added String.UnicodeScalarView.dropLast() -> String.UnicodeScalarView

Added String.UnicodeScalarView.dropLast(_: Int) -> String.UnicodeScalarView

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.enumerated() -> EnumeratedSequence<String.UnicodeScalarView>

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(after: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index

Added String.UnicodeScalarView.index(before: 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.isEmpty

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.makeIterator() -> String.UnicodeScalarView.Iterator

Added String.UnicodeScalarView.map<T>(_: (UnicodeScalar) throws -> T) rethrows -> [T]

Added String.UnicodeScalarView.max() -> UnicodeScalar?

Added String.UnicodeScalarView.max(by: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?

Added String.UnicodeScalarView.min() -> 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.prefix(_: Int) -> String.UnicodeScalarView

Added String.UnicodeScalarView.prefix(through: String.UnicodeScalarView.Index) -> String.UnicodeScalarView

Added String.UnicodeScalarView.prefix(upTo: String.UnicodeScalarView.Index) -> String.UnicodeScalarView

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.replaceSubrange<C where C : Collection, C.Iterator.Element == UnicodeScalar>(_: Range<String.UnicodeScalarView.Index>, with: C)

Added String.UnicodeScalarView.reversed() -> ReversedCollection<String.UnicodeScalarView>

Added String.UnicodeScalarView.sorted() -> [UnicodeScalar]

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.suffix(_: Int) -> String.UnicodeScalarView

Added String.UnicodeScalarView.suffix(from: String.UnicodeScalarView.Index) -> String.UnicodeScalarView

Added String.UnicodeScalarView.underestimatedCount

Added String.UnicodeScalarView.Iterator [struct]

Added String.UnicodeScalarView.Iterator.next() -> UnicodeScalar?

Added String.UTF16View.contains(_: UInt16) -> Bool

Added String.UTF16View.contains(where: (UInt16) throws -> Bool) rethrows -> Bool

Added String.UTF16View.count

Added String.UTF16View.customMirror

Added String.UTF16View.customPlaygroundQuickLook

Added String.UTF16View.distance(from: String.UTF16View.Index, to: String.UTF16View.Index) -> String.UTF16View.IndexDistance

Added String.UTF16View.dropFirst() -> String.UTF16View

Added String.UTF16View.dropFirst(_: Int) -> String.UTF16View

Added String.UTF16View.dropLast() -> String.UTF16View

Added String.UTF16View.dropLast(_: Int) -> String.UTF16View

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.enumerated() -> EnumeratedSequence<String.UTF16View>

Added String.UTF16View.filter(_: (UInt16) throws -> Bool) rethrows -> [UInt16]

Added String.UTF16View.first

Added String.UTF16View.first(where: (UInt16) throws -> Bool) rethrows -> UInt16?

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.forEach(_: (UInt16) throws -> Void) rethrows

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(_: String.UTF16View.Index, offsetBy: String.UTF16View.IndexDistance) -> String.UTF16View.Index

Added String.UTF16View.index(_: String.UTF16View.Index, offsetBy: String.UTF16View.IndexDistance, limitedBy: String.UTF16View.Index) -> String.UTF16View.Index?

Added String.UTF16View.index(after: String.UTF16View.Index) -> String.UTF16View.Index

Added String.UTF16View.index(before: String.UTF16View.Index) -> 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.indices

Added String.UTF16View.isEmpty

Added String.UTF16View.last

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.makeIterator() -> IndexingIterator<String.UTF16View>

Added String.UTF16View.map<T>(_: (UInt16) throws -> T) rethrows -> [T]

Added String.UTF16View.max() -> UInt16?

Added String.UTF16View.max(by: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16?

Added String.UTF16View.min() -> UInt16?

Added String.UTF16View.min(by: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16?

Added String.UTF16View.popFirst() -> UInt16?

Added String.UTF16View.popLast() -> UInt16?

Added String.UTF16View.prefix(_: Int) -> String.UTF16View

Added String.UTF16View.prefix(through: String.UTF16View.Index) -> String.UTF16View

Added String.UTF16View.prefix(upTo: String.UTF16View.Index) -> String.UTF16View

Added String.UTF16View.reduce<Result>(_: Result, _: (Result, UInt16) throws -> Result) rethrows -> Result

Added String.UTF16View.removeFirst() -> UInt16

Added String.UTF16View.removeFirst(_: Int)

Added String.UTF16View.removeLast() -> UInt16

Added String.UTF16View.removeLast(_: Int)

Added String.UTF16View.reversed() -> ReversedCollection<String.UTF16View>

Added String.UTF16View.sorted() -> [UInt16]

Added String.UTF16View.sorted(by: (UInt16, UInt16) -> Bool) -> [UInt16]

Added String.UTF16View.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (UInt16) throws -> Bool) rethrows -> [String.UTF16View]

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.suffix(_: Int) -> String.UTF16View

Added String.UTF16View.suffix(from: String.UTF16View.Index) -> String.UTF16View

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.UTF16View.Indices [struct]

Added String.UTF16View.Indices.distance(from: String.UTF16View.Indices.Index, to: String.UTF16View.Indices.Index) -> String.UTF16View.Indices.IndexDistance

Added String.UTF16View.Indices.endIndex

Added String.UTF16View.Indices.formIndex(after: String.UTF16View.Indices.Index)

Added String.UTF16View.Indices.formIndex(before: String.UTF16View.Indices.Index)

Added String.UTF16View.Indices.index(_: String.UTF16View.Indices.Index, offsetBy: String.UTF16View.Indices.IndexDistance) -> String.UTF16View.Indices.Index

Added String.UTF16View.Indices.index(_: String.UTF16View.Indices.Index, offsetBy: String.UTF16View.Indices.IndexDistance, limitedBy: String.UTF16View.Indices.Index) -> String.UTF16View.Indices.Index?

Added String.UTF16View.Indices.index(after: String.UTF16View.Indices.Index) -> String.UTF16View.Indices.Index

Added String.UTF16View.Indices.index(before: String.UTF16View.Indices.Index) -> String.UTF16View.Indices.Index

Added String.UTF16View.Indices.indices

Added String.UTF16View.Indices.startIndex

Added String.UTF16View.Indices.subscript(_: String.UTF16View.Indices.Index) -> String.UTF16View.Indices.Index

Added String.UTF16View.Indices.subscript(_: Range<String.UTF16View.Indices.Index>) -> String.UTF16View.Indices

Added String.UTF8View.contains(_: UInt8) -> Bool

Added String.UTF8View.contains(where: (UInt8) throws -> Bool) rethrows -> Bool

Added String.UTF8View.count

Added String.UTF8View.customMirror

Added String.UTF8View.customPlaygroundQuickLook

Added String.UTF8View.distance(from: String.UTF8View.Index, to: String.UTF8View.Index) -> Int

Added String.UTF8View.dropFirst() -> String.UTF8View

Added String.UTF8View.dropFirst(_: Int) -> String.UTF8View

Added String.UTF8View.dropLast() -> String.UTF8View

Added String.UTF8View.dropLast(_: Int) -> String.UTF8View

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.enumerated() -> EnumeratedSequence<String.UTF8View>

Added String.UTF8View.filter(_: (UInt8) throws -> Bool) rethrows -> [UInt8]

Added String.UTF8View.first

Added String.UTF8View.first(where: (UInt8) throws -> Bool) rethrows -> UInt8?

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.forEach(_: (UInt8) throws -> Void) rethrows

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(after: 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.isEmpty

Added String.UTF8View.lazy

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.makeIterator() -> IndexingIterator<String.UTF8View>

Added String.UTF8View.map<T>(_: (UInt8) throws -> T) rethrows -> [T]

Added String.UTF8View.max() -> UInt8?

Added String.UTF8View.max(by: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?

Added String.UTF8View.min() -> UInt8?

Added String.UTF8View.min(by: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?

Added String.UTF8View.popFirst() -> UInt8?

Added String.UTF8View.prefix(_: Int) -> String.UTF8View

Added String.UTF8View.prefix(through: String.UTF8View.Index) -> String.UTF8View

Added String.UTF8View.prefix(upTo: String.UTF8View.Index) -> String.UTF8View

Added String.UTF8View.reduce<Result>(_: Result, _: (Result, UInt8) throws -> Result) rethrows -> Result

Added String.UTF8View.removeFirst() -> UInt8

Added String.UTF8View.removeFirst(_: Int)

Added String.UTF8View.reversed() -> [UInt8]

Added String.UTF8View.sorted() -> [UInt8]

Added String.UTF8View.sorted(by: (UInt8, UInt8) -> Bool) -> [UInt8]

Added String.UTF8View.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (UInt8) throws -> Bool) rethrows -> [String.UTF8View]

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.suffix(_: Int) -> String.UTF8View

Added String.UTF8View.suffix(from: String.UTF8View.Index) -> String.UTF8View

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 TextOutputStream

Added TextOutputStream.write(_: String)

Added TextOutputStreamable

Added TextOutputStreamable.write<Target : TextOutputStream>(to: Target)

Added UInt.advanced(by: Int) -> UInt

Added UInt.customMirror

Added UInt.customPlaygroundQuickLook

Added UInt.distance(to: UInt) -> Int

Added UInt.init(bitPattern: UnsafeRawPointer?)

Added UInt.init(bitPattern: UnsafePointer?)

Added UInt.init(bitPattern: UnsafeMutablePointer?)

Added UInt.init(bitPattern: ObjectIdentifier)

Added UInt.init(bitPattern: UnsafeMutableRawPointer?)

Added UInt.init(bitPattern: OpaquePointer?)

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.advanced(by: Int) -> UInt16

Added UInt16.customMirror

Added UInt16.customPlaygroundQuickLook

Added UInt16.distance(to: UInt16) -> Int

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.advanced(by: Int) -> UInt32

Added UInt32.customMirror

Added UInt32.customPlaygroundQuickLook

Added UInt32.distance(to: UInt32) -> Int

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.advanced(by: Int) -> UInt64

Added UInt64.customMirror

Added UInt64.customPlaygroundQuickLook

Added UInt64.distance(to: UInt64) -> Int

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.advanced(by: Int) -> UInt8

Added UInt8.customMirror

Added UInt8.customPlaygroundQuickLook

Added UInt8.distance(to: UInt8) -> Int

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 [struct]

Added UnfoldSequence.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added UnfoldSequence.dropFirst() -> AnySequence<Element>

Added UnfoldSequence.dropFirst(_: Int) -> AnySequence<Element>

Added UnfoldSequence.dropLast() -> AnySequence<Element>

Added UnfoldSequence.dropLast(_: Int) -> AnySequence<Element>

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.enumerated() -> EnumeratedSequence<UnfoldSequence<Element, State>>

Added UnfoldSequence.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added UnfoldSequence.first(where: (Element) throws -> Bool) rethrows -> Element?

Added UnfoldSequence.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Added UnfoldSequence.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]

Added UnfoldSequence.forEach(_: (Element) throws -> Void) rethrows

Added UnfoldSequence.joined() -> FlattenSequence<UnfoldSequence<Element, State>>

Added UnfoldSequence.joined(separator: String) -> String

Added UnfoldSequence.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<UnfoldSequence<Element, State>>

Added UnfoldSequence.lazy

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.makeIterator() -> UnfoldSequence<Element, State>

Added UnfoldSequence.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added UnfoldSequence.max() -> Element?

Added UnfoldSequence.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added UnfoldSequence.min() -> Element?

Added UnfoldSequence.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added UnfoldSequence.next() -> Element?

Added UnfoldSequence.prefix(_: Int) -> AnySequence<Element>

Added UnfoldSequence.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added UnfoldSequence.reversed() -> [Element]

Added UnfoldSequence.sorted() -> [Element]

Added UnfoldSequence.sorted(by: (Element, Element) -> Bool) -> [Element]

Added UnfoldSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]

Added UnfoldSequence.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]

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 UnfoldSequence.suffix(_: Int) -> AnySequence<Element>

Added UnfoldSequence.underestimatedCount

Added UnicodeCodec

Added UnicodeCodec.decode(_: I) -> UnicodeDecodingResult

Added UnicodeCodec.encode(_: UnicodeScalar, into: (Self.CodeUnit) -> Swift.Void) [class]

Added UnicodeCodec.init()

Added UnicodeDecodingResult.emptyInput

Added UnicodeDecodingResult.error

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 Unmanaged.fromOpaque(_: UnsafeRawPointer) -> Unmanaged<Instance> [static]

Added Unmanaged.toOpaque() -> UnsafeMutableRawPointer

Added UnsafeBufferPointer.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added UnsafeBufferPointer.count

Added UnsafeBufferPointer.distance(from: Int, to: Int) -> Int

Added UnsafeBufferPointer.dropFirst() -> RandomAccessSlice<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.dropFirst(_: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.dropLast() -> RandomAccessSlice<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.dropLast(_: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>

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.enumerated() -> EnumeratedSequence<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added UnsafeBufferPointer.first

Added UnsafeBufferPointer.first(where: (Element) throws -> Bool) rethrows -> Element?

Added UnsafeBufferPointer.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Added UnsafeBufferPointer.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]

Added UnsafeBufferPointer.forEach(_: (Element) throws -> Void) rethrows

Added UnsafeBufferPointer.formIndex(_: Int, offsetBy: Int)

Added UnsafeBufferPointer.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool

Added UnsafeBufferPointer.formIndex(after: Int)

Added UnsafeBufferPointer.formIndex(before: Int)

Added UnsafeBufferPointer.index(_: Int, offsetBy: Int) -> Int

Added UnsafeBufferPointer.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?

Added UnsafeBufferPointer.index(after: Int) -> Int

Added UnsafeBufferPointer.index(before: Int) -> Int

Added UnsafeBufferPointer.index(of: Element) -> Int?

Added UnsafeBufferPointer.index(where: (Element) throws -> Bool) rethrows -> Int?

Added UnsafeBufferPointer.indices

Added UnsafeBufferPointer.init(start: UnsafePointer<Element>?, count: Int)

Added UnsafeBufferPointer.isEmpty

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.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.last

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.makeIterator() -> UnsafeBufferPointerIterator<Element>

Added UnsafeBufferPointer.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added UnsafeBufferPointer.max() -> Element?

Added UnsafeBufferPointer.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added UnsafeBufferPointer.min() -> Element?

Added UnsafeBufferPointer.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added UnsafeBufferPointer.prefix(_: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.prefix(through: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.prefix(upTo: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added UnsafeBufferPointer.reversed() -> ReversedRandomAccessCollection<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.sorted() -> [Element]

Added UnsafeBufferPointer.sorted(by: (Element, Element) -> Bool) -> [Element]

Added UnsafeBufferPointer.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [RandomAccessSlice<UnsafeBufferPointer<Element>>]

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(_: CountableClosedRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.subscript(_: CountableRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.suffix(_: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>

Added UnsafeBufferPointer.suffix(from: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>>

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.contains(where: (Element) throws -> Bool) rethrows -> Bool

Added UnsafeMutableBufferPointer.count

Added UnsafeMutableBufferPointer.distance(from: Int, to: Int) -> Int

Added UnsafeMutableBufferPointer.dropFirst() -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.dropFirst(_: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.dropLast() -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.dropLast(_: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>

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.enumerated() -> EnumeratedSequence<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.filter(_: (Element) throws -> Bool) rethrows -> [Element]

Added UnsafeMutableBufferPointer.first

Added UnsafeMutableBufferPointer.first(where: (Element) throws -> Bool) rethrows -> Element?

Added UnsafeMutableBufferPointer.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]

Added UnsafeMutableBufferPointer.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Added UnsafeMutableBufferPointer.forEach(_: (Element) throws -> Void) rethrows

Added UnsafeMutableBufferPointer.formIndex(_: Int, offsetBy: Int)

Added UnsafeMutableBufferPointer.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool

Added UnsafeMutableBufferPointer.formIndex(after: Int)

Added UnsafeMutableBufferPointer.formIndex(before: Int)

Added UnsafeMutableBufferPointer.index(_: Int, offsetBy: Int) -> Int

Added UnsafeMutableBufferPointer.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?

Added UnsafeMutableBufferPointer.index(after: Int) -> Int

Added UnsafeMutableBufferPointer.index(before: Int) -> Int

Added UnsafeMutableBufferPointer.index(of: Element) -> Int?

Added UnsafeMutableBufferPointer.index(where: (Element) throws -> Bool) rethrows -> Int?

Added UnsafeMutableBufferPointer.indices

Added UnsafeMutableBufferPointer.init(start: UnsafeMutablePointer<Element>?, count: Int)

Added UnsafeMutableBufferPointer.isEmpty

Added UnsafeMutableBufferPointer.joined() -> FlattenCollection<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.joined() -> FlattenSequence<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.joined() -> FlattenBidirectionalCollection<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.joined(separator: String) -> String

Added UnsafeMutableBufferPointer.last

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.makeIterator() -> UnsafeBufferPointerIterator<Element>

Added UnsafeMutableBufferPointer.map<T>(_: (Element) throws -> T) rethrows -> [T]

Added UnsafeMutableBufferPointer.max() -> Element?

Added UnsafeMutableBufferPointer.max(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added UnsafeMutableBufferPointer.min() -> Element?

Added UnsafeMutableBufferPointer.min(by: (Element, Element) throws -> Bool) rethrows -> Element?

Added UnsafeMutableBufferPointer.partition(by: (Element) throws -> Bool) rethrows -> Int

Added UnsafeMutableBufferPointer.prefix(_: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.prefix(through: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.prefix(upTo: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result

Added UnsafeMutableBufferPointer.reversed() -> ReversedRandomAccessCollection<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.sort()

Added UnsafeMutableBufferPointer.sort(by: (Element, Element) -> Bool)

Added UnsafeMutableBufferPointer.sorted() -> [Element]

Added UnsafeMutableBufferPointer.sorted(by: (Element, Element) -> Bool) -> [Element]

Added UnsafeMutableBufferPointer.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<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(_: 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.suffix(_: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.suffix(from: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>

Added UnsafeMutableBufferPointer.underestimatedCount

Added UnsafeMutablePointer.advanced(by: Int) -> UnsafeMutablePointer<Pointee>

Added UnsafeMutablePointer.allocate(capacity: Int) -> UnsafeMutablePointer<Pointee> [static]

Added UnsafeMutablePointer.assign(from: UnsafePointer<Pointee>, count: Int)

Added UnsafeMutablePointer.customMirror

Added UnsafeMutablePointer.customPlaygroundQuickLook

Added UnsafeMutablePointer.deallocate(capacity: Int)

Added UnsafeMutablePointer.deinitialize(count: Int) -> UnsafeMutableRawPointer

Added UnsafeMutablePointer.distance(to: UnsafeMutablePointer<Pointee>) -> Int

Added UnsafeMutablePointer.init(_: UnsafeMutablePointer<Pointee>)

Added UnsafeMutablePointer.init(_: UnsafeMutablePointer<Pointee>?)

Added UnsafeMutablePointer.init(_: OpaquePointer?)

Added UnsafeMutablePointer.init(_: OpaquePointer)

Added UnsafeMutablePointer.init(mutating: UnsafePointer<Pointee>)

Added UnsafeMutablePointer.init(mutating: UnsafePointer<Pointee>?)

Added UnsafeMutablePointer.initialize<C : Collection where C.Iterator.Element == Pointee>(from: C)

Added UnsafeMutablePointer.initialize(from: UnsafePointer<Pointee>, count: Int)

Added UnsafeMutablePointer.initialize(to: Pointee, count: Int)

Added UnsafeMutablePointer.moveAssign(from: UnsafeMutablePointer<Pointee>, count: Int)

Added UnsafeMutablePointer.moveInitialize(from: UnsafeMutablePointer<Pointee>, count: Int)

Added UnsafeMutablePointer.pointee

Added UnsafeMutablePointer.withMemoryRebound<T, Result>(to: T.Type, capacity: Int, _: (UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result

Added UnsafeMutableRawPointer [struct]

Added UnsafeMutableRawPointer.advanced(by: Int) -> UnsafeMutableRawPointer

Added UnsafeMutableRawPointer.allocate(bytes: Int, alignedTo: Int) -> UnsafeMutableRawPointer [static]

Added UnsafeMutableRawPointer.assumingMemoryBound<T>(to: T.Type) -> UnsafeMutablePointer<T>

Added UnsafeMutableRawPointer.bindMemory<T>(to: T.Type, capacity: Int) -> UnsafeMutablePointer<T>

Added UnsafeMutableRawPointer.copyBytes(from: UnsafeRawPointer, count: Int)

Added UnsafeMutableRawPointer.customMirror

Added UnsafeMutableRawPointer.customPlaygroundQuickLook

Added UnsafeMutableRawPointer.deallocate(bytes: Int, alignedTo: Int)

Added UnsafeMutableRawPointer.debugDescription

Added UnsafeMutableRawPointer.distance(to: UnsafeMutableRawPointer) -> Int

Added UnsafeMutableRawPointer.hashValue

Added UnsafeMutableRawPointer.init(_: UnsafeMutableRawPointer)

Added UnsafeMutableRawPointer.init(_: UnsafeMutablePointer<T>?)

Added UnsafeMutableRawPointer.init(_: AutoreleasingUnsafeMutablePointer<T>?)

Added UnsafeMutableRawPointer.init(_: OpaquePointer?)

Added UnsafeMutableRawPointer.init(_: OpaquePointer)

Added UnsafeMutableRawPointer.init<T>(_: UnsafeMutablePointer<T>)

Added UnsafeMutableRawPointer.init(_: UnsafeMutableRawPointer?)

Added UnsafeMutableRawPointer.init<T>(_: AutoreleasingUnsafeMutablePointer<T>)

Added UnsafeMutableRawPointer.init(bitPattern: Int)

Added UnsafeMutableRawPointer.init(bitPattern: UInt)

Added UnsafeMutableRawPointer.init(mutating: UnsafeRawPointer)

Added UnsafeMutableRawPointer.init(mutating: UnsafeRawPointer?)

Added UnsafeMutableRawPointer.initializeMemory<T>(as: T.Type, at: Int, count: Int, to: T) -> UnsafeMutablePointer<T>

Added UnsafeMutableRawPointer.initializeMemory<C : Collection>(as: C.Iterator.Element.Type, from: C) -> UnsafeMutablePointer<C.Iterator.Element>

Added UnsafeMutableRawPointer.initializeMemory<T>(as: T.Type, from: UnsafePointer<T>, count: Int) -> UnsafeMutablePointer<T>

Added UnsafeMutableRawPointer.load<T>(fromByteOffset: Int, as: T.Type) -> T

Added UnsafeMutableRawPointer.moveInitializeMemory<T>(as: T.Type, from: UnsafeMutablePointer<T>, count: Int) -> UnsafeMutablePointer<T>

Added UnsafeMutableRawPointer.storeBytes<T>(of: T, toByteOffset: Int, as: T.Type)

Added UnsafePointer.advanced(by: Int) -> UnsafePointer<Pointee>

Added UnsafePointer.customMirror

Added UnsafePointer.customPlaygroundQuickLook

Added UnsafePointer.distance(to: UnsafePointer<Pointee>) -> Int

Added UnsafePointer.init(_: UnsafePointer<Pointee>)

Added UnsafePointer.init(_: UnsafePointer<Pointee>?)

Added UnsafePointer.init(_: OpaquePointer?)

Added UnsafePointer.init(_: OpaquePointer)

Added UnsafePointer.init(_: UnsafeMutablePointer<Pointee>)

Added UnsafePointer.init(_: UnsafeMutablePointer<Pointee>?)

Added UnsafePointer.pointee

Added UnsafePointer.withMemoryRebound<T, Result>(to: T.Type, capacity: Int, _: (UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result

Added UnsafeRawPointer [struct]

Added UnsafeRawPointer.advanced(by: Int) -> UnsafeRawPointer

Added UnsafeRawPointer.assumingMemoryBound<T>(to: T.Type) -> UnsafePointer<T>

Added UnsafeRawPointer.bindMemory<T>(to: T.Type, capacity: Int) -> UnsafePointer<T>

Added UnsafeRawPointer.customMirror

Added UnsafeRawPointer.customPlaygroundQuickLook

Added UnsafeRawPointer.deallocate(bytes: Int, alignedTo: Int)

Added UnsafeRawPointer.debugDescription

Added UnsafeRawPointer.distance(to: UnsafeRawPointer) -> Int

Added UnsafeRawPointer.hashValue

Added UnsafeRawPointer.init<T>(_: AutoreleasingUnsafeMutablePointer<T>)

Added UnsafeRawPointer.init(_: UnsafeMutableRawPointer)

Added UnsafeRawPointer.init(_: UnsafeRawPointer)

Added UnsafeRawPointer.init(_: OpaquePointer?)

Added UnsafeRawPointer.init<T>(_: UnsafeMutablePointer<T>)

Added UnsafeRawPointer.init<T>(_: UnsafePointer<T>)

Added UnsafeRawPointer.init(_: AutoreleasingUnsafeMutablePointer<T>?)

Added UnsafeRawPointer.init(_: UnsafeMutableRawPointer?)

Added UnsafeRawPointer.init(_: UnsafeMutablePointer<T>?)

Added UnsafeRawPointer.init(_: UnsafeRawPointer?)

Added UnsafeRawPointer.init(_: OpaquePointer)

Added UnsafeRawPointer.init(_: UnsafePointer<T>?)

Added UnsafeRawPointer.init(bitPattern: UInt)

Added UnsafeRawPointer.init(bitPattern: Int)

Added UnsafeRawPointer.load<T>(fromByteOffset: Int, as: T.Type) -> T

Added UnsignedInteger

Added UnsignedInteger.advanced(by: Int) -> Self

Added UnsignedInteger.distance(to: Self) -> Int

Added UnsignedInteger.init(_: UIntMax)

Added UnsignedInteger.toUIntMax() -> UIntMax

Added UTF16.decode(_: 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) -> UnicodeDecodingResult

Added UTF32.encode(_: UnicodeScalar, into: (UTF32.CodeUnit) -> Swift.Void) [static]

Added UTF8.decode(_: 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.dropFirst() -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>

Added Zip2Sequence.dropFirst(_: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>

Added Zip2Sequence.dropLast() -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>

Added Zip2Sequence.dropLast(_: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>

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.enumerated() -> EnumeratedSequence<Zip2Sequence<Sequence1, Sequence2>>

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.lazy

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.makeIterator() -> Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator>

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.prefix(_: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>

Added Zip2Sequence.reduce<Result>(_: Result, _: (Result, (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Result) rethrows -> Result

Added Zip2Sequence.reversed() -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)]

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 Zip2Sequence.suffix(_: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>

Added Zip2Sequence.underestimatedCount

Added !(_: Bool) -> Bool

Added !=(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool

Added !=(_: T, _: T) -> Bool

Added !=(_: [Key : Value], _: [Key : Value]) -> Bool

Added !=(_: T, _: T) -> Bool

Added !=(_: Any.Type?, _: Any.Type?) -> Bool

Added !=(_: T, _: T) -> Bool

Added %(_: T, _: T) -> T

Added %=(_: T, _: T)

Added &&(_: Bool, _: () throws -> Bool) rethrows -> Bool

Added &*(_: T, _: T) -> T

Added &+(_: T, _: T) -> T

Added &-(_: T, _: T) -> T

Added &=(_: T, _: T)

Added *(_: T, _: T) -> T

Added *=(_: T, _: T)

Added +(_: T) -> T

Added +(_: T, _: T._DisallowMixedSignArithmetic) -> T

Added +(_: C, _: S) -> C

Added +(_: String, _: String) -> String

Added +(_: T._DisallowMixedSignArithmetic, _: T) -> T

Added +(_: RRC1, _: RRC2) -> RRC1

Added +(_: T, _: T) -> T

Added +(_: S, _: C) -> C

Added +(_: T, _: T) -> T

Added +=(_: String, _: String)

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) -> 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)

Added <(_: ClosedRangeIndex<Bound>, _: ClosedRangeIndex<Bound>) -> Bool

Added <(_: String.Index, _: String.Index) -> Bool

Added <(_: AnyIndex, _: AnyIndex) -> 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 <(_: ObjectIdentifier, _: ObjectIdentifier) -> Bool

Added <(_: String, _: String) -> Bool

Added <(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool

Added <(_: T, _: T) -> Bool

Added <(_: FlattenCollectionIndex<BaseElements>, _: FlattenCollectionIndex<BaseElements>) -> Bool

Added <(_: Character, _: Character) -> Bool

Added <(_: T, _: T) -> Bool

Added <=(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool

Added <=(_: T, _: T) -> Bool

Added ==(_: Range<Bound>, _: Range<Bound>) -> Bool

Added ==(_: UnsafeMutableRawPointer, _: UnsafeMutableRawPointer) -> Bool

Added ==(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool

Added ==(_: Any.Type?, _: Any.Type?) -> Bool

Added ==(_: String.Index, _: String.Index) -> Bool

Added ==(_: [Key : Value], _: [Key : Value]) -> Bool

Added ==(_: Set<Element>, _: Set<Element>) -> Bool

Added ==(_: String.UTF8View.Index, _: String.UTF8View.Index) -> Bool

Added ==(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool

Added ==(_: Character, _: Character) -> Bool

Added ==(_: OpaquePointer, _: OpaquePointer) -> Bool

Added ==(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool

Added ==(_: ReversedIndex<Base>, _: ReversedIndex<Base>) -> Bool

Added ==(_: CountableClosedRange<Bound>, _: CountableClosedRange<Bound>) -> Bool

Added ==(_: AnyHashable, _: AnyHashable) -> Bool

Added ==(_: String, _: String) -> Bool

Added ==(_: ClosedRangeIndex<Bound>, _: ClosedRangeIndex<Bound>) -> Bool

Added ==(_: UnicodeScalar, _: UnicodeScalar) -> Bool

Added ==(_: ObjectIdentifier, _: ObjectIdentifier) -> Bool

Added ==(_: ClosedRange<Bound>, _: ClosedRange<Bound>) -> Bool

Added ==(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool

Added ==(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool

Added ==(_: UnicodeDecodingResult, _: UnicodeDecodingResult) -> Bool

Added ==(_: T, _: T) -> Bool

Added ==(_: ManagedBufferPointer<Header, Element>, _: ManagedBufferPointer<Header, Element>) -> Bool

Added ==(_: T, _: T) -> Bool

Added ==(_: EmptyCollection<Element>, _: EmptyCollection<Element>) -> Bool

Added ==(_: Bool, _: Bool) -> Bool

Added ==(_: AnyIndex, _: AnyIndex) -> 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 >(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool

Added >=(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool

Added >=(_: T, _: T) -> Bool

Added ^=(_: T, _: T)

Added abs<T : SignedNumber>(_: T) -> T

Added AnyBidirectionalCollection.Index

Added AnyBidirectionalCollection.IndexDistance

Added AnyCollection.Index

Added AnyCollection.IndexDistance

Added AnyRandomAccessCollection.Index

Added AnyRandomAccessCollection.IndexDistance

Added Array.Index

Added Array.Indices

Added Array.Iterator

Added ArrayLiteralConvertible

Added ArraySlice.Index

Added ArraySlice.Indices

Added ArraySlice.Iterator

Added BidirectionalCollection.Indices

Added BidirectionalCollection.SubSequence

Added BidirectionalSlice.Index

Added BidirectionalSlice.IndexDistance

Added BidirectionalSlice.SubSequence

Added BinaryFloatingPoint.RawExponent

Added BinaryFloatingPoint.RawSignificand

Added BooleanLiteralConvertible

Added Collection.IndexDistance

Added Collection.Indices

Added Collection.Iterator

Added Collection.SubSequence

Added CollectionOfOne.Indices

Added ContiguousArray.Index

Added ContiguousArray.Indices

Added ContiguousArray.Iterator

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 debugPrint<Target : TextOutputStream>(_: Any, separator: String, terminator: String, to: Target)

Added DefaultBidirectionalIndices.Index

Added DefaultBidirectionalIndices.Indices

Added DefaultBidirectionalIndices.SubSequence

Added DefaultIndices.Index

Added DefaultIndices.Indices

Added DefaultIndices.SubSequence

Added DefaultRandomAccessIndices.Index

Added DefaultRandomAccessIndices.Indices

Added DefaultRandomAccessIndices.SubSequence

Added DictionaryLiteral.Indices

Added DictionaryLiteralConvertible

Added Double.Exponent

Added Double.RawSignificand

Added dump<T, TargetStream : TextOutputStream>(_: T, to: TargetStream, name: String?, indent: Int, maxDepth: Int, maxItems: Int) -> T

Added EmptyCollection.IndexDistance

Added EmptyCollection.Indices

Added EmptyCollection.SubSequence

Added EnumeratedIterator.Element

Added ExpressibleByArrayLiteral.Element

Added ExpressibleByBooleanLiteral.BooleanLiteralType

Added ExpressibleByDictionaryLiteral.Key

Added ExpressibleByDictionaryLiteral.Value

Added ExpressibleByExtendedGraphemeClusterLiteral.ExtendedGraphemeClusterLiteralType

Added ExpressibleByFloatLiteral.FloatLiteralType

Added ExpressibleByIntegerLiteral.IntegerLiteralType

Added ExpressibleByStringLiteral.StringLiteralType

Added ExpressibleByUnicodeScalarLiteral.UnicodeScalarLiteralType

Added ExtendedGraphemeClusterLiteralConvertible

Added fatalError(_: () -> String, file: StaticString, line: UInt) -> Never

Added FlattenBidirectionalCollection.IndexDistance

Added FlattenCollection.IndexDistance

Added Float.Exponent

Added Float.RawSignificand

Added FloatingPoint.Exponent

Added FloatLiteralConvertible

Added getVaList(_: [CVarArg]) -> CVaListPointer

Added Indexable.IndexDistance

Added IndexableBase.Index

Added IndexableBase.SubSequence

Added IntegerLiteralConvertible

Added isKnownUniquelyReferenced<T : AnyObject>(_: T) -> Bool

Added isKnownUniquelyReferenced<T : AnyObject>(_: T?) -> Bool

Added IteratorProtocol.Element

Added LazyBidirectionalCollection.Elements

Added LazyBidirectionalCollection.Index

Added LazyCollectionProtocol.Elements

Added LazyFilterBidirectionalCollection.Index

Added LazyFilterBidirectionalCollection.IndexDistance

Added LazyFilterCollection.IndexDistance

Added LazyMapBidirectionalCollection.Index

Added LazyMapBidirectionalCollection.IndexDistance

Added LazyMapBidirectionalCollection.Indices

Added LazyMapCollection.IndexDistance

Added LazyMapCollection.Indices

Added LazyMapRandomAccessCollection.Index

Added LazyMapRandomAccessCollection.IndexDistance

Added LazyMapRandomAccessCollection.Indices

Added LazyRandomAccessCollection.Elements

Added LazyRandomAccessCollection.Index

Added LazySequenceProtocol.Elements

Added MutableBidirectionalSlice.Index

Added MutableBidirectionalSlice.IndexDistance

Added MutableBidirectionalSlice.SubSequence

Added MutableCollection.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 NilLiteralConvertible

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 OptionSet.Element

Added preconditionFailure(_: () -> String, file: StaticString, line: UInt) -> Never

Added print<Target : TextOutputStream>(_: Any, separator: String, terminator: String, to: Target)

Added RandomAccessCollection.Indices

Added RandomAccessCollection.SubSequence

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 readLine(strippingNewline: Bool) -> String?

Added Repeated.Index

Added Repeated.Indices

Added repeatElement<T>(_: T, count: Int) -> Repeated<T>

Added ReversedCollection.Index

Added ReversedCollection.IndexDistance

Added ReversedCollection.Iterator

Added ReversedRandomAccessCollection.Index

Added ReversedRandomAccessCollection.IndexDistance

Added ReversedRandomAccessCollection.Iterator

Added sequence<T>(first: T, next: (T) -> T?) -> UnfoldSequence<T, (T?, Bool)>

Added sequence<T, State>(state: State, next: (inout State) -> T?) -> UnfoldSequence<T, State>

Added Sequence.Iterator

Added Sequence.SubSequence

Added SetAlgebra.Element

Added Slice.IndexDistance

Added Slice.SubSequence

Added Streamable

Added stride<T : Strideable>(from: T, through: T, by: T.Stride) -> StrideThrough<T>

Added stride<T : Strideable>(from: T, to: T, by: T.Stride) -> StrideTo<T>

Added String.CharacterView.IndexDistance

Added String.IndexDistance

Added String.UTF16View.IndexDistance

Added String.UTF16View.Indices.Index

Added String.UTF16View.Indices.IndexDistance

Added String.UTF16View.Indices.Indices

Added String.UTF16View.Indices.SubSequence

Added String.UTF8View.IndexDistance

Added StringInterpolationConvertible

Added StringLiteralConvertible

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 UnfoldFirstSequence

Added UnicodeCodec.CodeUnit

Added UnicodeScalarLiteralConvertible

Added unsafeBitCast<T, U>(_: T, to: U.Type) -> U

Added UnsafeBufferPointer.Index

Added UnsafeBufferPointer.IndexDistance

Added UnsafeBufferPointer.Indices

Added UnsafeBufferPointer.Iterator

Added unsafeDowncast<T : AnyObject>(_: AnyObject, to: T.Type) -> T

Added UnsafeMutableBufferPointer.Index

Added UnsafeMutableBufferPointer.IndexDistance

Added UnsafeMutableBufferPointer.Indices

Added UnsafeMutableBufferPointer.Iterator

Added withUnsafeMutablePointer<T, Result>(to: T, _: (UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result

Added withUnsafePointer<T, Result>(to: T, _: (UnsafePointer<T>) throws -> Result) rethrows -> Result

Added withVaList<R>(_: [CVarArg], _: (CVaListPointer) -> R) -> R

Added zip<Sequence1 : Sequence, Sequence2 : Sequence>(_: Sequence1, _: Sequence2) -> Zip2Sequence<Sequence1, Sequence2>

Added Zip2Iterator.Element

Added Zip2Sequence.Iterator

Added |=(_: T, _: T)

Added ||(_: Bool, _: () throws -> Bool) rethrows -> Bool

Added ~=(_: ClosedRange<Bound>, _: Bound) -> Bool

Added ~=(_: CountableClosedRange<Bound>, _: Bound) -> Bool

Added ~=(_: Range<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

	Declaration	Protocols
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

Modified AnyBidirectionalCollection [struct]

	Declaration	Protocols
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

Protocols

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

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

Modified AnyBidirectionalCollection.endIndex

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

Modified AnyBidirectionalCollection.startIndex

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

Modified AnyRandomAccessCollection [struct]

	Declaration	Protocols
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

Protocols

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

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

Modified AnyRandomAccessCollection.endIndex

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

Modified AnyRandomAccessCollection.startIndex

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

Modified AnySequence [struct]

	Declaration	Protocols
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

Protocols

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

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

Modified AnySequence.dropFirst(_: Int) -> AnySequence<Element>

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

Modified AnySequence.prefix(_: Int) -> AnySequence<Element>

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

Modified Array [struct]

	Declaration	Protocols
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

Protocols

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

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

Modified Array.subscript(_: Int) -> Element

	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

Declaration

From

func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

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

Declaration

From

mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

Modified ArraySlice [struct]

	Declaration	Protocols
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

Declaration

Protocols

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

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>

Modified ArraySlice.subscript(_: Int) -> 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

Declaration

From

func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

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

Declaration

From

mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

Modified AutoreleasingUnsafeMutablePointer [struct]

	Declaration	Protocols	Generics[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, NilLiteralConvertible	Memory
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, Equatable	Pointee

Declaration

Protocols

Generics[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, NilLiteralConvertible

Memory

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, Equatable

Pointee

Modified AutoreleasingUnsafeMutablePointer.subscript(_: Int) -> Pointee

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

Modified Bool [struct]

	Declaration	Protocols
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

Declaration

Protocols

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

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

Modified Character [struct]

	Declaration	Protocols
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

Declaration

Protocols

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

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

Modified CollectionOfOne [struct]

	Declaration	Protocols
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

Protocols

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

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

Modified CollectionOfOne.endIndex

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

Modified CollectionOfOne.startIndex

	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

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
}

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
}

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

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 ContiguousArray [struct]

	Declaration	Protocols
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

Declaration

Protocols

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

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>

Modified ContiguousArray.subscript(_: Int) -> 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

Declaration

From

func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

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

mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

Modified CustomPlaygroundQuickLookable

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

Declaration

From

protocol CustomPlaygroundQuickLookable {
    @warn_unused_result
    func customPlaygroundQuickLook() -> PlaygroundQuickLook
}

protocol CustomPlaygroundQuickLookable {
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}

Modified CustomReflectable

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

Modified CVaListPointer [struct]

	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 } }

Declaration

From

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

struct CVaListPointer {
}
extension CVaListPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}

Modified Dictionary [struct]

	Declaration	Protocols
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

Declaration

Protocols

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

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]

	Declaration	Protocols
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

Declaration

Protocols

From

struct DictionaryIndex<Key : Hashable, Value> : ForwardIndexType, Comparable {
    func successor() -> DictionaryIndex<Key, Value>
}

Comparable, ForwardIndexType

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

Modified DictionaryLiteral [struct]

	Declaration	Protocols
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

Declaration

Protocols

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

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

Modified Double [struct]

	Declaration	Protocols
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

Declaration

Protocols

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

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

Modified EmptyCollection [struct]

	Declaration	Protocols
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

Protocols

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

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

Modified EmptyCollection.endIndex

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

Modified EmptyCollection.startIndex

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

Modified EmptyCollection.subscript(_: EmptyCollection.Index) -> Element

	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 }

Modified Equatable.==(_: Self, _: Self) -> Bool

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

Modified FlattenBidirectionalCollection [struct]

Declaration

Protocols

Generics[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

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]

Declaration

Protocols

Generics[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

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

Modified FlattenCollection [struct]

Declaration

Protocols

Generics[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

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]

Declaration

Protocols

Generics[Constraints]

From

struct FlattenCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType> : ForwardIndexType {
    func successor() -> FlattenCollectionIndex<BaseElements>
}

ForwardIndexType

BaseElements : CollectionType, BaseElements.Generator.Element : CollectionType

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

Modified FlattenSequence [struct]

Declaration

Protocols

Generics[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

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

Modified Float [struct]

Declaration

Protocols

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

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 }
}

Modified Float.abs(_: Float) -> Float [static]

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

Modified FloatingPointClassification [enum]

Declaration

From

enum FloatingPointClassification {
    case SignalingNaN
    case QuietNaN
    case NegativeInfinity
    case NegativeNormal
    case NegativeSubnormal
    case NegativeZero
    case PositiveZero
    case PositiveSubnormal
    case PositiveNormal
    case PositiveInfinity
}

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]

Declaration

Protocols

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

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

Declaration

Protocols

Deprecation

From

protocol Indexable {
    associatedtype Index : ForwardIndexType
    var startIndex: Self.Index { get }
    var endIndex: Self.Index { get }
    subscript (_ position: Self.Index) -> Self._Element { get }
}

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
}

IndexableBase

tvOS 10.0

Modified Int [struct]

Declaration

Protocols

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

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

Modified Int16 [struct]

Declaration

Protocols

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

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

Modified Int32 [struct]

Declaration

Protocols

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

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

Modified Int64 [struct]

Declaration

Protocols

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

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]

Declaration

Protocols

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

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

Modified LazyCollection [struct]

Declaration

Protocols

Generics[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

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 }

Modified LazyCollection.subscript(_: Range<Base.Index>) -> LazyCollection<Slice<Base>>

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

Modified LazyFilterCollection [struct]

Declaration

Protocols

Generics[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

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]

Declaration

Protocols

Generics[Constraints]

Generics[Parameters]

From

struct LazyFilterIndex<BaseElements : CollectionType> : ForwardIndexType {
    func successor() -> LazyFilterIndex<BaseElements>
    let base: BaseElements.Index
    typealias Base = BaseElements
}

ForwardIndexType

BaseElements : CollectionType

BaseElements

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

Modified LazyFilterSequence [struct]

Declaration

Protocols

Generics[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

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

Modified LazyMapCollection [struct]

Declaration

Protocols

Generics[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

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

Modified LazyMapCollection.subscript(_: Base.Index) -> Element

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

Modified LazyMapSequence [struct]

Declaration

Protocols

Generics[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

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

Modified LazySequence [struct]

Declaration

Protocols

Generics[Constraints]

From

struct LazySequence<Base : SequenceType> : LazySequenceType, _SequenceWrapperType {
    init(_ base: Base)
    var elements: Base { get }
    typealias S = Void
}

LazySequenceType

Base : SequenceType

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

Declaration

Superclasses

Generics[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
}

ManagedProtoBuffer

Value, Element

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

Modified ManagedBufferPointer [struct]

Declaration

Generics[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

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

Modified Mirror [struct]

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
}

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 }
}

Modified Mirror.children

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

Modified Mirror.init<Subject>(_: Subject, children: DictionaryLiteral<String, Any>, displayStyle: Mirror.DisplayStyle?, ancestorRepresentation: Mirror.AncestorRepresentation)

Declaration

Generics[Parameters]

From

init<T>(_ subject: T, children children: DictionaryLiteral<String, Any>, 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)

Subject

Modified Mirror.AncestorRepresentation [enum]

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

Modified Mirror.DisplayStyle [enum]

Declaration

From

enum DisplayStyle {
        case Struct
        case Class
        case Enum
        case Tuple
        case Optional
        case Collection
        case Dictionary
        case Set
    }

enum DisplayStyle {
        case `struct`
        case `class`
        case `enum`
        case tuple
        case optional
        case collection
        case dictionary
        case set
    }

Modified MutableIndexable

Declaration

Protocols

Deprecation

From

protocol MutableIndexable {
    associatedtype Index : ForwardIndexType
    var startIndex: Self.Index { get }
    var endIndex: Self.Index { get }
    subscript (_ position: Self.Index) -> Self._Element { get set }
}

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)
}

Indexable

tvOS 10.0

Modified MutableIndexable.endIndex

	Deprecation
From	--
To	tvOS 10.0

Modified MutableIndexable.startIndex

	Deprecation
From	--
To	tvOS 10.0

Modified MutableIndexable.subscript(_: Self.Index) -> Self._Element

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

Modified MutableSlice [struct]

Declaration

Protocols

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

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
From	tvOS 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

Modified ObjectIdentifier [struct]

Declaration

Protocols

From

struct ObjectIdentifier : Hashable, Comparable {
    var uintValue: UInt { get }
    var hashValue: Int { get }
    init(_ x: AnyObject)
    init(_ x: Any.Type)
}

Comparable, Hashable

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

Modified Optional [enum]

Declaration

Protocols

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

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

Modified Optional.flatMap(_: (Wrapped) throws -> U?) rethrows -> U?

	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?

Modified Optional.map(_: (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?

Modified PlaygroundQuickLook [enum]

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)
}

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)
}

Modified Range [struct]

Declaration

Protocols

Generics[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

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]

Declaration

Protocols

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

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

Modified Set.contains(_: Element) -> Bool

	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]

Declaration

Protocols

From

struct SetIndex<Element : Hashable> : ForwardIndexType, Comparable {
    typealias T = Element
    func successor() -> SetIndex<Element>
}

Comparable, ForwardIndexType

struct SetIndex<Element : Hashable> : Comparable {
    static func ==(_ lhs: SetIndex<Element>, _ rhs: SetIndex<Element>) -> Bool
    static func <(_ lhs: SetIndex<Element>, _ rhs: SetIndex<Element>) -> Bool
}

Comparable

Modified Slice [struct]

Declaration

Protocols

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

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

Modified Slice.endIndex

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

Modified Slice.init(base: Base, bounds: Range<Base.Index>)

	Deprecation
From	tvOS 9.2
To	--

Modified Slice.startIndex

	Declaration	Readonly
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 }

Modified StaticString [struct]

Declaration

Protocols

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

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

Modified StaticString.withUTF8Buffer<R>(_: (UnsafeBufferPointer<UInt8>) -> R) -> R

	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
}

protocol Strideable : Comparable {
    associatedtype Stride : SignedNumber
    func distance(to other: Self) -> Self.Stride
    func advanced(by n: Self.Stride) -> Self
}

Modified StrideThrough [struct]

Declaration

Protocols

From

struct StrideThrough<Element : Strideable> : SequenceType {
    typealias T = Element
    func generate() -> StrideThroughGenerator<Element>
}
extension StrideThrough : _Reflectable {
}

SequenceType

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

Modified StrideTo [struct]

Declaration

Protocols

From

struct StrideTo<Element : Strideable> : SequenceType {
    typealias T = Element
    func generate() -> StrideToGenerator<Element>
}
extension StrideTo : _Reflectable {
}

SequenceType

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

Modified String [struct]

Declaration

Protocols

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

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

Modified String.characters

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

Modified String.endIndex

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

Modified String.init<Subject>(reflecting: Subject)

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

Modified String.startIndex

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

Modified String.subscript(_: String.Index) -> Character

	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

	Declaration	Readonly
From	var utf16: String.UTF16View { get }	yes
To	var utf16: String.UTF16View	--

Modified String.utf8

	Declaration	Readonly
From	var utf8: String.UTF8View { get }	yes
To	var utf8: String.UTF8View	--

Modified String.withCString<Result>(_: (UnsafePointer<Int8>) throws -> Result) rethrows -> Result

	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]

Declaration

Protocols

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

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]

Declaration

Protocols

From

struct Index : BidirectionalIndexType, Comparable, _Reflectable {
        func successor() -> String.CharacterView.Index
        func predecessor() -> String.CharacterView.Index
    }

BidirectionalIndexType, Comparable

struct Index : Comparable, CustomPlaygroundQuickLookable {
        var customPlaygroundQuickLook: PlaygroundQuickLook { get }
    }

Comparable, CustomPlaygroundQuickLookable

Modified String.UnicodeScalarView [struct]

Declaration

Protocols

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

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

Modified String.UnicodeScalarView.subscript(_: String.UnicodeScalarView.Index) -> UnicodeScalar

	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]

Declaration

Protocols

From

struct Index : BidirectionalIndexType, Comparable {
            @warn_unused_result
            func successor() -> String.UnicodeScalarView.Index
            @warn_unused_result
            func predecessor() -> String.UnicodeScalarView.Index
        }

BidirectionalIndexType, Comparable

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

Modified String.UTF16View [struct]

Declaration

Protocols

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

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

Modified String.UTF16View.subscript(_: String.UTF16View.Index) -> UTF16.CodeUnit

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

Modified String.UTF16View.subscript(_: Range<String.UTF16View.Index>) -> String.UTF16View

	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]

Declaration

Protocols

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

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)

Modified String.UTF8View [struct]

Declaration

Protocols

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

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 }

Modified String.UTF8View.subscript(_: String.UTF8View.Index) -> UTF8.CodeUnit

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

Modified String.UTF8View.Index [struct]

Declaration

Protocols

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

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]

Declaration

Protocols

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

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

Modified UInt16 [struct]

Declaration

Protocols

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

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

Modified UInt32 [struct]

Declaration

Protocols

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

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

Modified UInt64 [struct]

Declaration

Protocols

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

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

Modified UInt8 [struct]

Declaration

Protocols

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

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

Modified UnicodeDecodingResult [enum]

Declaration

Protocols

From

enum UnicodeDecodingResult {
    case Result(UnicodeScalar)
    case EmptyInput
    case Error
    @warn_unused_result
    func isEmptyInput() -> Bool
}

enum UnicodeDecodingResult : Equatable {
    case scalarValue(UnicodeScalar)
    case emptyInput
    case error
    static func ==(_ lhs: UnicodeDecodingResult, _ rhs: UnicodeDecodingResult) -> Bool
}

Equatable

Modified UnicodeScalar [struct]

Declaration

Protocols

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

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)

Modified Unmanaged [struct]

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>
}

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
}

Modified Unmanaged.autorelease() -> Unmanaged<Instance>

	Deprecation
From	tvOS 9.2
To	--

Modified Unmanaged.passRetained(_: Instance) -> Unmanaged<Instance> [static]

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

Modified Unmanaged.passUnretained(_: Instance) -> Unmanaged<Instance> [static]

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

Modified Unmanaged.retain() -> Unmanaged<Instance>

	Deprecation
From	tvOS 9.2
To	--

Modified Unmanaged.takeRetainedValue() -> Instance

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

Modified Unmanaged.takeUnretainedValue() -> Instance

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

Modified UnsafeBufferPointer [struct]

Declaration

Protocols

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

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

Modified UnsafeBufferPointer.baseAddress

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

Modified UnsafeBufferPointer.subscript(_: Int) -> Element

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

Modified UnsafeMutableBufferPointer [struct]

Declaration

Protocols

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

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

Modified UnsafeMutableBufferPointer.baseAddress

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

Modified UnsafeMutableBufferPointer.subscript(_: Int) -> Element

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

Modified UnsafeMutablePointer [struct]

Declaration

Protocols

Generics[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, RandomAccessIndexType

Memory

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, Strideable

Pointee

Modified UnsafeMutablePointer.init(bitPattern: UInt)

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

Modified UnsafeMutablePointer.init(bitPattern: Int)

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

Modified UnsafeMutablePointer.move() -> Pointee

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

Modified UnsafeMutablePointer.predecessor() -> UnsafeMutablePointer<Pointee>

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

Modified UnsafeMutablePointer.subscript(_: Int) -> Pointee

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

Modified UnsafeMutablePointer.successor() -> UnsafeMutablePointer<Pointee>

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

Modified UnsafePointer [struct]

Declaration

Protocols

Generics[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, RandomAccessIndexType

Memory

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, Strideable

Pointee

Modified UnsafePointer.init(bitPattern: UInt)

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

Modified UnsafePointer.init(bitPattern: Int)

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

Modified UnsafePointer.predecessor() -> UnsafePointer<Pointee>

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

Modified UnsafePointer.subscript(_: Int) -> Pointee

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

Modified UnsafePointer.successor() -> UnsafePointer<Pointee>

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

Modified UTF16 [struct]

Declaration

Protocols

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

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]

Declaration

Protocols

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

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]

Declaration

Protocols

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

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

Modified Zip2Sequence [struct]

Declaration

Protocols

Generics[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

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

Modified !=(_: (A, B, C, D, E), _: (A, B, C, D, E)) -> 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

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

func !=<Element : Equatable>(_ lhs: ContiguousArray<Element>, _ rhs: ContiguousArray<Element>) -> Bool

Modified !=(_: (A, B, C, D, E, F), _: (A, B, C, D, E, F)) -> 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

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 !=(_: (A, B, C, D), _: (A, B, C, D)) -> 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

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

Modified !=(_: (A, B), _: (A, B)) -> 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

func !=<Element : Equatable>(_ lhs: ArraySlice<Element>, _ rhs: ArraySlice<Element>) -> Bool

Modified !=(_: (A, B, C), _: (A, B, C)) -> Bool

Declaration

From

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

func !=<A : Equatable, B : Equatable, C : Equatable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Modified !==(_: AnyObject?, _: AnyObject?) -> 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>

Declaration

Generics[Parameters]

From

@warn_unused_result
func +<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: Int) -> UnsafeMutablePointer<Memory>

Memory

func +<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: Int) -> UnsafeMutablePointer<Pointee>

Pointee

Modified +(_: Int, _: UnsafePointer<Pointee>) -> UnsafePointer<Pointee>

	Declaration	Generics[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>

Declaration

Generics[Parameters]

From

@warn_unused_result
func +<Memory>(_ lhs: Int, _ rhs: UnsafeMutablePointer<Memory>) -> UnsafeMutablePointer<Memory>

Memory

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>

	Declaration	Generics[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)

	Declaration	Generics[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)

	Declaration	Generics[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>

Declaration

Generics[Parameters]

From

@warn_unused_result
func -<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: Int) -> UnsafeMutablePointer<Memory>

Memory

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

Declaration

Generics[Parameters]

From

@warn_unused_result
func -<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: UnsafeMutablePointer<Memory>) -> Int

Memory

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

	Declaration	Generics[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>

	Declaration	Generics[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)

	Declaration	Generics[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)

	Declaration	Generics[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)

Modified <(_: (A, B, C), _: (A, B, C)) -> Bool

Declaration

From

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

func <<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Modified <(_: UnsafePointer<Pointee>, _: UnsafePointer<Pointee>) -> Bool

	Declaration	Generics[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 <(_: (A, B, C, D, E), _: (A, B, C, D, E)) -> 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

func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool

Modified <(_: (A, B), _: (A, B)) -> 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

Declaration

Generics[Parameters]

From

@warn_unused_result
func <<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: UnsafeMutablePointer<Memory>) -> Bool

Memory

func <<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: UnsafeMutablePointer<Pointee>) -> Bool

Pointee

Modified <(_: (A, B, C, D, E, F), _: (A, B, C, D, E, F)) -> 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

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

Modified <(_: (A, B, C, D), _: (A, B, C, D)) -> 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

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)

Modified <=(_: (A, B, C, D, E), _: (A, B, C, D, E)) -> 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

func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool

Modified <=(_: (A, B, C), _: (A, B, C)) -> Bool

Declaration

From

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

func <=<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Modified <=(_: (A, B, C, D, E, F), _: (A, B, C, D, E, F)) -> 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

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

Modified <=(_: (A, B, C, D), _: (A, B, C, D)) -> 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

func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool

Modified <=(_: (A, B), _: (A, B)) -> 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

Modified ==(_: (A, B, C, D, E), _: (A, B, C, D, E)) -> 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

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

Declaration

Generics[Parameters]

From

@warn_unused_result
func ==<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: UnsafeMutablePointer<Memory>) -> Bool

Memory

func ==<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: UnsafeMutablePointer<Pointee>) -> Bool

Pointee

Modified ==(_: UnsafePointer<Pointee>, _: UnsafePointer<Pointee>) -> Bool

	Declaration	Generics[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

func ==<Element : Equatable>(_ lhs: ArraySlice<Element>, _ rhs: ArraySlice<Element>) -> Bool

Modified ==(_: AutoreleasingUnsafeMutablePointer<Pointee>, _: AutoreleasingUnsafeMutablePointer<Pointee>) -> Bool

Declaration

Generics[Parameters]

From

@warn_unused_result
func ==<Memory>(_ lhs: AutoreleasingUnsafeMutablePointer<Memory>, _ rhs: AutoreleasingUnsafeMutablePointer<Memory>) -> Bool

Memory

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

Modified ==(_: (A, B), _: (A, B)) -> 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

func ==<Element : Equatable>(_ lhs: ContiguousArray<Element>, _ rhs: ContiguousArray<Element>) -> Bool

Modified ==(_: (A, B, C, D, E, F), _: (A, B, C, D, E, F)) -> 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

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

func ==<Value, Element>(_ lhs: _HeapBuffer<Value, Element>, _ rhs: _HeapBuffer<Value, Element>) -> Bool

Modified ==(_: (A, B, C, D), _: (A, B, C, D)) -> 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

func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool

Modified ==(_: (A, B, C), _: (A, B, C)) -> Bool

Declaration

From

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

func ==<A : Equatable, B : Equatable, C : Equatable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Modified ===(_: AnyObject?, _: AnyObject?) -> Bool

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

Modified >(_: (A, B, C, D, E), _: (A, B, C, D, E)) -> 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

func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool

Modified >(_: (A, B, C, D, E, F), _: (A, B, C, D, E, F)) -> 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

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

Modified >(_: (A, B, C, D), _: (A, B, C, D)) -> 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

func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool

Modified >(_: (A, B, C), _: (A, B, C)) -> Bool

Declaration

From

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

func ><A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Modified >(_: (A, B), _: (A, B)) -> 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 >=(_: (A, B, C, D, E, F), _: (A, B, C, D, E, F)) -> 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

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

Modified >=(_: (A, B, C), _: (A, B, C)) -> Bool

Declaration

From

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

func >=<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool

Modified >=(_: (A, B), _: (A, B)) -> 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 >=(_: (A, B, C, D, E), _: (A, B, C, D, E)) -> 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

func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool

Modified >=(_: (A, B, C, D), _: (A, B, C, D)) -> 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

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)

Modified ??(_: T?, _: () 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 ??(_: T?, _: () 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)

Modified assert(_: () -> Bool, _: () -> String, file: StaticString, line: UInt)

Declaration

From

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

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

Modified assertionFailure(_: () -> String, file: StaticString, line: UInt)

Declaration

From

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

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

Modified CollectionOfOne.Index

	Declaration
From	typealias Index = Bit
To	typealias Index = Int

Modified Dictionary.Element

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

Modified DictionaryLiteral.Element

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

Modified max<T : Comparable>(_: T, _: T) -> T

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

Modified max<T : Comparable>(_: T, _: T, _: T, _: 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

Modified min<T : Comparable>(_: T, _: 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

Modified min<T : Comparable>(_: T, _: T, _: T, _: 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

Modified Mirror.Children

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

Modified MutableIndexable.Index

	Declaration
From	associatedtype Index : ForwardIndexType
To	associatedtype Index : Comparable

Modified precondition(_: () -> Bool, _: () -> String, file: StaticString, line: UInt)

Declaration

From

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

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

Modified Strideable.Stride

	Declaration
From	associatedtype Stride : SignedNumberType
To	associatedtype Stride : SignedNumber

Modified swap<T>(_: T, _: T)

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

Modified withExtendedLifetime<T, Result>(_: T, _: () throws -> Result) rethrows -> Result

	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

Modified withExtendedLifetime<T, Result>(_: T, _: (T) 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

Modified Zip2Sequence.Stream1

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

Modified Zip2Sequence.Stream2

	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

Modified ~=(_: T, _: T) -> Bool

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