Swift Changes for Swift
Swift
Removed _Incrementable.successor() -> Self
Removed AnyBidirectionalCollection.generate() -> AnyGenerator<Element>
Removed AnyBidirectionalCollection.init(_: AnyForwardCollection<Element>)
Removed AnyBidirectionalCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
Removed AnyBidirectionalCollection.init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_: C)
Removed AnyBidirectionalCollection.subscript(_: AnyBidirectionalIndex) -> Element
Removed AnyBidirectionalCollection.underestimateCount() -> Int
Removed AnyBidirectionalIndex [struct]
Removed AnyBidirectionalIndex.init<BaseIndex : BidirectionalIndexType>(_: BaseIndex)
Removed AnyBidirectionalIndex.predecessor() -> AnyBidirectionalIndex
Removed AnyBidirectionalIndex.successor() -> AnyBidirectionalIndex
Removed AnyCollectionType
Removed AnyForwardCollection [struct]
Removed AnyForwardCollection.count
Removed AnyForwardCollection.endIndex
Removed AnyForwardCollection.generate() -> AnyGenerator<Element>
Removed AnyForwardCollection.init(_: AnyRandomAccessCollection<Element>)
Removed AnyForwardCollection.init(_: AnyForwardCollection<Element>)
Removed AnyForwardCollection.init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_: C)
Removed AnyForwardCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
Removed AnyForwardCollection.init<C : CollectionType where C.Index : ForwardIndexType, C.Generator.Element == Element>(_: C)
Removed AnyForwardCollection.init(_: AnyBidirectionalCollection<Element>)
Removed AnyForwardCollection.startIndex
Removed AnyForwardCollection.subscript(_: AnyForwardIndex) -> Element
Removed AnyForwardCollection.underestimateCount() -> Int
Removed AnyForwardIndex [struct]
Removed AnyForwardIndex.init<BaseIndex : ForwardIndexType>(_: BaseIndex)
Removed AnyForwardIndex.successor() -> AnyForwardIndex
Removed AnyGenerator [struct]
Removed AnyGenerator.init<G : GeneratorType where G.Element == Element>(_: G)
Removed AnyGenerator.init(body: () -> Element?)
Removed AnyGenerator.next() -> Element?
Removed AnyRandomAccessCollection.generate() -> AnyGenerator<Element>
Removed AnyRandomAccessCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
Removed AnyRandomAccessCollection.init(_: AnyForwardCollection<Element>)
Removed AnyRandomAccessCollection.subscript(_: AnyRandomAccessIndex) -> Element
Removed AnyRandomAccessCollection.underestimateCount() -> Int
Removed AnyRandomAccessIndex [struct]
Removed AnyRandomAccessIndex.advancedBy(_: Distance) -> AnyRandomAccessIndex
Removed AnyRandomAccessIndex.advancedBy(_: Distance, limit: AnyRandomAccessIndex) -> AnyRandomAccessIndex
Removed AnyRandomAccessIndex.distanceTo(_: AnyRandomAccessIndex) -> Distance
Removed AnyRandomAccessIndex.init<BaseIndex : RandomAccessIndexType>(_: BaseIndex)
Removed AnyRandomAccessIndex.predecessor() -> AnyRandomAccessIndex
Removed AnyRandomAccessIndex.successor() -> AnyRandomAccessIndex
Removed AnySequence.generate() -> AnyGenerator<Element>
Removed AnySequence.init<G : GeneratorType where G.Element == Element>(_: () -> G)
Removed AnySequence.init<S : SequenceType where S.Generator.Element == Element, S.SubSequence : SequenceType, S.SubSequence.Generator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_: S)
Removed AnySequence.underestimateCount() -> Int
Removed Array.appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_: C)
Removed Array.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed Array.init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_: S)
Removed Array.init(count: Int, repeatedValue: Element)
Removed Array.insert(_: Element, atIndex: Int)
Removed Array.removeAll(keepCapacity: Bool)
Removed Array.removeAtIndex(_: Int) -> Element
Removed Array.removeLast() -> Element
Removed Array.replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Removed ArrayLiteralConvertible
Removed ArrayLiteralConvertible.init(arrayLiteral: Self.Element)
Removed ArraySlice.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed ArraySlice.appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_: C)
Removed ArraySlice.init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_: S)
Removed ArraySlice.init(count: Int, repeatedValue: Element)
Removed ArraySlice.insert(_: Element, atIndex: Int)
Removed ArraySlice.removeAll(keepCapacity: Bool)
Removed ArraySlice.removeAtIndex(_: Int) -> Element
Removed ArraySlice.removeLast() -> Element
Removed ArraySlice.replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Removed AutoreleasingUnsafeMutablePointer.init()
Removed AutoreleasingUnsafeMutablePointer.init(nilLiteral: ())
Removed AutoreleasingUnsafeMutablePointer.memory
Removed BidirectionalIndexType
Removed BidirectionalIndexType.advancedBy(_: Self.Distance) -> Self
Removed BidirectionalIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed BidirectionalIndexType.predecessor() -> Self
Removed BidirectionalIndexType.predecessor() -> Self
Removed BidirectionalIndexType.successor() -> Self
Removed Bit [enum]
Removed Bit.addWithOverflow(_: Bit, _: Bit) -> (Bit, overflow: Bool) [static]
Removed Bit.advancedBy(_: Distance) -> Bit
Removed Bit.distanceTo(_: Bit) -> Int
Removed Bit.divideWithOverflow(_: Bit, _: Bit) -> (Bit, overflow: Bool) [static]
Removed Bit.multiplyWithOverflow(_: Bit, _: Bit) -> (Bit, overflow: Bool) [static]
Removed Bit.One
Removed Bit.predecessor() -> Bit
Removed Bit.remainderWithOverflow(_: Bit, _: Bit) -> (Bit, overflow: Bool) [static]
Removed Bit.subtractWithOverflow(_: Bit, _: Bit) -> (Bit, overflow: Bool) [static]
Removed Bit.successor() -> Bit
Removed Bit.toIntMax() -> IntMax
Removed Bit.Zero
Removed BitwiseOperationsType
Removed BitwiseOperationsType.&(_: Self, _: Self) -> Self
Removed BitwiseOperationsType.^(_: Self, _: Self) -> Self
Removed BitwiseOperationsType.allZeros
Removed BitwiseOperationsType.|(_: Self, _: Self) -> Self
Removed BitwiseOperationsType.~(_: Self) -> Self
Removed Bool.boolValue
Removed Bool.init<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 CollectionType
Removed CollectionType.count
Removed CollectionType.count
Removed CollectionType.dropFirst(_: Int) -> Self.SubSequence
Removed CollectionType.dropLast(_: Int) -> Self.SubSequence
Removed CollectionType.dropLast(_: Int) -> Self.SubSequence
Removed CollectionType.endIndex
Removed CollectionType.filter(_: (Self.Base.Generator.Element) -> Bool) -> [Self.Base.Generator.Element]
Removed CollectionType.first
Removed CollectionType.first
Removed CollectionType.flatten() -> FlattenCollection<Self>
Removed CollectionType.flatten() -> FlattenBidirectionalCollection<Self>
Removed CollectionType.generate() -> Self.Generator
Removed CollectionType.generate() -> IndexingGenerator<Self>
Removed CollectionType.indexOf(_: (Self.Generator.Element) throws -> Bool) rethrows -> Self.Index?
Removed CollectionType.indexOf(_: Self.Generator.Element) -> Self.Index?
Removed CollectionType.indices
Removed CollectionType.isEmpty
Removed CollectionType.isEmpty
Removed CollectionType.last
Removed CollectionType.lazy
Removed CollectionType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed CollectionType.map<T>(_: (Self.Base.Generator.Element) -> T) -> [T]
Removed CollectionType.popFirst() -> Self.Generator.Element?
Removed CollectionType.popLast() -> Self.Generator.Element?
Removed CollectionType.popLast() -> Self.Generator.Element?
Removed CollectionType.prefix(_: Int) -> Self.SubSequence
Removed CollectionType.prefixThrough(_: Self.Index) -> Self.SubSequence
Removed CollectionType.prefixThrough(_: Self.Index) -> Self.SubSequence
Removed CollectionType.prefixUpTo(_: Self.Index) -> Self.SubSequence
Removed CollectionType.prefixUpTo(_: Self.Index) -> Self.SubSequence
Removed CollectionType.removeFirst() -> Self.Generator.Element
Removed CollectionType.removeFirst(_: Int)
Removed CollectionType.removeLast() -> Self.Generator.Element
Removed CollectionType.removeLast(_: Int)
Removed CollectionType.reverse() -> ReverseRandomAccessCollection<Self>
Removed CollectionType.reverse() -> ReverseCollection<Self>
Removed CollectionType.split(_: Int, allowEmptySlices: Bool, isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Removed CollectionType.split(_: Self.Generator.Element, maxSplit: Int, allowEmptySlices: Bool) -> [Self.SubSequence]
Removed CollectionType.startIndex
Removed CollectionType.startIndex
Removed CollectionType.subscript(_: Range<Self.Index>) -> Self.SubSequence
Removed CollectionType.subscript(_: Self.Index) -> Self.Generator.Element
Removed CollectionType.subscript(_: Self.Index) -> Self.Base.Generator.Element
Removed CollectionType.subscript(_: Range<Self.Index>) -> Slice<Self>
Removed CollectionType.suffix(_: Int) -> Self.SubSequence
Removed CollectionType.suffix(_: Int) -> Self.SubSequence
Removed CollectionType.suffixFrom(_: Self.Index) -> Self.SubSequence
Removed CollectionType.suffixFrom(_: Self.Index) -> Self.SubSequence
Removed CollectionType.underestimateCount() -> Int
Removed ContiguousArray.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed ContiguousArray.appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_: C)
Removed ContiguousArray.init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_: S)
Removed ContiguousArray.init(count: Int, repeatedValue: Element)
Removed ContiguousArray.insert(_: Element, atIndex: Int)
Removed ContiguousArray.removeAll(keepCapacity: Bool)
Removed ContiguousArray.removeAtIndex(_: Int) -> Element
Removed ContiguousArray.removeLast() -> Element
Removed ContiguousArray.replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Removed COpaquePointer [struct]
Removed COpaquePointer.debugDescription
Removed COpaquePointer.hashValue
Removed COpaquePointer.init()
Removed COpaquePointer.init<T>(_: UnsafeMutablePointer<T>)
Removed COpaquePointer.init<T>(_: UnsafePointer<T>)
Removed COpaquePointer.init(bitPattern: Int)
Removed COpaquePointer.init(bitPattern: UInt)
Removed COpaquePointer.init(nilLiteral: ())
Removed CustomPlaygroundQuickLookable.customPlaygroundQuickLook() -> PlaygroundQuickLook
Removed CustomReflectable.customMirror() -> Mirror
Removed CVaListPointer.init(_fromUnsafeMutablePointer: UnsafeMutablePointer<Void>)
Removed CVarArgType
Removed Dictionary.generate() -> DictionaryGenerator<Key, Value>
Removed Dictionary.indexForKey(_: Key) -> DictionaryIndex<Key, Value>?
Removed Dictionary.removeAll(keepCapacity: Bool)
Removed Dictionary.removeAtIndex(_: DictionaryIndex<Key, Value>) -> (Key, Value)
Removed Dictionary.removeValueForKey(_: Key) -> Value?
Removed Dictionary.subscript(_: DictionaryIndex<Key, Value>) -> (Key, Value)
Removed DictionaryGenerator [struct]
Removed DictionaryGenerator.next() -> (Key, Value)?
Removed DictionaryIndex.successor() -> DictionaryIndex<Key, Value>
Removed DictionaryLiteralConvertible
Removed DictionaryLiteralConvertible.init(dictionaryLiteral: (Self.Key, Self.Value))
Removed Double.advancedBy(_: Double) -> Double
Removed Double.distanceTo(_: Double) -> Double
Removed Double.floatingPointClass
Removed Double.init(_bits: Builtin.FPIEEE64)
Removed Double.init(_builtinFloatLiteral: Builtin.FPIEEE64)
Removed Double.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Double.isSignaling
Removed Double.isSignMinus
Removed Double.NaN
Removed Double.quietNaN
Removed EmptyCollection.generate() -> EmptyGenerator<Element>
Removed EmptyGenerator [struct]
Removed EmptyGenerator.init()
Removed EmptyGenerator.next() -> Element?
Removed EnumerateGenerator [struct]
Removed EnumerateGenerator.init(_: Base)
Removed EnumerateGenerator.next() -> (index: Int, element: Base.Element)?
Removed EnumerateSequence [struct]
Removed EnumerateSequence.generate() -> EnumerateGenerator<Base.Generator>
Removed EnumerateSequence.init(_: Base)
Removed ErrorType
Removed ExtendedGraphemeClusterLiteralConvertible
Removed ExtendedGraphemeClusterLiteralConvertible.init(extendedGraphemeClusterLiteral: Self.ExtendedGraphemeClusterLiteralType)
Removed FlattenBidirectionalCollection.generate() -> FlattenGenerator<Base.Generator>
Removed FlattenBidirectionalCollection.subscript(_: FlattenBidirectionalCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element
Removed FlattenBidirectionalCollection.underestimateCount() -> Int
Removed FlattenBidirectionalCollectionIndex.predecessor() -> FlattenBidirectionalCollectionIndex<BaseElements>
Removed FlattenBidirectionalCollectionIndex.successor() -> FlattenBidirectionalCollectionIndex<BaseElements>
Removed FlattenCollection.generate() -> FlattenGenerator<Base.Generator>
Removed FlattenCollection.subscript(_: FlattenCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element
Removed FlattenCollection.underestimateCount() -> Int
Removed FlattenCollectionIndex.successor() -> FlattenCollectionIndex<BaseElements>
Removed FlattenGenerator [struct]
Removed FlattenGenerator.init(_: Base)
Removed FlattenGenerator.next() -> Base.Element.Generator.Element?
Removed FlattenSequence.generate() -> FlattenGenerator<Base.Generator>
Removed FlattenSequence.init(_: Base)
Removed Float.advancedBy(_: Float) -> Float
Removed Float.distanceTo(_: Float) -> Float
Removed Float.floatingPointClass
Removed Float.init(_bits: Builtin.FPIEEE32)
Removed Float.init(_builtinFloatLiteral: Builtin.FPIEEE64)
Removed Float.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Float.isSignaling
Removed Float.isSignMinus
Removed Float.NaN
Removed Float.quietNaN
Removed FloatingPointClassification.NegativeInfinity
Removed FloatingPointClassification.NegativeNormal
Removed FloatingPointClassification.NegativeSubnormal
Removed FloatingPointClassification.NegativeZero
Removed FloatingPointClassification.PositiveInfinity
Removed FloatingPointClassification.PositiveNormal
Removed FloatingPointClassification.PositiveSubnormal
Removed FloatingPointClassification.PositiveZero
Removed FloatingPointClassification.QuietNaN
Removed FloatingPointClassification.SignalingNaN
Removed FloatingPointType
Removed FloatingPointType.floatingPointClass
Removed FloatingPointType.infinity
Removed FloatingPointType.init(_: Int)
Removed FloatingPointType.init(_: Int8)
Removed FloatingPointType.init(_: UInt8)
Removed FloatingPointType.init(_: UInt)
Removed FloatingPointType.init(_: Int16)
Removed FloatingPointType.init(_: Int32)
Removed FloatingPointType.init(_: UInt64)
Removed FloatingPointType.init(_: Int64)
Removed FloatingPointType.init(_: UInt32)
Removed FloatingPointType.init(_: UInt16)
Removed FloatingPointType.isFinite
Removed FloatingPointType.isInfinite
Removed FloatingPointType.isNaN
Removed FloatingPointType.isNormal
Removed FloatingPointType.isSignaling
Removed FloatingPointType.isSignMinus
Removed FloatingPointType.isSubnormal
Removed FloatingPointType.isZero
Removed FloatingPointType.NaN
Removed FloatingPointType.quietNaN
Removed FloatLiteralConvertible
Removed FloatLiteralConvertible.init(floatLiteral: Self.FloatLiteralType)
Removed ForwardIndexType
Removed ForwardIndexType.advancedBy(_: Self.Distance) -> Self
Removed ForwardIndexType.advancedBy(_: Self.Distance) -> Self
Removed ForwardIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed ForwardIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed ForwardIndexType.distanceTo(_: Self) -> Self.Distance
Removed ForwardIndexType.distanceTo(_: Self) -> Self.Distance
Removed GeneratorOfOne [struct]
Removed GeneratorOfOne.init(_: Element?)
Removed GeneratorOfOne.next() -> Element?
Removed GeneratorSequence [struct]
Removed GeneratorSequence.init(_: Base)
Removed GeneratorSequence.next() -> Base.Element?
Removed GeneratorType
Removed GeneratorType.next() -> Self.Element?
Removed HalfOpenInterval [struct]
Removed HalfOpenInterval.clamp(_: HalfOpenInterval<Bound>) -> HalfOpenInterval<Bound>
Removed HalfOpenInterval.contains(_: Bound) -> Bool
Removed HalfOpenInterval.debugDescription
Removed HalfOpenInterval.description
Removed HalfOpenInterval.end
Removed HalfOpenInterval.init(_: HalfOpenInterval<Bound>)
Removed HalfOpenInterval.init(_: Bound, _: Bound)
Removed HalfOpenInterval.isEmpty
Removed HalfOpenInterval.start
Removed ImplicitlyUnwrappedOptional.flatMap<U>(_: (Wrapped) throws -> U!) rethrows -> U!
Removed ImplicitlyUnwrappedOptional.init()
Removed ImplicitlyUnwrappedOptional.init(_: Wrapped?)
Removed ImplicitlyUnwrappedOptional.map<U>(_: (Wrapped) throws -> U) rethrows -> U!
Removed ImplicitlyUnwrappedOptional.None
Removed ImplicitlyUnwrappedOptional.Some
Removed Index.samePositionIn(_: String.UTF16View) -> String.UTF16View.Index
Removed Index.samePositionIn(_: String.UTF8View) -> String.UTF8View.Index
Removed Index.samePositionIn(_: String.UnicodeScalarView) -> String.UnicodeScalarView.Index
Removed Indexable.endIndex
Removed Indexable.startIndex
Removed Indexable.subscript(_: Self.Index) -> Self._Element
Removed IndexingGenerator [struct]
Removed IndexingGenerator.init(_: Elements)
Removed IndexingGenerator.next() -> Elements._Element?
Removed Int.advancedBy(_: Distance) -> Int
Removed Int.distanceTo(_: Int) -> Distance
Removed Int.init(_: Builtin.Word)
Removed Int.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Int.predecessor() -> Int
Removed Int.successor() -> Int
Removed Int16.advancedBy(_: Distance) -> Int16
Removed Int16.distanceTo(_: Int16) -> Distance
Removed Int16.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Int16.predecessor() -> Int16
Removed Int16.successor() -> Int16
Removed Int32.advancedBy(_: Distance) -> Int32
Removed Int32.distanceTo(_: Int32) -> Distance
Removed Int32.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Int32.predecessor() -> Int32
Removed Int32.successor() -> Int32
Removed Int64.advancedBy(_: Distance) -> Int64
Removed Int64.distanceTo(_: Int64) -> Distance
Removed Int64.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Int64.predecessor() -> Int64
Removed Int64.successor() -> Int64
Removed Int8.advancedBy(_: Distance) -> Int8
Removed Int8.distanceTo(_: Int8) -> Distance
Removed Int8.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed Int8.predecessor() -> Int8
Removed Int8.successor() -> Int8
Removed IntegerArithmeticType
Removed IntegerArithmeticType.%(_: Self, _: Self) -> Self
Removed IntegerArithmeticType.*(_: Self, _: Self) -> Self
Removed IntegerArithmeticType.+(_: Self, _: Self) -> Self
Removed IntegerArithmeticType.-(_: Self, _: Self) -> Self
Removed IntegerArithmeticType./(_: Self, _: Self) -> Self
Removed IntegerArithmeticType.addWithOverflow(_: Self, _: Self) -> (Self, overflow: Bool) [class]
Removed IntegerArithmeticType.divideWithOverflow(_: Self, _: Self) -> (Self, overflow: Bool) [class]
Removed IntegerArithmeticType.multiplyWithOverflow(_: Self, _: Self) -> (Self, overflow: Bool) [class]
Removed IntegerArithmeticType.remainderWithOverflow(_: Self, _: Self) -> (Self, overflow: Bool) [class]
Removed IntegerArithmeticType.subtractWithOverflow(_: Self, _: Self) -> (Self, overflow: Bool) [class]
Removed IntegerArithmeticType.toIntMax() -> IntMax
Removed IntegerLiteralConvertible
Removed IntegerLiteralConvertible.init(integerLiteral: Self.IntegerLiteralType)
Removed IntegerType
Removed IntervalType
Removed IntervalType.clamp(_: Self) -> Self
Removed IntervalType.contains(_: Self.Bound) -> Bool
Removed IntervalType.end
Removed IntervalType.isEmpty
Removed IntervalType.overlaps<I : IntervalType where I.Bound == Bound>(_: I) -> Bool
Removed IntervalType.start
Removed JoinGenerator [struct]
Removed JoinGenerator.init<Separator : SequenceType where Separator.Generator.Element == Base.Element.Generator.Element>(base: Base, separator: Separator)
Removed JoinGenerator.next() -> Base.Element.Generator.Element?
Removed JoinSequence [struct]
Removed JoinSequence.generate() -> JoinGenerator<Base.Generator>
Removed JoinSequence.init<Separator : SequenceType where Separator.Generator.Element == Base.Generator.Element.Generator.Element>(base: Base, separator: Separator)
Removed LazyCollection.count
Removed LazyCollection.generate() -> Base.Generator
Removed LazyCollection.init(_: Base)
Removed LazyCollection.subscript(_: Base.Index) -> Base.Generator.Element
Removed LazyCollection.underestimateCount() -> Int
Removed LazyCollectionType
Removed LazyCollectionType.elements
Removed LazyCollectionType.filter(_: (Self.Elements.Generator.Element) -> Bool) -> LazyFilterCollection<Self.Elements>
Removed LazyCollectionType.flatMap<Intermediate : CollectionType>(_: (Self.Elements.Generator.Element) -> Intermediate) -> LazyCollection<FlattenCollection<LazyMapCollection<Self.Elements, Intermediate>>>
Removed LazyCollectionType.flatMap<Intermediate : CollectionType where Intermediate.Index : BidirectionalIndexType>(_: (Self.Elements.Generator.Element) -> Intermediate) -> LazyCollection<FlattenBidirectionalCollection<LazyMapCollection<Self.Elements, Intermediate>>>
Removed LazyCollectionType.flatten() -> LazyCollection<FlattenBidirectionalCollection<Self.Elements>>
Removed LazyCollectionType.flatten() -> LazyCollection<FlattenCollection<Self.Elements>>
Removed LazyCollectionType.lazy
Removed LazyCollectionType.map<U>(_: (Self.Elements.Generator.Element) -> U) -> LazyMapCollection<Self.Elements, U>
Removed LazyCollectionType.reverse() -> LazyCollection<ReverseCollection<Self.Elements>>
Removed LazyCollectionType.reverse() -> LazyCollection<ReverseRandomAccessCollection<Self.Elements>>
Removed LazyFilterCollection.generate() -> LazyFilterGenerator<Base.Generator>
Removed LazyFilterCollection.init(_: Base, whereElementsSatisfy: (Base.Generator.Element) -> Bool)
Removed LazyFilterCollection.subscript(_: LazyFilterIndex<Base>) -> Base.Generator.Element
Removed LazyFilterGenerator [struct]
Removed LazyFilterGenerator.base
Removed LazyFilterGenerator.init(_: Base, whereElementsSatisfy: (Base.Element) -> Bool)
Removed LazyFilterGenerator.next() -> Base.Element?
Removed LazyFilterIndex.successor() -> LazyFilterIndex<BaseElements>
Removed LazyFilterSequence.generate() -> LazyFilterGenerator<Base.Generator>
Removed LazyFilterSequence.init(_: Base, whereElementsSatisfy: (Base.Generator.Element) -> Bool)
Removed LazyMapCollection.count
Removed LazyMapCollection.generate() -> LazyMapGenerator<Base.Generator, Element>
Removed LazyMapCollection.init(_: Base, transform: (Base.Generator.Element) -> Element)
Removed LazyMapCollection.underestimateCount() -> Int
Removed LazyMapGenerator [struct]
Removed LazyMapGenerator.base
Removed LazyMapGenerator.next() -> Element?
Removed LazyMapSequence.generate() -> LazyMapGenerator<Base.Generator, Element>
Removed LazyMapSequence.init(_: Base, transform: (Base.Generator.Element) -> Element)
Removed LazyMapSequence.underestimateCount() -> Int
Removed LazySequence.init(_: Base)
Removed LazySequenceType
Removed LazySequenceType.array
Removed LazySequenceType.elements
Removed LazySequenceType.elements
Removed LazySequenceType.filter(_: (Self.Elements.Generator.Element) -> Bool) -> LazyFilterSequence<Self.Elements>
Removed LazySequenceType.flatMap<Intermediate : SequenceType>(_: (Self.Elements.Generator.Element) -> Intermediate) -> LazySequence<FlattenSequence<LazyMapSequence<Self.Elements, Intermediate>>>
Removed LazySequenceType.flatten() -> LazySequence<FlattenSequence<Self.Elements>>
Removed LazySequenceType.lazy
Removed LazySequenceType.map<U>(_: (Self.Elements.Generator.Element) -> U) -> LazyMapSequence<Self.Elements, U>
Removed ManagedBuffer.create(_: Int, initialValue: (ManagedProtoBuffer<Value, Element>) -> Value) -> ManagedBuffer<Value, Element> [class]
Removed ManagedBuffer.value
Removed ManagedBufferPointer.allocatedElementCount
Removed ManagedBufferPointer.holdsUniqueOrPinnedReference() -> Bool
Removed ManagedBufferPointer.holdsUniqueReference() -> Bool
Removed ManagedBufferPointer.init(bufferClass: AnyClass, minimumCapacity: Int, initialValue: (buffer: AnyObject, allocatedCount: (AnyObject) -> Int) -> Value)
Removed ManagedBufferPointer.value
Removed ManagedBufferPointer.withUnsafeMutablePointerToValue<R>(_: (UnsafeMutablePointer<Value>) -> R) -> R
Removed ManagedProtoBuffer
Removed ManagedProtoBuffer.allocatedElementCount
Removed ManagedProtoBuffer.withUnsafeMutablePointers<R>(_: (UnsafeMutablePointer<Value>, UnsafeMutablePointer<Element>) -> R) -> R
Removed ManagedProtoBuffer.withUnsafeMutablePointerToElements<R>(_: (UnsafeMutablePointer<Element>) -> R) -> R
Removed ManagedProtoBuffer.withUnsafeMutablePointerToValue<R>(_: (UnsafeMutablePointer<Value>) -> R) -> R
Removed Mirror.customMirror() -> Mirror
Removed Mirror.init<T, C : CollectionType where C.Generator.Element == Child>(_: T, children: C, displayStyle: Mirror.DisplayStyle?, ancestorRepresentation: Mirror.AncestorRepresentation)
Removed Mirror.init<T, C : CollectionType>(_: T, unlabeledChildren: C, displayStyle: Mirror.DisplayStyle?, ancestorRepresentation: Mirror.AncestorRepresentation)
Removed Mirror.superclassMirror() -> Mirror?
Removed Mirror.AncestorRepresentation.Customized
Removed Mirror.AncestorRepresentation.Generated
Removed Mirror.AncestorRepresentation.Suppressed
Removed Mirror.DisplayStyle.Class
Removed Mirror.DisplayStyle.Collection
Removed Mirror.DisplayStyle.Dictionary
Removed Mirror.DisplayStyle.Enum
Removed Mirror.DisplayStyle.Optional
Removed Mirror.DisplayStyle.Set
Removed Mirror.DisplayStyle.Struct
Removed Mirror.DisplayStyle.Tuple
Removed MirrorPathType
Removed MutableCollectionType
Removed MutableCollectionType.partition(_: Range<Self.Index>) -> Self.Index
Removed MutableCollectionType.partition(_: Range<Self.Index>, isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) -> Bool) -> Self.Index
Removed MutableCollectionType.sort() -> [Self.Generator.Element]
Removed MutableCollectionType.sort(_: (Self.Generator.Element, Self.Generator.Element) -> Bool) -> [Self.Generator.Element]
Removed MutableCollectionType.sortInPlace()
Removed MutableCollectionType.sortInPlace(_: (Self.Generator.Element, Self.Generator.Element) -> Bool)
Removed MutableCollectionType.subscript(_: Self.Index) -> Self.Generator.Element
Removed MutableCollectionType.subscript(_: Range<Self.Index>) -> MutableSlice<Self>
Removed MutableCollectionType.subscript(_: Range<Self.Index>) -> Self.SubSequence
Removed MutableSliceable
Removed MutableSliceable.subscript(_: Range<Self.Index>) -> Self.SubSequence
Removed NilLiteralConvertible
Removed NilLiteralConvertible.init(nilLiteral: ())
Removed NonObjectiveCBase
Removed NonObjectiveCBase.init()
Removed ObjectIdentifier.uintValue
Removed Optional.init()
Removed Optional.None
Removed Optional.Some
Removed OptionSetType
Removed OptionSetType.contains(_: Self) -> Bool
Removed OptionSetType.exclusiveOr(_: Self) -> Self
Removed OptionSetType.exclusiveOrInPlace(_: Self)
Removed OptionSetType.init()
Removed OptionSetType.init(rawValue: Self.RawValue)
Removed OptionSetType.insert(_: Self)
Removed OptionSetType.intersect(_: Self) -> Self
Removed OptionSetType.intersectInPlace(_: Self)
Removed OptionSetType.remove(_: Self) -> Self?
Removed OptionSetType.union(_: Self) -> Self
Removed OptionSetType.unionInPlace(_: Self)
Removed OutputStreamType
Removed OutputStreamType.write(_: String)
Removed PermutationGenerator [struct]
Removed PermutationGenerator.init(elements: C, indices: Indices)
Removed PermutationGenerator.next() -> C.Generator.Element?
Removed PlaygroundQuickLook.AttributedString
Removed PlaygroundQuickLook.BezierPath
Removed PlaygroundQuickLook.Color
Removed PlaygroundQuickLook.Double
Removed PlaygroundQuickLook.Float
Removed PlaygroundQuickLook.Image
Removed PlaygroundQuickLook.Int
Removed PlaygroundQuickLook.Logical
Removed PlaygroundQuickLook.Point
Removed PlaygroundQuickLook.Range
Removed PlaygroundQuickLook.Rectangle
Removed PlaygroundQuickLook.Size
Removed PlaygroundQuickLook.Sound
Removed PlaygroundQuickLook.Sprite
Removed PlaygroundQuickLook.Text
Removed PlaygroundQuickLook.UInt
Removed PlaygroundQuickLook.URL
Removed PlaygroundQuickLook.View
Removed Process [enum]
Removed Process.argc
Removed Process.arguments
Removed Process.unsafeArgv
Removed RandomAccessIndexType
Removed RandomAccessIndexType.advancedBy(_: Self.Distance) -> Self
Removed RandomAccessIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed RandomAccessIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed RandomAccessIndexType.distanceTo(_: Self) -> Self.Distance
Removed Range.endIndex
Removed Range.generate() -> RangeGenerator<Element>
Removed Range.init(start: Element, end: Element)
Removed Range.startIndex
Removed Range.subscript(_: Element) -> Element
Removed Range.subscript(_: Element._DisabledRangeIndex) -> Element
Removed RangeGenerator [struct]
Removed RangeGenerator.endIndex
Removed RangeGenerator.init(_: Range<Element>)
Removed RangeGenerator.next() -> Element?
Removed RangeGenerator.startIndex
Removed RangeReplaceableCollectionType
Removed RangeReplaceableCollectionType.append(_: Self.Generator.Element)
Removed RangeReplaceableCollectionType.append(_: Self.Generator.Element)
Removed RangeReplaceableCollectionType.appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Removed RangeReplaceableCollectionType.appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Removed RangeReplaceableCollectionType.init()
Removed RangeReplaceableCollectionType.init<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Removed RangeReplaceableCollectionType.init<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Removed RangeReplaceableCollectionType.insert(_: Self.Generator.Element, atIndex: Self.Index)
Removed RangeReplaceableCollectionType.insert(_: Self.Generator.Element, atIndex: Self.Index)
Removed RangeReplaceableCollectionType.insertContentsOf<S : CollectionType where S.Generator.Element == Generator.Element>(_: S, at: Self.Index)
Removed RangeReplaceableCollectionType.insertContentsOf<C : CollectionType where C.Generator.Element == Generator.Element>(_: C, at: Self.Index)
Removed RangeReplaceableCollectionType.removeAll(keepCapacity: Bool)
Removed RangeReplaceableCollectionType.removeAll(keepCapacity: Bool)
Removed RangeReplaceableCollectionType.removeAtIndex(_: Self.Index) -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeAtIndex(_: Self.Index) -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst(_: Int)
Removed RangeReplaceableCollectionType.removeFirst(_: Int)
Removed RangeReplaceableCollectionType.removeFirst(_: Int)
Removed RangeReplaceableCollectionType.removeLast() -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeLast(_: Int)
Removed RangeReplaceableCollectionType.removeRange(_: Range<Self.Index>)
Removed RangeReplaceableCollectionType.removeRange(_: Range<Self.Index>)
Removed RangeReplaceableCollectionType.replaceRange<C : CollectionType where C.Generator.Element == Generator.Element>(_: Range<Self.Index>, with: C)
Removed RangeReplaceableCollectionType.reserveCapacity(_: Self.Index.Distance)
Removed RangeReplaceableCollectionType.reserveCapacity(_: Self.Index.Distance)
Removed RawByte [struct]
Removed Repeat [struct]
Removed Repeat.count
Removed Repeat.endIndex
Removed Repeat.init(count: Int, repeatedValue: Element)
Removed Repeat.repeatedValue
Removed Repeat.startIndex
Removed Repeat.subscript(_: Int) -> Element
Removed ReverseCollection [struct]
Removed ReverseCollection.init(_: Base)
Removed ReverseIndex [struct]
Removed ReverseIndex.base
Removed ReverseIndex.init(_: Base)
Removed ReverseIndexType
Removed ReverseIndexType.base
Removed ReverseIndexType.init(_: Self.Base)
Removed ReverseRandomAccessCollection [struct]
Removed ReverseRandomAccessCollection.init(_: Base)
Removed ReverseRandomAccessIndex [struct]
Removed ReverseRandomAccessIndex.advancedBy(_: Base.Distance) -> ReverseRandomAccessIndex<Base>
Removed ReverseRandomAccessIndex.base
Removed ReverseRandomAccessIndex.distanceTo(_: ReverseRandomAccessIndex<Base>) -> Base.Distance
Removed ReverseRandomAccessIndex.init(_: Base)
Removed SequenceType
Removed SequenceType.contains(_: Self.Generator.Element) -> Bool
Removed SequenceType.contains(_: (Self.Generator.Element) throws -> Bool) rethrows -> Bool
Removed SequenceType.dropFirst() -> Self.SubSequence
Removed SequenceType.dropFirst(_: Int) -> Self.SubSequence
Removed SequenceType.dropFirst(_: Int) -> AnySequence<Self.Generator.Element>
Removed SequenceType.dropLast() -> Self.SubSequence
Removed SequenceType.dropLast(_: Int) -> AnySequence<Self.Generator.Element>
Removed SequenceType.dropLast(_: Int) -> Self.SubSequence
Removed SequenceType.elementsEqual<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence) -> Bool
Removed SequenceType.elementsEqual<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence, isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool
Removed SequenceType.enumerate() -> EnumerateSequence<Self>
Removed SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Removed SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Removed SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Removed SequenceType.flatMap<T>(_: (Self.Generator.Element) throws -> T?) rethrows -> [T]
Removed SequenceType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
Removed SequenceType.flatten() -> FlattenSequence<Self>
Removed SequenceType.forEach(_: (Self.Generator.Element) throws -> Void) rethrows
Removed SequenceType.forEach(_: (Self.Generator.Element) throws -> Void) rethrows
Removed SequenceType.generate() -> Self.Generator
Removed SequenceType.generate() -> Self.Generator
Removed SequenceType.generate() -> Self
Removed SequenceType.joinWithSeparator(_: String) -> String
Removed SequenceType.joinWithSeparator<Separator : SequenceType where Separator.Generator.Element == Generator.Element.Generator.Element>(_: Separator) -> JoinSequence<Self>
Removed SequenceType.lazy
Removed SequenceType.lexicographicalCompare<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence) -> Bool
Removed SequenceType.lexicographicalCompare<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence, isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool
Removed SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed SequenceType.maxElement() -> Self.Generator.Element?
Removed SequenceType.maxElement(_: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element?
Removed SequenceType.minElement() -> Self.Generator.Element?
Removed SequenceType.minElement(_: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element?
Removed SequenceType.prefix(_: Int) -> AnySequence<Self.Generator.Element>
Removed SequenceType.prefix(_: Int) -> Self.SubSequence
Removed SequenceType.reduce<T>(_: T, combine: (T, Self.Generator.Element) throws -> T) rethrows -> T
Removed SequenceType.reverse() -> [Self.Generator.Element]
Removed SequenceType.sort() -> [Self.Generator.Element]
Removed SequenceType.sort(_: (Self.Generator.Element, Self.Generator.Element) -> Bool) -> [Self.Generator.Element]
Removed SequenceType.split(_: Int, allowEmptySlices: Bool, isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [AnySequence<Self.Generator.Element>]
Removed SequenceType.split(_: Int, allowEmptySlices: Bool, isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Removed SequenceType.split(_: Self.Generator.Element, maxSplit: Int, allowEmptySlices: Bool) -> [AnySequence<Self.Generator.Element>]
Removed SequenceType.startsWith<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence) -> Bool
Removed SequenceType.startsWith<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence, isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool
Removed SequenceType.suffix(_: Int) -> AnySequence<Self.Generator.Element>
Removed SequenceType.suffix(_: Int) -> Self.SubSequence
Removed SequenceType.underestimateCount() -> Int
Removed SequenceType.underestimateCount() -> Int
Removed SequenceType.underestimateCount() -> Int
Removed Set.exclusiveOr<S : SequenceType where S.Generator.Element == Element>(_: S) -> Set<Element>
Removed Set.exclusiveOrInPlace<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed Set.generate() -> SetGenerator<Element>
Removed Set.indexOf(_: Element) -> SetIndex<Element>?
Removed Set.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed Set.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, isDisjointWith: Self.Element) -> Bool [class]
Removed SetAlgebraType.element(_: Self.Element, subsumes: Self.Element) -> Bool [class]
Removed SetAlgebraType.element(_: Self.Element, subsumes: Self.Element) -> Bool [class]
Removed SetAlgebraType.exclusiveOr(_: Self) -> Self
Removed SetAlgebraType.exclusiveOrInPlace(_: Self)
Removed SetAlgebraType.init()
Removed SetAlgebraType.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed SetAlgebraType.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed SetAlgebraType.init(arrayLiteral: Self.Element)
Removed SetAlgebraType.insert(_: Self.Element)
Removed SetAlgebraType.intersect(_: Self) -> Self
Removed SetAlgebraType.intersectInPlace(_: Self)
Removed SetAlgebraType.isDisjointWith(_: Self) -> Bool
Removed SetAlgebraType.isDisjointWith(_: Self) -> Bool
Removed SetAlgebraType.isEmpty
Removed SetAlgebraType.isEmpty
Removed SetAlgebraType.isStrictSubsetOf(_: Self) -> Bool
Removed SetAlgebraType.isStrictSupersetOf(_: Self) -> Bool
Removed SetAlgebraType.isSubsetOf(_: Self) -> Bool
Removed SetAlgebraType.isSubsetOf(_: Self) -> Bool
Removed SetAlgebraType.isSupersetOf(_: Self) -> Bool
Removed SetAlgebraType.isSupersetOf(_: Self) -> Bool
Removed SetAlgebraType.remove(_: Self.Element) -> Self.Element?
Removed SetAlgebraType.subtract(_: Self) -> Self
Removed SetAlgebraType.subtract(_: Self) -> Self
Removed SetAlgebraType.subtractInPlace(_: Self)
Removed SetAlgebraType.subtractInPlace(_: Self)
Removed SetAlgebraType.union(_: Self) -> Self
Removed SetAlgebraType.unionInPlace(_: Self)
Removed SetGenerator [struct]
Removed SetGenerator.next() -> Element?
Removed SetIndex.successor() -> SetIndex<Element>
Removed SignedIntegerType
Removed SignedIntegerType.init(_: IntMax)
Removed SignedIntegerType.toIntMax() -> IntMax
Removed SignedNumberType
Removed SignedNumberType.-(_: Self) -> Self
Removed SignedNumberType.-(_: Self, _: Self) -> Self
Removed StaticString.byteSize
Removed StaticString.init(_builtinExtendedGraphemeClusterLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)
Removed StaticString.init(_builtinStringLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)
Removed StaticString.init(_builtinUnicodeScalarLiteral: Builtin.Int32)
Removed StaticString.stringValue
Removed Streamable
Removed Streamable.writeTo<Target : OutputStreamType>(_: Target)
Removed Strideable.advancedBy(_: Self.Stride) -> Self
Removed Strideable.distanceTo(_: Self) -> Self.Stride
Removed Strideable.stride(through: Self, by: Self.Stride) -> StrideThrough<Self>
Removed Strideable.stride(to: Self, by: Self.Stride) -> StrideTo<Self>
Removed StrideThrough.generate() -> StrideThroughGenerator<Element>
Removed StrideThroughGenerator [struct]
Removed StrideThroughGenerator.next() -> Element?
Removed StrideTo.generate() -> StrideToGenerator<Element>
Removed StrideToGenerator [struct]
Removed StrideToGenerator.next() -> Element?
Removed String.append(_: UnicodeScalar)
Removed String.appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed String.appendContentsOf(_: String)
Removed String.fromCString(_: UnsafePointer<CChar>) -> String? [static]
Removed String.fromCStringRepairingIllFormedUTF8(_: UnsafePointer<CChar>) -> (String?, hadError: Bool) [static]
Removed String.init<T : _SignedIntegerType>(_: T)
Removed String.init<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed String.init<T>(_: T)
Removed String.init<T : UnsignedIntegerType>(_: T)
Removed String.init<T : UnsignedIntegerType>(_: T, radix: Int, uppercase: Bool)
Removed String.init<T : _SignedIntegerType>(_: T, radix: Int, uppercase: Bool)
Removed String.init(_builtinExtendedGraphemeClusterLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)
Removed String.init(_builtinStringLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)
Removed String.init(_builtinUnicodeScalarLiteral: Builtin.Int32)
Removed String.init(_builtinUTF16StringLiteral: Builtin.RawPointer, numberOfCodeUnits: Builtin.Word)
Removed String.init(count: Int, repeatedValue: Character)
Removed String.init(count: Int, repeatedValue: UnicodeScalar)
Removed String.insert(_: Character, atIndex: Index)
Removed String.insertContentsOf<S : CollectionType where S.Generator.Element == Character>(_: S, at: Index)
Removed String.lowercaseString
Removed String.nulTerminatedUTF8
Removed String.removeAll(keepCapacity: Bool)
Removed String.removeAtIndex(_: Index) -> Character
Removed String.removeRange(_: Range<Index>)
Removed String.replaceRange(_: Range<Index>, with: String)
Removed String.replaceRange<C : CollectionType where C.Generator.Element == Character>(_: Range<Index>, with: C)
Removed String.uppercaseString
Removed String.writeTo<Target : OutputStreamType>(_: Target)
Removed String.CharacterView.appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed String.CharacterView.init<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed String.CharacterView.replaceRange<C : CollectionType where C.Generator.Element == Character>(_: Range<String.CharacterView.Index>, with: C)
Removed String.CharacterView.Index.predecessor() -> String.CharacterView.Index
Removed String.CharacterView.Index.successor() -> String.CharacterView.Index
Removed String.UnicodeScalarView.appendContentsOf<S : SequenceType where S.Generator.Element == UnicodeScalar>(_: S)
Removed String.UnicodeScalarView.generate() -> String.UnicodeScalarView.Generator
Removed String.UnicodeScalarView.replaceRange<C : CollectionType where C.Generator.Element == UnicodeScalar>(_: Range<String.UnicodeScalarView.Index>, with: C)
Removed String.UnicodeScalarView.Generator [struct]
Removed String.UnicodeScalarView.Generator.next() -> UnicodeScalar?
Removed String.UnicodeScalarView.Index.predecessor() -> String.UnicodeScalarView.Index
Removed String.UnicodeScalarView.Index.successor() -> String.UnicodeScalarView.Index
Removed String.UTF16View.Index.advancedBy(_: Distance) -> String.UTF16View.Index
Removed String.UTF16View.Index.advancedBy(_: Distance, limit: String.UTF16View.Index) -> String.UTF16View.Index
Removed String.UTF16View.Index.distanceTo(_: String.UTF16View.Index) -> Distance
Removed String.UTF16View.Index.predecessor() -> String.UTF16View.Index
Removed String.UTF16View.Index.samePositionIn(_: String.UnicodeScalarView) -> UnicodeScalarIndex?
Removed String.UTF16View.Index.samePositionIn(_: String.UTF8View) -> String.UTF8View.Index?
Removed String.UTF16View.Index.samePositionIn(_: String) -> Index?
Removed String.UTF16View.Index.successor() -> String.UTF16View.Index
Removed String.UTF8View.Index.samePositionIn(_: String) -> Index?
Removed String.UTF8View.Index.samePositionIn(_: String.UnicodeScalarView) -> UnicodeScalarIndex?
Removed String.UTF8View.Index.samePositionIn(_: String.UTF16View) -> String.UTF16View.Index?
Removed String.UTF8View.Index.successor() -> String.UTF8View.Index
Removed StringInterpolationConvertible
Removed StringInterpolationConvertible.init(stringInterpolation: Self)
Removed StringInterpolationConvertible.init<T>(stringInterpolationSegment: T)
Removed StringLiteralConvertible
Removed StringLiteralConvertible.init(stringLiteral: Self.StringLiteralType)
Removed UInt.advancedBy(_: Distance) -> UInt
Removed UInt.distanceTo(_: UInt) -> Distance
Removed UInt.init(_: Builtin.Word)
Removed UInt.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed UInt.predecessor() -> UInt
Removed UInt.successor() -> UInt
Removed UInt16.advancedBy(_: Distance) -> UInt16
Removed UInt16.distanceTo(_: UInt16) -> Distance
Removed UInt16.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed UInt16.predecessor() -> UInt16
Removed UInt16.successor() -> UInt16
Removed UInt32.advancedBy(_: Distance) -> UInt32
Removed UInt32.distanceTo(_: UInt32) -> Distance
Removed UInt32.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed UInt32.predecessor() -> UInt32
Removed UInt32.successor() -> UInt32
Removed UInt64.advancedBy(_: Distance) -> UInt64
Removed UInt64.distanceTo(_: UInt64) -> Distance
Removed UInt64.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed UInt64.predecessor() -> UInt64
Removed UInt64.successor() -> UInt64
Removed UInt8.advancedBy(_: Distance) -> UInt8
Removed UInt8.distanceTo(_: UInt8) -> Distance
Removed UInt8.init(_builtinIntegerLiteral: Builtin.Int2048)
Removed UInt8.predecessor() -> UInt8
Removed UInt8.successor() -> UInt8
Removed UnicodeCodecType
Removed UnicodeCodecType.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed UnicodeCodecType.encode(_: UnicodeScalar, output: (Self.CodeUnit) -> Void) [class]
Removed UnicodeCodecType.init()
Removed UnicodeDecodingResult.EmptyInput
Removed UnicodeDecodingResult.Error
Removed UnicodeDecodingResult.isEmptyInput() -> Bool
Removed UnicodeDecodingResult.Result
Removed UnicodeScalar.escape(asASCII: Bool) -> String
Removed UnicodeScalar.init()
Removed UnicodeScalar.init(_builtinUnicodeScalarLiteral: Builtin.Int32)
Removed UnicodeScalar.isASCII() -> Bool
Removed UnicodeScalar.writeTo<Target : OutputStreamType>(_: Target)
Removed UnicodeScalarIndex.samePositionIn(_: String.UTF16View) -> String.UTF16View.Index
Removed UnicodeScalarIndex.samePositionIn(_: String.UTF8View) -> String.UTF8View.Index
Removed UnicodeScalarIndex.samePositionIn(_: String) -> Index?
Removed UnicodeScalarLiteralConvertible
Removed UnicodeScalarLiteralConvertible.init(unicodeScalarLiteral: Self.UnicodeScalarLiteralType)
Removed Unmanaged.toOpaque() -> COpaquePointer
Removed UnsafeBufferPointer.generate() -> UnsafeBufferPointerGenerator<Element>
Removed UnsafeBufferPointerGenerator [struct]
Removed UnsafeBufferPointerGenerator.next() -> Element?
Removed UnsafeMutableBufferPointer.generate() -> UnsafeBufferPointerGenerator<Element>
Removed UnsafeMutablePointer.advancedBy(_: Int) -> UnsafeMutablePointer<Memory>
Removed UnsafeMutablePointer.alloc(_: Int) -> UnsafeMutablePointer<Memory> [static]
Removed UnsafeMutablePointer.assignBackwardFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafeMutablePointer.assignFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafeMutablePointer.dealloc(_: Int)
Removed UnsafeMutablePointer.destroy()
Removed UnsafeMutablePointer.destroy(_: Int)
Removed UnsafeMutablePointer.distanceTo(_: UnsafeMutablePointer<Memory>) -> Int
Removed UnsafeMutablePointer.init()
Removed UnsafeMutablePointer.init<U>(_: UnsafeMutablePointer<U>)
Removed UnsafeMutablePointer.init<U>(_: UnsafePointer<U>)
Removed UnsafeMutablePointer.init(nilLiteral: ())
Removed UnsafeMutablePointer.initialize(_: Memory)
Removed UnsafeMutablePointer.initializeFrom<C : CollectionType where C.Generator.Element == Memory>(_: C)
Removed UnsafeMutablePointer.initializeFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafeMutablePointer.memory
Removed UnsafeMutablePointer.moveAssignFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafeMutablePointer.moveInitializeBackwardFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafeMutablePointer.moveInitializeFrom(_: UnsafeMutablePointer<Memory>, count: Int)
Removed UnsafePointer.advancedBy(_: Int) -> UnsafePointer<Memory>
Removed UnsafePointer.distanceTo(_: UnsafePointer<Memory>) -> Int
Removed UnsafePointer.init()
Removed UnsafePointer.init<U>(_: UnsafeMutablePointer<U>)
Removed UnsafePointer.init<U>(_: UnsafePointer<U>)
Removed UnsafePointer.init(nilLiteral: ())
Removed UnsafePointer.memory
Removed UnsignedIntegerType
Removed UnsignedIntegerType.init(_: UIntMax)
Removed UnsignedIntegerType.toUIntMax() -> UIntMax
Removed UTF16.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed UTF16.encode(_: UnicodeScalar, output: (CodeUnit) -> Void) [static]
Removed UTF16.measure<Encoding : UnicodeCodecType, Input : GeneratorType where Encoding.CodeUnit == Input.Element>(_: Encoding.Type, input: Input, repairIllFormedSequences: Bool) -> (Int, Bool)? [static]
Removed UTF32.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed UTF32.encode(_: UnicodeScalar, output: (CodeUnit) -> Void) [static]
Removed UTF8.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed UTF8.encode(_: UnicodeScalar, output: (CodeUnit) -> Void) [static]
Removed VaListBuilder
Removed Zip2Generator [struct]
Removed Zip2Generator.init(_: Generator1, _: Generator2)
Removed Zip2Generator.next() -> (Generator1.Element, Generator2.Element)?
Removed Zip2Sequence.generate() -> Zip2Generator<Sequence1.Generator, Sequence2.Generator>
Removed Zip2Sequence.init(_: Sequence1, _: Sequence2)
Removed !(_: Bool) -> Bool
Removed !(_: T) -> Bool
Removed !=(_: Float, _: Float) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !=(_: [Key : Value], _: [Key : Value]) -> Bool
Removed !=(_: Double, _: Double) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !==(_: L, _: R) -> Bool
Removed %(_: T, _: T) -> T
Removed %(_: Double, _: Double) -> Double
Removed %(_: Float, _: Float) -> Float
Removed %=(_: T, _: T)
Removed %=(_: Double, _: Double)
Removed %=(_: Float, _: Float)
Removed &&(_: T, _: () throws -> Bool) rethrows -> Bool
Removed &&(_: T, _: () throws -> U) rethrows -> Bool
Removed &*(_: T, _: T) -> T
Removed &+(_: T, _: T) -> T
Removed &-(_: T, _: T) -> T
Removed &=(_: T, _: T)
Removed *(_: T, _: T) -> T
Removed *=(_: T, _: T)
Removed +(_: T) -> T
Removed +(_: T, _: T._DisallowMixedSignArithmetic) -> T
Removed +(_: S, _: C) -> C
Removed +(_: C, _: S) -> C
Removed +(_: T._DisallowMixedSignArithmetic, _: T) -> T
Removed +(_: T, _: T) -> T
Removed +(_: RRC1, _: RRC2) -> RRC1
Removed +(_: String, _: String) -> String
Removed +(_: C, _: S) -> C
Removed ++(_: T) -> T
Removed ++(_: Int64) -> Int64
Removed ++(_: UInt) -> UInt
Removed ++(_: UInt16) -> UInt16
Removed ++(_: Float) -> Float
Removed ++(_: Int32) -> Int32
Removed ++(_: T) -> T
Removed ++(_: Int16) -> Int16
Removed ++(_: UInt8) -> UInt8
Removed ++(_: Int64) -> Int64
Removed ++(_: UInt64) -> UInt64
Removed ++(_: UInt32) -> UInt32
Removed ++(_: Int8) -> Int8
Removed ++(_: Int32) -> Int32
Removed ++(_: UInt) -> UInt
Removed ++(_: Double) -> Double
Removed ++(_: UInt16) -> UInt16
Removed ++(_: Int) -> Int
Removed ++(_: UInt64) -> UInt64
Removed ++(_: Int) -> Int
Removed ++(_: Float) -> Float
Removed ++(_: Int16) -> Int16
Removed ++(_: Int8) -> Int8
Removed ++(_: UInt32) -> UInt32
Removed ++(_: UInt8) -> UInt8
Removed ++(_: Double) -> Double
Removed +=(_: ContiguousArray<Element>, _: S)
Removed +=(_: _ContiguousArrayBuffer<Element>, _: C)
Removed +=(_: T, _: T)
Removed +=(_: ArraySlice<Element>, _: S)
Removed +=(_: [Element], _: C)
Removed +=(_: T, _: T._DisallowMixedSignArithmetic)
Removed +=(_: ContiguousArray<Element>, _: C)
Removed +=(_: ArraySlice<Element>, _: C)
Removed +=(_: [Element], _: S)
Removed +=(_: String, _: String)
Removed -(_: T) -> T
Removed -(_: T, _: T) -> T
Removed --(_: Float) -> Float
Removed --(_: UInt32) -> UInt32
Removed --(_: Double) -> Double
Removed --(_: T) -> T
Removed --(_: Int64) -> Int64
Removed --(_: UInt64) -> UInt64
Removed --(_: UInt64) -> UInt64
Removed --(_: Int) -> Int
Removed --(_: Int64) -> Int64
Removed --(_: T) -> T
Removed --(_: UInt8) -> UInt8
Removed --(_: UInt16) -> UInt16
Removed --(_: Int16) -> Int16
Removed --(_: UInt) -> UInt
Removed --(_: Float) -> Float
Removed --(_: Int16) -> Int16
Removed --(_: UInt32) -> UInt32
Removed --(_: Int8) -> Int8
Removed --(_: Int32) -> Int32
Removed --(_: Int8) -> Int8
Removed --(_: Double) -> Double
Removed --(_: Int) -> Int
Removed --(_: UInt16) -> UInt16
Removed --(_: UInt8) -> UInt8
Removed --(_: Int32) -> Int32
Removed --(_: UInt) -> UInt
Removed -=(_: T, _: T._DisallowMixedSignArithmetic)
Removed -=(_: T, _: T)
Removed ...(_: Pos, _: Pos) -> Range<Pos>
Removed ...(_: Pos, _: Pos) -> Range<Pos>
Removed ...(_: Bound, _: Bound) -> ClosedInterval<Bound>
Removed ..<(_: Bound, _: Bound) -> HalfOpenInterval<Bound>
Removed ..<(_: Pos, _: Pos) -> Range<Pos>
Removed ..<(_: Pos, _: Pos) -> Range<Pos>
Removed /(_: T, _: T) -> T
Removed /=(_: T, _: T)
Removed <(_: T, _: T) -> Bool
Removed <(_: Float, _: Float) -> Bool
Removed <(_: ObjectIdentifier, _: ObjectIdentifier) -> Bool
Removed <(_: Double, _: Double) -> Bool
Removed <(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> Bool
Removed <(_: Character, _: Character) -> Bool
Removed <(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool
Removed <(_: Index, _: Index) -> Bool
Removed <(_: T?, _: T?) -> Bool
Removed <(_: String, _: String) -> Bool
Removed <(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool
Removed <(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool
Removed <(_: UnicodeScalar, _: UnicodeScalar) -> Bool
Removed <(_: Bit, _: Bit) -> Bool
Removed <(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool
Removed <=(_: Double, _: Double) -> Bool
Removed <=(_: Float, _: Float) -> Bool
Removed <=(_: T, _: T) -> Bool
Removed <=(_: T?, _: T?) -> Bool
Removed ==(_: String.UTF8View.Index, _: String.UTF8View.Index) -> Bool
Removed ==(_: Double, _: Double) -> Bool
Removed ==(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Removed ==(_: Bool, _: Bool) -> Bool
Removed ==(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool
Removed ==(_: AnyForwardIndex, _: AnyForwardIndex) -> Bool
Removed ==(_: Index, _: Index) -> Bool
Removed ==(_: FlattenCollectionIndex<BaseElements>, _: FlattenCollectionIndex<BaseElements>) -> Bool
Removed ==(_: ObjectIdentifier, _: ObjectIdentifier) -> Bool
Removed ==(_: ClosedInterval<Bound>, _: ClosedInterval<Bound>) -> Bool
Removed ==(_: [Key : Value], _: [Key : Value]) -> Bool
Removed ==(_: Set<Element>, _: Set<Element>) -> Bool
Removed ==(_: COpaquePointer, _: COpaquePointer) -> Bool
Removed ==(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> Bool
Removed ==(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool
Removed ==(_: FlattenBidirectionalCollectionIndex<BaseElements>, _: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool
Removed ==(_: ReverseIndex<Base>, _: ReverseIndex<Base>) -> Bool
Removed ==(_: HalfOpenInterval<Bound>, _: HalfOpenInterval<Bound>) -> Bool
Removed ==(_: String, _: String) -> Bool
Removed ==(_: Range<Element>, _: Range<Element>) -> Bool
Removed ==(_: Character, _: Character) -> Bool
Removed ==(_: AnyRandomAccessIndex, _: AnyRandomAccessIndex) -> Bool
Removed ==(_: UnicodeScalar, _: UnicodeScalar) -> Bool
Removed ==(_: ManagedBufferPointer<Value, Element>, _: ManagedBufferPointer<Value, Element>) -> Bool
Removed ==(_: T, _: T) -> Bool
Removed ==(_: Float, _: Float) -> Bool
Removed ==(_: AnyBidirectionalIndex, _: AnyBidirectionalIndex) -> Bool
Removed ==(_: Bit, _: Bit) -> Bool
Removed ==(_: T, _: T) -> Bool
Removed ==(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool
Removed ==(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool
Removed ===(_: L, _: R) -> Bool
Removed >(_: Float, _: Float) -> Bool
Removed >(_: T, _: T) -> Bool
Removed >(_: T?, _: T?) -> Bool
Removed >(_: Double, _: Double) -> Bool
Removed >=(_: T?, _: T?) -> Bool
Removed >=(_: T, _: T) -> Bool
Removed >=(_: Double, _: Double) -> Bool
Removed >=(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> Bool
Removed >=(_: Float, _: Float) -> Bool
Removed ^=(_: T, _: T)
Removed abs<T : SignedNumberType>(_: T) -> T
Removed alignof<T>(_: T.Type) -> Int
Removed alignofValue<T>(_: T) -> Int
Removed Any
Removed AnyBidirectionalIndex.Distance
Removed AnyForwardIndex.Distance
Removed anyGenerator<Element>(_: () -> Element?) -> AnyGenerator<Element>
Removed anyGenerator<G : GeneratorType>(_: G) -> AnyGenerator<G.Element>
Removed AnyRandomAccessIndex.Distance
Removed ArrayLiteralConvertible.Element
Removed Bit.Distance
Removed BooleanLiteralConvertible.BooleanLiteralType
Removed CollectionType.Generator
Removed CollectionType.SubSequence
Removed debugPrint<Target : OutputStreamType>(_: Any, separator: String, terminator: String, toStream: Target)
Removed DictionaryLiteralConvertible.Key
Removed DictionaryLiteralConvertible.Value
Removed dump<T, TargetStream : OutputStreamType>(_: T, _: TargetStream, name: String?, indent: Int, maxDepth: Int, maxItems: Int) -> T
Removed EnumerateGenerator.Element
Removed ExtendedGraphemeClusterLiteralConvertible.ExtendedGraphemeClusterLiteralType
Removed FloatLiteralConvertible.FloatLiteralType
Removed ForwardIndexType.Distance
Removed GeneratorType.Element
Removed Indexable.Index
Removed Int.Distance
Removed Int16.Distance
Removed Int32.Distance
Removed Int64.Distance
Removed Int8.Distance
Removed IntegerLiteralConvertible.IntegerLiteralType
Removed IntervalType.Bound
Removed isUniquelyReferenced<T : NonObjectiveCBase>(_: T) -> Bool
Removed isUniquelyReferencedNonObjC<T : AnyObject>(_: T) -> Bool
Removed isUniquelyReferencedNonObjC<T : AnyObject>(_: T?) -> Bool
Removed LazyCollectionType.Elements
Removed LazySequenceType.Elements
Removed MutableCollectionType.SubSequence
Removed numericCast<T : UnsignedIntegerType, U : UnsignedIntegerType>(_: T) -> U
Removed numericCast<T : _SignedIntegerType, U : _SignedIntegerType>(_: T) -> U
Removed numericCast<T : _SignedIntegerType, U : UnsignedIntegerType>(_: T) -> U
Removed numericCast<T : UnsignedIntegerType, U : _SignedIntegerType>(_: T) -> U
Removed OptionSetType.Element
Removed PermutationGenerator.Element
Removed print<Target : OutputStreamType>(_: Any, separator: String, terminator: String, toStream: Target)
Removed readLine(stripNewline: Bool) -> String?
Removed Repeat.Index
Removed ReverseCollection.Generator
Removed ReverseCollection.Index
Removed ReverseIndex.Distance
Removed ReverseIndexType.Base
Removed ReverseIndexType.Distance
Removed ReverseRandomAccessCollection.Generator
Removed ReverseRandomAccessCollection.Index
Removed ReverseRandomAccessIndex.Distance
Removed SequenceType.Generator
Removed SequenceType.SubSequence
Removed SetAlgebraType.Element
Removed sizeof<T>(_: T.Type) -> Int
Removed sizeofValue<T>(_: T) -> Int
Removed strideof<T>(_: T.Type) -> Int
Removed strideofValue<T>(_: T) -> Int
Removed String.UTF16View.Index.Distance
Removed StringLiteralConvertible.StringLiteralType
Removed transcode<Input : GeneratorType, InputEncoding : UnicodeCodecType, OutputEncoding : UnicodeCodecType where InputEncoding.CodeUnit == Input.Element>(_: InputEncoding.Type, _: OutputEncoding.Type, _: Input, _: (OutputEncoding.CodeUnit) -> Void, stopOnError: Bool) -> Bool
Removed UInt.Distance
Removed UInt16.Distance
Removed UInt32.Distance
Removed UInt64.Distance
Removed UInt8.Distance
Removed UnicodeCodecType.CodeUnit
Removed UnicodeScalarLiteralConvertible.UnicodeScalarLiteralType
Removed unsafeAddressOf(_: AnyObject) -> UnsafePointer<Void>
Removed unsafeBitCast<T, U>(_: T, _: U.Type) -> U
Removed unsafeDowncast<T : AnyObject>(_: AnyObject) -> T
Removed unsafeUnwrap<T>(_: T?) -> T
Removed withUnsafeMutablePointer<T, Result>(_: T, _: UnsafeMutablePointer<T> throws -> Result) rethrows -> Result
Removed withUnsafeMutablePointers<A0, A1, Result>(_: A0, _: A1, _: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>) throws -> Result) rethrows -> Result
Removed withUnsafeMutablePointers<A0, A1, A2, Result>(_: A0, _: A1, _: A2, _: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>, UnsafeMutablePointer<A2>) throws -> Result) rethrows -> Result
Removed withUnsafePointer<T, Result>(_: T, _: UnsafePointer<T> throws -> Result) rethrows -> Result
Removed withUnsafePointers<A0, A1, Result>(_: A0, _: A1, _: (UnsafePointer<A0>, UnsafePointer<A1>) throws -> Result) rethrows -> Result
Removed withUnsafePointers<A0, A1, A2, Result>(_: A0, _: A1, _: A2, _: (UnsafePointer<A0>, UnsafePointer<A1>, UnsafePointer<A2>) throws -> Result) rethrows -> Result
Removed withVaList<R>(_: VaListBuilder, _: CVaListPointer -> R) -> R
Removed withVaList<R>(_: [CVarArgType], _: CVaListPointer -> R) -> R
Removed Zip2Generator.Element
Removed Zip2Sequence.Generator
Removed |=(_: T, _: T)
Removed ||(_: T, _: () throws -> Bool) rethrows -> Bool
Removed ||(_: T, _: () throws -> U) rethrows -> Bool
Removed ~=(_: Range<I>, _: I) -> Bool
Removed ~=(_: I, _: I.Bound) -> Bool
Added AnyBidirectionalCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.count
Added AnyBidirectionalCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax
Added AnyBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.enumerated() -> EnumeratedSequence<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.first
Added AnyBidirectionalCollection.first
Added AnyBidirectionalCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added AnyBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnyBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnyBidirectionalCollection.formIndex(_: AnyIndex, offsetBy: IntMax)
Added AnyBidirectionalCollection.formIndex(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> Bool
Added AnyBidirectionalCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex
Added AnyBidirectionalCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?
Added AnyBidirectionalCollection.index(of: Element) -> AnyIndex?
Added AnyBidirectionalCollection.index(where: (Element) throws -> Bool) rethrows -> AnyIndex?
Added AnyBidirectionalCollection.indices
Added AnyBidirectionalCollection.init<C : BidirectionalCollection where C.Iterator.Element == Element, C.SubSequence : BidirectionalCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : BidirectionalCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : BidirectionalCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyBidirectionalCollection.init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyBidirectionalCollection.joined() -> FlattenCollection<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.joined() -> FlattenBidirectionalCollection<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.joined() -> FlattenSequence<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.last
Added AnyBidirectionalCollection.last
Added AnyBidirectionalCollection.lazy
Added AnyBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyBidirectionalCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyBidirectionalCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyBidirectionalCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnyBidirectionalCollection.reversed() -> ReversedCollection<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnyBidirectionalCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyBidirectionalCollection<Element>]
Added AnyBidirectionalCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnyBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added AnyBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.subscript(_: Range<AnyIndex>) -> AnyBidirectionalCollection<Element>
Added AnyBidirectionalCollection.subscript(_: ClosedRange<AnyIndex>) -> AnyBidirectionalCollection<Element>
Added AnyBidirectionalCollection.underestimatedCount
Added AnyBidirectionalCollection.underestimatedCount
Added AnyBidirectionalCollection.underestimatedCount
Added AnyCollection [struct]
Added AnyCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnyCollection.count
Added AnyCollection.count
Added AnyCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax
Added AnyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyCollection.endIndex
Added AnyCollection.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added AnyCollection.first
Added AnyCollection.first
Added AnyCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added AnyCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnyCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnyCollection.forEach(_: (Element) throws -> Swift.Void) rethrows
Added AnyCollection.formIndex(_: AnyIndex, offsetBy: IntMax)
Added AnyCollection.formIndex(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> Bool
Added AnyCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex
Added AnyCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?
Added AnyCollection.index(of: Element) -> AnyIndex?
Added AnyCollection.index(where: (Element) throws -> Bool) rethrows -> AnyIndex?
Added AnyCollection.indices
Added AnyCollection.init<C : BidirectionalCollection where C.Iterator.Element == Element, C.SubSequence : BidirectionalCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : BidirectionalCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : BidirectionalCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyCollection.init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyCollection.init<C : Collection where C.Iterator.Element == Element, C.SubSequence : Collection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : Collection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : Collection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyCollection.isEmpty
Added AnyCollection.joined() -> FlattenSequence<AnyCollection<Element>>
Added AnyCollection.joined() -> FlattenCollection<AnyCollection<Element>>
Added AnyCollection.lazy
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.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnyCollection.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnyCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnyCollection<Element>]
Added AnyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyCollection<Element>]
Added AnyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnyCollection.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(_: ClosedRange<AnyIndex>) -> AnyCollection<Element>
Added AnyCollection.underestimatedCount
Added AnyCollection.underestimatedCount
Added AnyCollection.underestimatedCount
Added AnyHashable [struct]
Added AnyHashable.base
Added AnyHashable.customMirror
Added AnyHashable.description
Added AnyHashable.hashValue
Added AnyIndex [struct]
Added AnyIterator [struct]
Added AnyIterator.init<I : IteratorProtocol where I.Element == Element>(_: I)
Added AnyRandomAccessCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnyRandomAccessCollection.count
Added AnyRandomAccessCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax
Added AnyRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyRandomAccessCollection.enumerated() -> EnumeratedSequence<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.first
Added AnyRandomAccessCollection.first
Added AnyRandomAccessCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added AnyRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnyRandomAccessCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnyRandomAccessCollection.formIndex(_: AnyIndex, offsetBy: IntMax)
Added AnyRandomAccessCollection.formIndex(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> Bool
Added AnyRandomAccessCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex
Added AnyRandomAccessCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?
Added AnyRandomAccessCollection.index(of: Element) -> AnyIndex?
Added AnyRandomAccessCollection.index(where: (Element) throws -> Bool) rethrows -> AnyIndex?
Added AnyRandomAccessCollection.indices
Added AnyRandomAccessCollection.init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyRandomAccessCollection.joined() -> FlattenBidirectionalCollection<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.joined() -> FlattenCollection<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.joined() -> FlattenSequence<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.last
Added AnyRandomAccessCollection.last
Added AnyRandomAccessCollection.lazy
Added AnyRandomAccessCollection.lazy
Added AnyRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyRandomAccessCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyRandomAccessCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyRandomAccessCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnyRandomAccessCollection.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnyRandomAccessCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyRandomAccessCollection<Element>]
Added AnyRandomAccessCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnyRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added AnyRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyRandomAccessCollection.subscript(_: ClosedRange<AnyIndex>) -> AnyRandomAccessCollection<Element>
Added AnyRandomAccessCollection.underestimatedCount
Added AnyRandomAccessCollection.underestimatedCount
Added AnyRandomAccessCollection.underestimatedCount
Added AnySequence.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnySequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnySequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnySequence.first(where: (Element) throws -> Bool) rethrows -> Element?
Added AnySequence.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnySequence.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnySequence.init<S : Sequence where S.Iterator.Element == Element, S.SubSequence : Sequence, S.SubSequence.Iterator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_: S)
Added AnySequence.init<I : IteratorProtocol where I.Element == Element>(_: () -> I)
Added AnySequence.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.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnySequence.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnySequence.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnySequence.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnySequence.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnySequence.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnySequence.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnySequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added AnySequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnySequence.underestimatedCount
Added AnySequence.underestimatedCount
Added Array.append<S : Sequence where S.Iterator.Element == Element>(contentsOf: S)
Added Array.append<C : Collection where C.Iterator.Element == Element>(contentsOf: C)
Added Array.count
Added Array.customMirror
Added Array.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Array.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Array.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added Array.first
Added Array.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Array.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Array.formIndex(_: Int, offsetBy: Int)
Added Array.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Array.index(of: Element) -> Int?
Added Array.index(where: (Element) throws -> Bool) rethrows -> Int?
Added Array.indices
Added Array.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Array.isEmpty
Added Array.joined() -> FlattenSequence<Array<Element>>
Added Array.joined() -> FlattenBidirectionalCollection<Array<Element>>
Added Array.joined() -> FlattenCollection<Array<Element>>
Added Array.joined(separator: String) -> String
Added Array.last
Added Array.lazy
Added Array.lazy
Added Array.lazy
Added Array.lazy
Added Array.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Array.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Array.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Array.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Array.max() -> Element?
Added Array.min() -> Element?
Added Array.partition(by: (Element) throws -> Bool) rethrows -> Int
Added Array.partition(by: (Element) throws -> Bool) rethrows -> Int
Added Array.replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Added Array.sort()
Added Array.sorted() -> [Element]
Added Array.sorted() -> [Element]
Added Array.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added Array.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Element>]
Added Array.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added Array.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Array.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: Range<Int>) -> MutableSlice<Array<Element>>
Added Array.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added Array.underestimatedCount
Added Array.underestimatedCount
Added ArraySlice.append<C : Collection where C.Iterator.Element == Element>(contentsOf: C)
Added ArraySlice.append<S : Sequence where S.Iterator.Element == Element>(contentsOf: S)
Added ArraySlice.count
Added ArraySlice.customMirror
Added ArraySlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ArraySlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ArraySlice.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added ArraySlice.first
Added ArraySlice.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ArraySlice.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ArraySlice.formIndex(_: Int, offsetBy: Int)
Added ArraySlice.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added ArraySlice.index(of: Element) -> Int?
Added ArraySlice.index(where: (Element) throws -> Bool) rethrows -> Int?
Added ArraySlice.indices
Added ArraySlice.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added ArraySlice.isEmpty
Added ArraySlice.joined() -> FlattenSequence<ArraySlice<Element>>
Added ArraySlice.joined() -> FlattenCollection<ArraySlice<Element>>
Added ArraySlice.joined() -> FlattenBidirectionalCollection<ArraySlice<Element>>
Added ArraySlice.last
Added ArraySlice.lazy
Added ArraySlice.lazy
Added ArraySlice.lazy
Added ArraySlice.lazy
Added ArraySlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ArraySlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ArraySlice.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added ArraySlice.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added ArraySlice.partition(by: (Element) throws -> Bool) rethrows -> Int
Added ArraySlice.partition(by: (Element) throws -> Bool) rethrows -> Int
Added ArraySlice.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added ArraySlice.removeFirst() -> Element
Added ArraySlice.removeLast() -> Element
Added ArraySlice.removeLast(_: Int)
Added ArraySlice.replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Added ArraySlice.sort()
Added ArraySlice.sorted() -> [Element]
Added ArraySlice.sorted() -> [Element]
Added ArraySlice.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Element>]
Added ArraySlice.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added ArraySlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added ArraySlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ArraySlice.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: Range<Int>) -> MutableSlice<ArraySlice<Element>>
Added ArraySlice.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ArraySlice.underestimatedCount
Added ArraySlice.underestimatedCount
Added BidirectionalCollection
Added BidirectionalCollection.formIndex(before: Self.Index)
Added BidirectionalCollection.indices
Added BidirectionalCollection.joined() -> FlattenBidirectionalCollection<Self>
Added BidirectionalCollection.last
Added BidirectionalCollection.last
Added BidirectionalCollection.lazy
Added BidirectionalCollection.subscript(_: Range<Self.Index>) -> BidirectionalSlice<Self>
Added BidirectionalIndexable
Added BidirectionalIndexable.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance
Added BidirectionalIndexable.formIndex(before: Self.Index)
Added BidirectionalIndexable.formIndex(before: Self.Index)
Added BidirectionalIndexable.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index
Added BidirectionalIndexable.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added BidirectionalIndexable.index(before: Self.Index) -> Self.Index
Added BidirectionalSlice [struct]
Added BidirectionalSlice.base
Added BidirectionalSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added BidirectionalSlice.count
Added BidirectionalSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added BidirectionalSlice.dropFirst() -> BidirectionalSlice<Base>
Added BidirectionalSlice.dropFirst(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.dropLast() -> BidirectionalSlice<Base>
Added BidirectionalSlice.dropLast(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added BidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added BidirectionalSlice.endIndex
Added BidirectionalSlice.enumerated() -> EnumeratedSequence<BidirectionalSlice<Base>>
Added BidirectionalSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added BidirectionalSlice.first
Added BidirectionalSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added BidirectionalSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added BidirectionalSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added BidirectionalSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added BidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added BidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added BidirectionalSlice.formIndex(after: Base.Index)
Added BidirectionalSlice.formIndex(before: Base.Index)
Added BidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added BidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added BidirectionalSlice.index(after: Base.Index) -> Base.Index
Added BidirectionalSlice.index(before: Base.Index) -> Base.Index
Added BidirectionalSlice.index(of: Base._Element) -> Base.Index?
Added BidirectionalSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added BidirectionalSlice.indices
Added BidirectionalSlice.init(base: Base, bounds: Range<Base.Index>)
Added BidirectionalSlice.isEmpty
Added BidirectionalSlice.joined() -> FlattenCollection<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined() -> FlattenBidirectionalCollection<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined() -> FlattenSequence<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined(separator: String) -> String
Added BidirectionalSlice.last
Added BidirectionalSlice.lazy
Added BidirectionalSlice.lazy
Added BidirectionalSlice.lazy
Added BidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added BidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added BidirectionalSlice.makeIterator() -> IndexingIterator<BidirectionalSlice<Base>>
Added BidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added BidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added BidirectionalSlice.max() -> Base._Element?
Added BidirectionalSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added BidirectionalSlice.min() -> Base._Element?
Added BidirectionalSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added BidirectionalSlice.popFirst() -> Base._Element?
Added BidirectionalSlice.popLast() -> Base._Element?
Added BidirectionalSlice.prefix(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.prefix(through: Base.Index) -> BidirectionalSlice<Base>
Added BidirectionalSlice.prefix(upTo: Base.Index) -> BidirectionalSlice<Base>
Added BidirectionalSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added BidirectionalSlice.removeFirst() -> Base._Element
Added BidirectionalSlice.removeFirst(_: Int)
Added BidirectionalSlice.removeLast() -> Base._Element
Added BidirectionalSlice.removeLast(_: Int)
Added BidirectionalSlice.reversed() -> ReversedCollection<BidirectionalSlice<Base>>
Added BidirectionalSlice.sorted() -> [Base._Element]
Added BidirectionalSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added BidirectionalSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [BidirectionalSlice<Base>]
Added BidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added BidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<Base>]
Added BidirectionalSlice.startIndex
Added BidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added BidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added BidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: Range<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: Range<Base.Index>) -> BidirectionalSlice<BidirectionalSlice<Base>>
Added BidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: Base.Index) -> Base._Element
Added BidirectionalSlice.suffix(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.suffix(from: Base.Index) -> BidirectionalSlice<Base>
Added BidirectionalSlice.underestimatedCount
Added BidirectionalSlice.underestimatedCount
Added BinaryFloatingPoint
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.init(_: String)
Added Bool.init(_: Bool)
Added Character.customMirror
Added Character.description
Added Character._SmallUTF16.contains(_: UInt16) -> Bool
Added Character._SmallUTF16.contains(where: (UInt16) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF16.count
Added Character._SmallUTF16.distance(from: Int, to: Int) -> Int
Added Character._SmallUTF16.dropFirst() -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.dropFirst(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.dropLast() -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.dropLast(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence) -> Bool
Added Character._SmallUTF16.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF16.enumerated() -> EnumeratedSequence<Character._SmallUTF16>
Added Character._SmallUTF16.filter(_: (UInt16) throws -> Bool) rethrows -> [UInt16]
Added Character._SmallUTF16.first
Added Character._SmallUTF16.first(where: (UInt16) throws -> Bool) rethrows -> UInt16?
Added Character._SmallUTF16.flatMap<SegmentOfResult : Sequence>(_: (UInt16) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Character._SmallUTF16.flatMap<ElementOfResult>(_: (UInt16) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Character._SmallUTF16.forEach(_: (UInt16) throws -> Void) rethrows
Added Character._SmallUTF16.formIndex(_: Int, offsetBy: Int)
Added Character._SmallUTF16.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Character._SmallUTF16.formIndex(after: Int)
Added Character._SmallUTF16.formIndex(before: Int)
Added Character._SmallUTF16.index(_: Int, offsetBy: Int) -> Int
Added Character._SmallUTF16.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added Character._SmallUTF16.index(after: Int) -> Int
Added Character._SmallUTF16.index(before: Int) -> Int
Added Character._SmallUTF16.index(of: UInt16) -> Int?
Added Character._SmallUTF16.index(where: (UInt16) throws -> Bool) rethrows -> Int?
Added Character._SmallUTF16.indices
Added Character._SmallUTF16.isEmpty
Added Character._SmallUTF16.last
Added Character._SmallUTF16.lazy
Added Character._SmallUTF16.lazy
Added Character._SmallUTF16.lazy
Added Character._SmallUTF16.lazy
Added Character._SmallUTF16.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence) -> Bool
Added Character._SmallUTF16.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF16.makeIterator() -> IndexingIterator<Character._SmallUTF16>
Added Character._SmallUTF16.map<T>(_: (UInt16) throws -> T) rethrows -> [T]
Added Character._SmallUTF16.map<T>(_: (UInt16) throws -> T) rethrows -> [T]
Added Character._SmallUTF16.max() -> UInt16?
Added Character._SmallUTF16.max(by: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16?
Added Character._SmallUTF16.min() -> UInt16?
Added Character._SmallUTF16.min(by: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16?
Added Character._SmallUTF16.prefix(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.prefix(through: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.prefix(upTo: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.reduce<Result>(_: Result, _: (Result, UInt16) throws -> Result) rethrows -> Result
Added Character._SmallUTF16.reversed() -> ReversedRandomAccessCollection<Character._SmallUTF16>
Added Character._SmallUTF16.sorted() -> [UInt16]
Added Character._SmallUTF16.sorted(by: (UInt16, UInt16) -> Bool) -> [UInt16]
Added Character._SmallUTF16.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (UInt16) throws -> Bool) rethrows -> [RandomAccessSlice<Character._SmallUTF16>]
Added Character._SmallUTF16.split(separator: UInt16, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<Character._SmallUTF16>]
Added Character._SmallUTF16.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with: PossiblePrefix) -> Bool
Added Character._SmallUTF16.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with: PossiblePrefix, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF16.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.subscript(_: CountableRange<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.subscript(_: Range<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.suffix(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.suffix(from: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.underestimatedCount
Added Character._SmallUTF16.underestimatedCount
Added Character._SmallUTF8.contains(_: UInt8) -> Bool
Added Character._SmallUTF8.contains(where: (UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.count
Added Character._SmallUTF8.distance(from: Int, to: Int) -> Int
Added Character._SmallUTF8.dropFirst() -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.dropFirst(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.dropLast() -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.dropLast(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence) -> Bool
Added Character._SmallUTF8.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.enumerated() -> EnumeratedSequence<Character._SmallUTF8>
Added Character._SmallUTF8.filter(_: (UInt8) throws -> Bool) rethrows -> [UInt8]
Added Character._SmallUTF8.first
Added Character._SmallUTF8.first(where: (UInt8) throws -> Bool) rethrows -> UInt8?
Added Character._SmallUTF8.flatMap<SegmentOfResult : Sequence>(_: (UInt8) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Character._SmallUTF8.flatMap<ElementOfResult>(_: (UInt8) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Character._SmallUTF8.forEach(_: (UInt8) throws -> Void) rethrows
Added Character._SmallUTF8.formIndex(_: Int, offsetBy: Int)
Added Character._SmallUTF8.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Character._SmallUTF8.formIndex(after: Int)
Added Character._SmallUTF8.formIndex(before: Int)
Added Character._SmallUTF8.index(_: Int, offsetBy: Int) -> Int
Added Character._SmallUTF8.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added Character._SmallUTF8.index(after: Int) -> Int
Added Character._SmallUTF8.index(before: Int) -> Int
Added Character._SmallUTF8.index(of: UInt8) -> Int?
Added Character._SmallUTF8.index(where: (UInt8) throws -> Bool) rethrows -> Int?
Added Character._SmallUTF8.indices
Added Character._SmallUTF8.isEmpty
Added Character._SmallUTF8.last
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence) -> Bool
Added Character._SmallUTF8.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.map<T>(_: (UInt8) throws -> T) rethrows -> [T]
Added Character._SmallUTF8.map<T>(_: (UInt8) throws -> T) rethrows -> [T]
Added Character._SmallUTF8.max() -> UInt8?
Added Character._SmallUTF8.max(by: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?
Added Character._SmallUTF8.min() -> UInt8?
Added Character._SmallUTF8.min(by: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?
Added Character._SmallUTF8.prefix(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.prefix(through: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.prefix(upTo: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.reduce<Result>(_: Result, _: (Result, UInt8) throws -> Result) rethrows -> Result
Added Character._SmallUTF8.reversed() -> ReversedRandomAccessCollection<Character._SmallUTF8>
Added Character._SmallUTF8.sorted() -> [UInt8]
Added Character._SmallUTF8.sorted(by: (UInt8, UInt8) -> Bool) -> [UInt8]
Added Character._SmallUTF8.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (UInt8) throws -> Bool) rethrows -> [RandomAccessSlice<Character._SmallUTF8>]
Added Character._SmallUTF8.split(separator: UInt8, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<Character._SmallUTF8>]
Added Character._SmallUTF8.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with: PossiblePrefix) -> Bool
Added Character._SmallUTF8.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with: PossiblePrefix, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.subscript(_: Range<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.subscript(_: CountableRange<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.suffix(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.suffix(from: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.underestimatedCount
Added Character._SmallUTF8.underestimatedCount
Added ClosedRange [struct]
Added ClosedRange.customMirror
Added ClosedRange.description
Added ClosedRange.isEmpty
Added ClosedRange.lowerBound
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 : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<ClosedRangeIterator<Bound>>
Added ClosedRangeIterator.joined(separator: String) -> String
Added ClosedRangeIterator.lazy
Added ClosedRangeIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added ClosedRangeIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added ClosedRangeIterator.makeIterator() -> ClosedRangeIterator<Bound>
Added ClosedRangeIterator.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added ClosedRangeIterator.max() -> Bound?
Added ClosedRangeIterator.max(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added ClosedRangeIterator.min() -> Bound?
Added ClosedRangeIterator.min(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added ClosedRangeIterator.next() -> Bound?
Added ClosedRangeIterator.prefix(_: Int) -> AnySequence<Bound>
Added ClosedRangeIterator.reduce<Result>(_: Result, _: (Result, Bound) throws -> Result) rethrows -> Result
Added ClosedRangeIterator.reversed() -> [Bound]
Added ClosedRangeIterator.sorted() -> [Bound]
Added ClosedRangeIterator.sorted(by: (Bound, Bound) -> Bool) -> [Bound]
Added ClosedRangeIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Bound) throws -> Bool) rethrows -> [AnySequence<Bound>]
Added ClosedRangeIterator.split(separator: Bound, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Bound>]
Added ClosedRangeIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix) -> Bool
Added ClosedRangeIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added ClosedRangeIterator.suffix(_: Int) -> AnySequence<Bound>
Added ClosedRangeIterator.underestimatedCount
Added Collection
Added Collection.count
Added Collection.count
Added Collection.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance
Added Collection.first
Added Collection.first
Added Collection.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index
Added Collection.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added Collection.index(of: Self.Iterator.Element) -> Self.Index?
Added Collection.index(where: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Index?
Added Collection.indices
Added Collection.indices
Added Collection.isEmpty
Added Collection.isEmpty
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.prefix(through: Self.Index) -> Self.SubSequence
Added Collection.prefix(through: Self.Index) -> Self.SubSequence
Added Collection.prefix(upTo: Self.Index) -> Self.SubSequence
Added Collection.prefix(upTo: Self.Index) -> Self.SubSequence
Added Collection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Self.Iterator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Added Collection.split(separator: Self.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Self.SubSequence]
Added Collection.subscript(_: Range<Self.Index>) -> Self.SubSequence
Added Collection.subscript(_: Range<Self.Index>) -> Slice<Self>
Added Collection.suffix(from: Self.Index) -> Self.SubSequence
Added Collection.suffix(from: Self.Index) -> Self.SubSequence
Added CollectionOfOne.count
Added CollectionOfOne.distance(from: Int, to: Int) -> Int
Added CollectionOfOne.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added CollectionOfOne.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added CollectionOfOne.first
Added CollectionOfOne.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added CollectionOfOne.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added CollectionOfOne.formIndex(_: Int, offsetBy: Int)
Added CollectionOfOne.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added CollectionOfOne.formIndex(after: Int)
Added CollectionOfOne.formIndex(before: Int)
Added CollectionOfOne.index(_: Int, offsetBy: Int) -> Int
Added CollectionOfOne.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added CollectionOfOne.index(of: Element) -> Int?
Added CollectionOfOne.index(where: (Element) throws -> Bool) rethrows -> Int?
Added CollectionOfOne.indices
Added CollectionOfOne.isEmpty
Added CollectionOfOne.joined() -> FlattenSequence<CollectionOfOne<Element>>
Added CollectionOfOne.joined() -> FlattenCollection<CollectionOfOne<Element>>
Added CollectionOfOne.joined() -> FlattenBidirectionalCollection<CollectionOfOne<Element>>
Added CollectionOfOne.joined(separator: String) -> String
Added CollectionOfOne.last
Added CollectionOfOne.lazy
Added CollectionOfOne.lazy
Added CollectionOfOne.lazy
Added CollectionOfOne.lazy
Added CollectionOfOne.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added CollectionOfOne.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added CollectionOfOne.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added CollectionOfOne.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added CollectionOfOne.partition(by: (Element) throws -> Bool) rethrows -> Int
Added CollectionOfOne.partition(by: (Element) throws -> Bool) rethrows -> Int
Added CollectionOfOne.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added CollectionOfOne.sort()
Added CollectionOfOne.sorted() -> [Element]
Added CollectionOfOne.sorted() -> [Element]
Added CollectionOfOne.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRandomAccessSlice<CollectionOfOne<Element>>]
Added CollectionOfOne.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added CollectionOfOne.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added CollectionOfOne.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added CollectionOfOne.subscript(_: CountableRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: ClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: CountableRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: ClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: Range<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: Range<Int>) -> MutableSlice<CollectionOfOne<Element>>
Added CollectionOfOne.underestimatedCount
Added CollectionOfOne.underestimatedCount
Added 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.count
Added ContiguousArray.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ContiguousArray.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ContiguousArray.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added ContiguousArray.first
Added ContiguousArray.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ContiguousArray.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ContiguousArray.formIndex(_: Int, offsetBy: Int)
Added ContiguousArray.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added ContiguousArray.index(of: Element) -> Int?
Added ContiguousArray.index(where: (Element) throws -> Bool) rethrows -> Int?
Added ContiguousArray.indices
Added ContiguousArray.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added ContiguousArray.init(repeating: Element, count: Int)
Added ContiguousArray.isEmpty
Added ContiguousArray.joined() -> FlattenBidirectionalCollection<ContiguousArray<Element>>
Added ContiguousArray.joined() -> FlattenCollection<ContiguousArray<Element>>
Added ContiguousArray.joined() -> FlattenSequence<ContiguousArray<Element>>
Added ContiguousArray.joined(separator: String) -> String
Added ContiguousArray.last
Added ContiguousArray.lazy
Added ContiguousArray.lazy
Added ContiguousArray.lazy
Added ContiguousArray.lazy
Added ContiguousArray.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ContiguousArray.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ContiguousArray.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added ContiguousArray.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added ContiguousArray.partition(by: (Element) throws -> Bool) rethrows -> Int
Added ContiguousArray.partition(by: (Element) throws -> Bool) rethrows -> Int
Added ContiguousArray.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.sort()
Added ContiguousArray.sorted() -> [Element]
Added ContiguousArray.sorted() -> [Element]
Added ContiguousArray.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added ContiguousArray.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Element>]
Added ContiguousArray.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added ContiguousArray.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ContiguousArray.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: Range<Int>) -> MutableSlice<ContiguousArray<Element>>
Added ContiguousArray.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.underestimatedCount
Added ContiguousArray.underestimatedCount
Added CountableClosedRange [struct]
Added CountableClosedRange.clamped(to: CountableClosedRange<Bound>) -> CountableClosedRange<Bound>
Added CountableClosedRange.contains(_: Bound) -> Bool
Added CountableClosedRange.contains(where: (Bound) throws -> Bool) rethrows -> Bool
Added CountableClosedRange.count
Added CountableClosedRange.customMirror
Added CountableClosedRange.debugDescription
Added CountableClosedRange.description
Added CountableClosedRange.distance(from: ClosedRangeIndex<Bound>, to: ClosedRangeIndex<Bound>) -> Bound.Stride
Added CountableClosedRange.dropFirst() -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.dropFirst(_: Int) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.dropLast() -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.dropLast(_: Int) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added CountableClosedRange.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableClosedRange.endIndex
Added CountableClosedRange.enumerated() -> EnumeratedSequence<CountableClosedRange<Bound>>
Added CountableClosedRange.filter(_: (Bound) throws -> Bool) rethrows -> [Bound]
Added CountableClosedRange.first
Added CountableClosedRange.first(where: (Bound) throws -> Bool) rethrows -> Bound?
Added CountableClosedRange.flatMap<SegmentOfResult : Sequence>(_: (Bound) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added CountableClosedRange.flatMap<ElementOfResult>(_: (Bound) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added CountableClosedRange.forEach(_: (Bound) throws -> Void) rethrows
Added CountableClosedRange.formIndex(_: ClosedRangeIndex<Bound>, offsetBy: Bound.Stride)
Added CountableClosedRange.formIndex(_: ClosedRangeIndex<Bound>, offsetBy: Bound.Stride, limitedBy: ClosedRangeIndex<Bound>) -> Bool
Added CountableClosedRange.formIndex(after: ClosedRangeIndex<Bound>)
Added CountableClosedRange.formIndex(before: ClosedRangeIndex<Bound>)
Added CountableClosedRange.index(_: ClosedRangeIndex<Bound>, offsetBy: Bound.Stride) -> ClosedRangeIndex<Bound>
Added CountableClosedRange.index(_: ClosedRangeIndex<Bound>, offsetBy: Bound.Stride, limitedBy: ClosedRangeIndex<Bound>) -> ClosedRangeIndex<Bound>?
Added CountableClosedRange.index(after: ClosedRangeIndex<Bound>) -> ClosedRangeIndex<Bound>
Added CountableClosedRange.index(before: ClosedRangeIndex<Bound>) -> ClosedRangeIndex<Bound>
Added CountableClosedRange.index(of: Bound) -> ClosedRangeIndex<Bound>?
Added CountableClosedRange.index(where: (Bound) throws -> Bool) rethrows -> ClosedRangeIndex<Bound>?
Added CountableClosedRange.indices
Added CountableClosedRange.indices
Added CountableClosedRange.init(_: Range<Bound>)
Added CountableClosedRange.init(_: CountableClosedRange<Bound>)
Added CountableClosedRange.init(_: ClosedRange<Bound>)
Added CountableClosedRange.init(_: CountableRange<Bound>)
Added CountableClosedRange.init(uncheckedBounds: (lower: Bound, upper: Bound))
Added CountableClosedRange.isEmpty
Added CountableClosedRange.isEmpty
Added CountableClosedRange.joined() -> FlattenSequence<CountableClosedRange<Bound>>
Added CountableClosedRange.joined() -> FlattenBidirectionalCollection<CountableClosedRange<Bound>>
Added CountableClosedRange.joined() -> FlattenCollection<CountableClosedRange<Bound>>
Added CountableClosedRange.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<CountableClosedRange<Bound>>
Added CountableClosedRange.joined(separator: String) -> String
Added CountableClosedRange.last
Added CountableClosedRange.lazy
Added CountableClosedRange.lazy
Added CountableClosedRange.lazy
Added CountableClosedRange.lazy
Added CountableClosedRange.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added CountableClosedRange.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableClosedRange.lowerBound
Added CountableClosedRange.makeIterator() -> ClosedRangeIterator<Bound>
Added CountableClosedRange.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added CountableClosedRange.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added CountableClosedRange.max() -> Bound?
Added CountableClosedRange.max(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added CountableClosedRange.min() -> Bound?
Added CountableClosedRange.min(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added CountableClosedRange.overlaps(_: CountableClosedRange<Bound>) -> Bool
Added CountableClosedRange.overlaps(_: ClosedRange<Bound>) -> Bool
Added CountableClosedRange.overlaps(_: Range<Bound>) -> Bool
Added CountableClosedRange.overlaps(_: CountableRange<Bound>) -> Bool
Added CountableClosedRange.prefix(_: Int) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.prefix(through: ClosedRangeIndex<Bound>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.prefix(upTo: ClosedRangeIndex<Bound>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.reduce<Result>(_: Result, _: (Result, Bound) throws -> Result) rethrows -> Result
Added CountableClosedRange.reversed() -> ReversedRandomAccessCollection<CountableClosedRange<Bound>>
Added CountableClosedRange.sorted() -> [Bound]
Added CountableClosedRange.sorted(by: (Bound, Bound) -> Bool) -> [Bound]
Added CountableClosedRange.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Bound) throws -> Bool) rethrows -> [RandomAccessSlice<CountableClosedRange<Bound>>]
Added CountableClosedRange.split(separator: Bound, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<CountableClosedRange<Bound>>]
Added CountableClosedRange.startIndex
Added CountableClosedRange.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix) -> Bool
Added CountableClosedRange.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableClosedRange.subscript(_: ClosedRangeIndex<Bound>) -> Bound
Added CountableClosedRange.subscript(_: Range<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.subscript(_: Range<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.subscript(_: ClosedRange<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.suffix(_: Int) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.suffix(from: ClosedRangeIndex<Bound>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.underestimatedCount
Added CountableClosedRange.underestimatedCount
Added CountableClosedRange.upperBound
Added CountableRange [struct]
Added CountableRange.clamped(to: CountableRange<Bound>) -> CountableRange<Bound>
Added CountableRange.contains(_: Bound) -> Bool
Added CountableRange.contains(where: (Bound) throws -> Bool) rethrows -> Bool
Added CountableRange.count
Added CountableRange.customMirror
Added CountableRange.debugDescription
Added CountableRange.description
Added CountableRange.distance(from: Bound, to: Bound) -> Bound.Stride
Added CountableRange.dropFirst() -> CountableRange<Bound>
Added CountableRange.dropFirst(_: Int) -> CountableRange<Bound>
Added CountableRange.dropLast() -> CountableRange<Bound>
Added CountableRange.dropLast(_: Int) -> CountableRange<Bound>
Added CountableRange.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added CountableRange.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableRange.endIndex
Added CountableRange.enumerated() -> EnumeratedSequence<CountableRange<Bound>>
Added CountableRange.filter(_: (Bound) throws -> Bool) rethrows -> [Bound]
Added CountableRange.first
Added CountableRange.first(where: (Bound) throws -> Bool) rethrows -> Bound?
Added CountableRange.flatMap<SegmentOfResult : Sequence>(_: (Bound) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added CountableRange.flatMap<ElementOfResult>(_: (Bound) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added CountableRange.forEach(_: (Bound) throws -> Void) rethrows
Added CountableRange.formIndex(_: Bound, offsetBy: Bound.Stride)
Added CountableRange.formIndex(_: Bound, offsetBy: Bound.Stride, limitedBy: Bound) -> Bool
Added CountableRange.formIndex(after: Bound)
Added CountableRange.formIndex(before: Bound)
Added CountableRange.index(_: Bound, offsetBy: Bound.Stride) -> Bound
Added CountableRange.index(_: Bound, offsetBy: Bound.Stride, limitedBy: Bound) -> Bound?
Added CountableRange.index(after: Bound) -> Bound
Added CountableRange.index(before: Bound) -> Bound
Added CountableRange.index(of: Bound) -> Bound?
Added CountableRange.index(where: (Bound) throws -> Bool) rethrows -> Bound?
Added CountableRange.indices
Added CountableRange.indices
Added CountableRange.init(_: CountableRange<Bound>)
Added CountableRange.init(_: Range<Bound>)
Added CountableRange.init(_: CountableClosedRange<Bound>)
Added CountableRange.init(_: ClosedRange<Bound>)
Added CountableRange.init(uncheckedBounds: (lower: Bound, upper: Bound))
Added CountableRange.isEmpty
Added CountableRange.isEmpty
Added CountableRange.joined() -> FlattenSequence<CountableRange<Bound>>
Added CountableRange.joined() -> FlattenCollection<CountableRange<Bound>>
Added CountableRange.joined() -> FlattenBidirectionalCollection<CountableRange<Bound>>
Added CountableRange.joined(separator: String) -> String
Added CountableRange.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<CountableRange<Bound>>
Added CountableRange.last
Added CountableRange.lazy
Added CountableRange.lazy
Added CountableRange.lazy
Added CountableRange.lazy
Added CountableRange.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added CountableRange.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableRange.lowerBound
Added CountableRange.makeIterator() -> IndexingIterator<CountableRange<Bound>>
Added CountableRange.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added CountableRange.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added CountableRange.max() -> Bound?
Added CountableRange.max(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added CountableRange.min() -> Bound?
Added CountableRange.min(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added CountableRange.overlaps(_: CountableRange<Bound>) -> Bool
Added CountableRange.overlaps(_: CountableClosedRange<Bound>) -> Bool
Added CountableRange.overlaps(_: ClosedRange<Bound>) -> Bool
Added CountableRange.overlaps(_: Range<Bound>) -> Bool
Added CountableRange.popFirst() -> Bound?
Added CountableRange.popLast() -> Bound?
Added CountableRange.prefix(_: Int) -> CountableRange<Bound>
Added CountableRange.prefix(through: Bound) -> CountableRange<Bound>
Added CountableRange.prefix(upTo: Bound) -> CountableRange<Bound>
Added CountableRange.reduce<Result>(_: Result, _: (Result, Bound) throws -> Result) rethrows -> Result
Added CountableRange.removeFirst() -> Bound
Added CountableRange.removeFirst(_: Int)
Added CountableRange.removeLast() -> Bound
Added CountableRange.removeLast(_: Int)
Added CountableRange.reversed() -> ReversedRandomAccessCollection<CountableRange<Bound>>
Added CountableRange.sorted() -> [Bound]
Added CountableRange.sorted(by: (Bound, Bound) -> Bool) -> [Bound]
Added CountableRange.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Bound) throws -> Bool) rethrows -> [CountableRange<Bound>]
Added CountableRange.split(separator: Bound, maxSplits: Int, omittingEmptySubsequences: Bool) -> [CountableRange<Bound>]
Added CountableRange.startIndex
Added CountableRange.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix) -> Bool
Added CountableRange.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added CountableRange.subscript(_: CountableClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: CountableRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: CountableClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: Bound) -> Bound
Added CountableRange.subscript(_: CountableRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: Range<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: ClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: ClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.suffix(_: Int) -> CountableRange<Bound>
Added CountableRange.suffix(from: Bound) -> CountableRange<Bound>
Added CountableRange.underestimatedCount
Added CountableRange.underestimatedCount
Added CountableRange.upperBound
Added CVarArg
Added DefaultBidirectionalIndices [struct]
Added DefaultBidirectionalIndices.contains(_: Elements.Index) -> Bool
Added DefaultBidirectionalIndices.contains(where: (Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultBidirectionalIndices.count
Added DefaultBidirectionalIndices.distance(from: Elements.Index, to: Elements.Index) -> Int
Added DefaultBidirectionalIndices.dropFirst() -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.dropFirst(_: Int) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.dropLast() -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.dropLast(_: Int) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultBidirectionalIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultBidirectionalIndices.endIndex
Added DefaultBidirectionalIndices.enumerated() -> EnumeratedSequence<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.filter(_: (Elements.Index) throws -> Bool) rethrows -> [Elements.Index]
Added DefaultBidirectionalIndices.first
Added DefaultBidirectionalIndices.first(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultBidirectionalIndices.flatMap<SegmentOfResult : Sequence>(_: (Elements.Index) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added DefaultBidirectionalIndices.flatMap<ElementOfResult>(_: (Elements.Index) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added DefaultBidirectionalIndices.forEach(_: (Elements.Index) throws -> Void) rethrows
Added DefaultBidirectionalIndices.formIndex(_: Elements.Index, offsetBy: Int)
Added DefaultBidirectionalIndices.formIndex(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Bool
Added DefaultBidirectionalIndices.formIndex(after: Elements.Index)
Added DefaultBidirectionalIndices.formIndex(before: Elements.Index)
Added DefaultBidirectionalIndices.index(_: Elements.Index, offsetBy: Int) -> Elements.Index
Added DefaultBidirectionalIndices.index(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Elements.Index?
Added DefaultBidirectionalIndices.index(after: Elements.Index) -> Elements.Index
Added DefaultBidirectionalIndices.index(before: Elements.Index) -> Elements.Index
Added DefaultBidirectionalIndices.index(of: Elements.Index) -> Elements.Index?
Added DefaultBidirectionalIndices.index(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultBidirectionalIndices.indices
Added DefaultBidirectionalIndices.indices
Added DefaultBidirectionalIndices.isEmpty
Added DefaultBidirectionalIndices.joined() -> FlattenCollection<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.joined() -> FlattenSequence<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.joined() -> FlattenBidirectionalCollection<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.joined(separator: String) -> String
Added DefaultBidirectionalIndices.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.last
Added DefaultBidirectionalIndices.lazy
Added DefaultBidirectionalIndices.lazy
Added DefaultBidirectionalIndices.lazy
Added DefaultBidirectionalIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultBidirectionalIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultBidirectionalIndices.makeIterator() -> IndexingIterator<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultBidirectionalIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultBidirectionalIndices.max() -> Elements.Index?
Added DefaultBidirectionalIndices.max(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultBidirectionalIndices.min() -> Elements.Index?
Added DefaultBidirectionalIndices.min(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultBidirectionalIndices.popFirst() -> Elements.Index?
Added DefaultBidirectionalIndices.popLast() -> Elements.Index?
Added DefaultBidirectionalIndices.prefix(_: Int) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.prefix(through: Elements.Index) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.prefix(upTo: Elements.Index) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.reduce<Result>(_: Result, _: (Result, Elements.Index) throws -> Result) rethrows -> Result
Added DefaultBidirectionalIndices.removeFirst() -> Elements.Index
Added DefaultBidirectionalIndices.removeFirst(_: Int)
Added DefaultBidirectionalIndices.removeLast() -> Elements.Index
Added DefaultBidirectionalIndices.removeLast(_: Int)
Added DefaultBidirectionalIndices.reversed() -> ReversedCollection<DefaultBidirectionalIndices<Elements>>
Added DefaultBidirectionalIndices.sorted() -> [Elements.Index]
Added DefaultBidirectionalIndices.sorted(by: (Elements.Index, Elements.Index) -> Bool) -> [Elements.Index]
Added DefaultBidirectionalIndices.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Elements.Index) throws -> Bool) rethrows -> [DefaultBidirectionalIndices<Elements>]
Added DefaultBidirectionalIndices.split(separator: Elements.Index, maxSplits: Int, omittingEmptySubsequences: Bool) -> [DefaultBidirectionalIndices<Elements>]
Added DefaultBidirectionalIndices.startIndex
Added DefaultBidirectionalIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix) -> Bool
Added DefaultBidirectionalIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultBidirectionalIndices.subscript(_: Range<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: CountableRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: CountableClosedRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: Elements.Index) -> Elements.Index
Added DefaultBidirectionalIndices.suffix(_: Int) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.suffix(from: Elements.Index) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.underestimatedCount
Added DefaultBidirectionalIndices.underestimatedCount
Added DefaultIndices [struct]
Added DefaultIndices.count
Added DefaultIndices.distance(from: Elements.Index, to: Elements.Index) -> Int
Added DefaultIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultIndices.endIndex
Added DefaultIndices.first
Added DefaultIndices.flatMap<ElementOfResult>(_: (Elements.Index) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added DefaultIndices.flatMap<SegmentOfResult : Sequence>(_: (Elements.Index) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added DefaultIndices.formIndex(_: Elements.Index, offsetBy: Int)
Added DefaultIndices.formIndex(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Bool
Added DefaultIndices.index(_: Elements.Index, offsetBy: Int) -> Elements.Index
Added DefaultIndices.index(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Elements.Index?
Added DefaultIndices.index(of: Elements.Index) -> Elements.Index?
Added DefaultIndices.index(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultIndices.indices
Added DefaultIndices.indices
Added DefaultIndices.isEmpty
Added DefaultIndices.joined() -> FlattenCollection<DefaultIndices<Elements>>
Added DefaultIndices.joined() -> FlattenSequence<DefaultIndices<Elements>>
Added DefaultIndices.lazy
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.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultIndices.max(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultIndices.min(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix) -> Bool
Added DefaultIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultIndices.subscript(_: CountableClosedRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: Elements.Index) -> Elements.Index
Added DefaultIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: CountableRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: Range<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.underestimatedCount
Added DefaultIndices.underestimatedCount
Added DefaultRandomAccessIndices [struct]
Added DefaultRandomAccessIndices.contains(_: Elements.Index) -> Bool
Added DefaultRandomAccessIndices.contains(where: (Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultRandomAccessIndices.count
Added DefaultRandomAccessIndices.distance(from: Elements.Index, to: Elements.Index) -> Int
Added DefaultRandomAccessIndices.dropFirst() -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.dropFirst(_: Int) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.dropLast() -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.dropLast(_: Int) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultRandomAccessIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultRandomAccessIndices.endIndex
Added DefaultRandomAccessIndices.enumerated() -> EnumeratedSequence<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.filter(_: (Elements.Index) throws -> Bool) rethrows -> [Elements.Index]
Added DefaultRandomAccessIndices.first
Added DefaultRandomAccessIndices.first(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultRandomAccessIndices.flatMap<SegmentOfResult : Sequence>(_: (Elements.Index) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added DefaultRandomAccessIndices.flatMap<ElementOfResult>(_: (Elements.Index) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added DefaultRandomAccessIndices.forEach(_: (Elements.Index) throws -> Void) rethrows
Added DefaultRandomAccessIndices.formIndex(_: Elements.Index, offsetBy: Int)
Added DefaultRandomAccessIndices.formIndex(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Bool
Added DefaultRandomAccessIndices.formIndex(after: Elements.Index)
Added DefaultRandomAccessIndices.formIndex(before: Elements.Index)
Added DefaultRandomAccessIndices.index(_: Elements.Index, offsetBy: Int) -> Elements.Index
Added DefaultRandomAccessIndices.index(_: Elements.Index, offsetBy: Int, limitedBy: Elements.Index) -> Elements.Index?
Added DefaultRandomAccessIndices.index(after: Elements.Index) -> Elements.Index
Added DefaultRandomAccessIndices.index(before: Elements.Index) -> Elements.Index
Added DefaultRandomAccessIndices.index(of: Elements.Index) -> Elements.Index?
Added DefaultRandomAccessIndices.index(where: (Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultRandomAccessIndices.indices
Added DefaultRandomAccessIndices.indices
Added DefaultRandomAccessIndices.isEmpty
Added DefaultRandomAccessIndices.joined() -> FlattenCollection<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.joined() -> FlattenSequence<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.joined() -> FlattenBidirectionalCollection<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.joined(separator: String) -> String
Added DefaultRandomAccessIndices.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.last
Added DefaultRandomAccessIndices.lazy
Added DefaultRandomAccessIndices.lazy
Added DefaultRandomAccessIndices.lazy
Added DefaultRandomAccessIndices.lazy
Added DefaultRandomAccessIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultRandomAccessIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultRandomAccessIndices.makeIterator() -> IndexingIterator<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultRandomAccessIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultRandomAccessIndices.max() -> Elements.Index?
Added DefaultRandomAccessIndices.max(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultRandomAccessIndices.min() -> Elements.Index?
Added DefaultRandomAccessIndices.min(by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Elements.Index?
Added DefaultRandomAccessIndices.popFirst() -> Elements.Index?
Added DefaultRandomAccessIndices.popLast() -> Elements.Index?
Added DefaultRandomAccessIndices.prefix(_: Int) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.prefix(through: Elements.Index) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.prefix(upTo: Elements.Index) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.reduce<Result>(_: Result, _: (Result, Elements.Index) throws -> Result) rethrows -> Result
Added DefaultRandomAccessIndices.removeFirst() -> Elements.Index
Added DefaultRandomAccessIndices.removeFirst(_: Int)
Added DefaultRandomAccessIndices.removeLast() -> Elements.Index
Added DefaultRandomAccessIndices.removeLast(_: Int)
Added DefaultRandomAccessIndices.reversed() -> ReversedRandomAccessCollection<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.sorted() -> [Elements.Index]
Added DefaultRandomAccessIndices.sorted(by: (Elements.Index, Elements.Index) -> Bool) -> [Elements.Index]
Added DefaultRandomAccessIndices.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Elements.Index) throws -> Bool) rethrows -> [DefaultRandomAccessIndices<Elements>]
Added DefaultRandomAccessIndices.split(separator: Elements.Index, maxSplits: Int, omittingEmptySubsequences: Bool) -> [DefaultRandomAccessIndices<Elements>]
Added DefaultRandomAccessIndices.startIndex
Added DefaultRandomAccessIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix) -> Bool
Added DefaultRandomAccessIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultRandomAccessIndices.subscript(_: CountableRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: Elements.Index) -> Elements.Index
Added DefaultRandomAccessIndices.subscript(_: CountableClosedRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: Range<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.suffix(_: Int) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.suffix(from: Elements.Index) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.underestimatedCount
Added DefaultRandomAccessIndices.underestimatedCount
Added Dictionary.count
Added Dictionary.customMirror
Added Dictionary.distance(from: DictionaryIndex<Key, Value>, to: DictionaryIndex<Key, Value>) -> Int
Added Dictionary.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (key: Key, value: Value)>(_: OtherSequence, by: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
Added Dictionary.filter(_: (Key, Value) throws -> Bool) rethrows -> [(key: Key, value: Value)]
Added Dictionary.first
Added Dictionary.flatMap<ElementOfResult>(_: (Key, Value) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Dictionary.flatMap<SegmentOfResult : Sequence>(_: (Key, Value) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Dictionary.formIndex(_: DictionaryIndex<Key, Value>, offsetBy: Int)
Added Dictionary.formIndex(_: DictionaryIndex<Key, Value>, offsetBy: Int, limitedBy: DictionaryIndex<Key, Value>) -> Bool
Added Dictionary.formIndex(after: DictionaryIndex<Key, Value>)
Added Dictionary.index(_: DictionaryIndex<Key, Value>, offsetBy: Int) -> DictionaryIndex<Key, Value>
Added Dictionary.index(_: DictionaryIndex<Key, Value>, offsetBy: Int, limitedBy: DictionaryIndex<Key, Value>) -> DictionaryIndex<Key, Value>?
Added Dictionary.index(after: DictionaryIndex<Key, Value>) -> DictionaryIndex<Key, Value>
Added Dictionary.index(where: (Key, Value) throws -> Bool) rethrows -> DictionaryIndex<Key, Value>?
Added Dictionary.indices
Added Dictionary.isEmpty
Added Dictionary.lazy
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.map<T>(_: (Key, Value) throws -> T) rethrows -> [T]
Added Dictionary.map<T>(_: (Key, Value) throws -> T) rethrows -> [T]
Added Dictionary.remove(at: DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
Added Dictionary.removeValue<ConcreteKey : Hashable>(forKey: ConcreteKey) -> Value?
Added Dictionary.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (key: Key, value: Value)>(with: PossiblePrefix, by: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
Added Dictionary.subscript(_: ClosedRange<DictionaryIndex<Key, Value>>) -> Slice<Dictionary<Key, Value>>
Added Dictionary.subscript(_: DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
Added Dictionary.subscript(_: Range<DictionaryIndex<Key, Value>>) -> Slice<Dictionary<Key, Value>>
Added Dictionary.subscript(_: _Hashable) -> Value?
Added Dictionary.underestimatedCount
Added Dictionary.underestimatedCount
Added Dictionary.updateValue<ConcreteKey : Hashable>(_: Value, forKey: ConcreteKey) -> Value?
Added Double.add(_: Double)
Added Double.binade
Added Double.bitPattern
Added Double.customMirror
Added Double.divide(by: Double)
Added Double.exponent
Added Double.exponentBitCount
Added Double.formSquareRoot()
Added Double.isCanonical
Added Double.isSignalingNaN
Added Double.multiply(by: Double)
Added Double.nan
Added Double.negate()
Added Double.nextUp
Added Double.pi
Added Double.sign
Added Double.signalingNaN
Added Double.significand
Added Double.significandWidth
Added Double.subtract(_: Double)
Added Double.ulp
Added EmptyCollection.count
Added EmptyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added EmptyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyCollection.first
Added EmptyCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EmptyCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EmptyCollection.formIndex(_: Int, offsetBy: Int)
Added EmptyCollection.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added EmptyCollection.formIndex(after: Int)
Added EmptyCollection.formIndex(before: Int)
Added EmptyCollection.index(of: Element) -> Int?
Added EmptyCollection.index(where: (Element) throws -> Bool) rethrows -> Int?
Added EmptyCollection.indices
Added EmptyCollection.isEmpty
Added EmptyCollection.joined() -> FlattenSequence<EmptyCollection<Element>>
Added EmptyCollection.joined() -> FlattenBidirectionalCollection<EmptyCollection<Element>>
Added EmptyCollection.joined() -> FlattenCollection<EmptyCollection<Element>>
Added EmptyCollection.joined(separator: String) -> String
Added EmptyCollection.last
Added EmptyCollection.lazy
Added EmptyCollection.lazy
Added EmptyCollection.lazy
Added EmptyCollection.lazy
Added EmptyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added EmptyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added EmptyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added EmptyCollection.partition(by: (Element) throws -> Bool) rethrows -> Int
Added EmptyCollection.partition(by: (Element) throws -> Bool) rethrows -> Int
Added EmptyCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added EmptyCollection.sort()
Added EmptyCollection.sorted() -> [Element]
Added EmptyCollection.sorted() -> [Element]
Added EmptyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [EmptyCollection<Element>]
Added EmptyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added EmptyCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added EmptyCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyCollection.subscript(_: CountableClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: ClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: Range<Int>) -> MutableSlice<EmptyCollection<Element>>
Added EmptyCollection.subscript(_: CountableClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: ClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.underestimatedCount
Added EmptyCollection.underestimatedCount
Added EmptyIterator [struct]
Added EmptyIterator.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added EmptyIterator.dropFirst() -> AnySequence<Element>
Added EmptyIterator.dropFirst(_: Int) -> AnySequence<Element>
Added EmptyIterator.dropLast() -> AnySequence<Element>
Added EmptyIterator.dropLast(_: Int) -> AnySequence<Element>
Added EmptyIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added EmptyIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyIterator.enumerated() -> EnumeratedSequence<EmptyIterator<Element>>
Added EmptyIterator.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added EmptyIterator.first(where: (Element) throws -> Bool) rethrows -> Element?
Added EmptyIterator.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EmptyIterator.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EmptyIterator.forEach(_: (Element) throws -> Void) rethrows
Added EmptyIterator.init()
Added EmptyIterator.joined() -> FlattenSequence<EmptyIterator<Element>>
Added EmptyIterator.joined(separator: String) -> String
Added EmptyIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<EmptyIterator<Element>>
Added EmptyIterator.lazy
Added EmptyIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added EmptyIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyIterator.makeIterator() -> EmptyIterator<Element>
Added EmptyIterator.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added EmptyIterator.max() -> Element?
Added EmptyIterator.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added EmptyIterator.min() -> Element?
Added EmptyIterator.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added EmptyIterator.next() -> Element?
Added EmptyIterator.prefix(_: Int) -> AnySequence<Element>
Added EmptyIterator.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added EmptyIterator.reversed() -> [Element]
Added EmptyIterator.sorted() -> [Element]
Added EmptyIterator.sorted(by: (Element, Element) -> Bool) -> [Element]
Added EmptyIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
Added EmptyIterator.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added EmptyIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added EmptyIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyIterator.suffix(_: Int) -> AnySequence<Element>
Added EmptyIterator.underestimatedCount
Added EnumeratedIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (offset: Int, element: Base.Element)>(_: OtherSequence, by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedIterator.flatMap<ElementOfResult>(_: (Int, Base.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EnumeratedIterator.flatMap<SegmentOfResult : Sequence>(_: (Int, Base.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EnumeratedIterator.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.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (offset: Int, element: Base.Element)>(with: PossiblePrefix, by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedSequence.contains(where: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added EnumeratedSequence.dropFirst(_: Int) -> 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.filter(_: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> [(offset: Int, element: Base.Iterator.Element)]
Added EnumeratedSequence.first(where: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> (offset: Int, element: Base.Iterator.Element)?
Added EnumeratedSequence.flatMap<SegmentOfResult : Sequence>(_: (Int, Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EnumeratedSequence.flatMap<ElementOfResult>(_: (Int, Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EnumeratedSequence.forEach(_: (Int, Base.Iterator.Element) throws -> Void) rethrows
Added EnumeratedSequence.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.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.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 Error
Added ExpressibleByArrayLiteral.init(arrayLiteral: Self.Element)
Added ExpressibleByNilLiteral
Added ExpressibleByStringInterpolation
Added ExpressibleByStringInterpolation.init(stringInterpolation: Self)
Added ExpressibleByStringInterpolation.init<T>(stringInterpolationSegment: T)
Added FlattenBidirectionalCollection.contains(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenBidirectionalCollection.count
Added FlattenBidirectionalCollection.distance(from: FlattenBidirectionalCollectionIndex<Base>, to: FlattenBidirectionalCollectionIndex<Base>) -> Base.IndexDistance
Added FlattenBidirectionalCollection.dropFirst() -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.dropFirst(_: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.dropLast() -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.dropLast(_: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenBidirectionalCollection.enumerated() -> EnumeratedSequence<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.filter(_: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
Added FlattenBidirectionalCollection.first
Added FlattenBidirectionalCollection.first(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added FlattenBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added FlattenBidirectionalCollection.forEach(_: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows
Added FlattenBidirectionalCollection.formIndex(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance)
Added FlattenBidirectionalCollection.formIndex(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: FlattenBidirectionalCollectionIndex<Base>) -> Bool
Added FlattenBidirectionalCollection.formIndex(after: FlattenBidirectionalCollectionIndex<Base>)
Added FlattenBidirectionalCollection.formIndex(before: FlattenBidirectionalCollectionIndex<Base>)
Added FlattenBidirectionalCollection.index(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance) -> FlattenBidirectionalCollectionIndex<Base>
Added FlattenBidirectionalCollection.index(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>?
Added FlattenBidirectionalCollection.index(after: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>
Added FlattenBidirectionalCollection.index(before: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>
Added FlattenBidirectionalCollection.index(of: Base.Iterator.Element.Iterator.Element) -> FlattenBidirectionalCollectionIndex<Base>?
Added FlattenBidirectionalCollection.index(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenBidirectionalCollectionIndex<Base>?
Added FlattenBidirectionalCollection.indices
Added FlattenBidirectionalCollection.isEmpty
Added FlattenBidirectionalCollection.joined() -> FlattenCollection<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined() -> FlattenSequence<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined() -> FlattenBidirectionalCollection<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined(separator: String) -> String
Added FlattenBidirectionalCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.last
Added FlattenBidirectionalCollection.lazy
Added FlattenBidirectionalCollection.lazy
Added FlattenBidirectionalCollection.lazy
Added FlattenBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenBidirectionalCollection.makeIterator() -> FlattenIterator<Base.Iterator>
Added FlattenBidirectionalCollection.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenBidirectionalCollection.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenBidirectionalCollection.max() -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.max(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.min() -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.min(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.prefix(_: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.prefix(through: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.prefix(upTo: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
Added FlattenBidirectionalCollection.reversed() -> ReversedCollection<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.sorted() -> [Base.Iterator.Element.Iterator.Element]
Added FlattenBidirectionalCollection.sorted(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
Added FlattenBidirectionalCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>]
Added FlattenBidirectionalCollection.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>]
Added FlattenBidirectionalCollection.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added FlattenBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix) -> Bool
Added FlattenBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenBidirectionalCollection.subscript(_: FlattenBidirectionalCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element
Added FlattenBidirectionalCollection.subscript(_: ClosedRange<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.subscript(_: Range<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.subscript(_: Range<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.suffix(_: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.suffix(from: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.underestimatedCount
Added FlattenBidirectionalCollection.underestimatedCount
Added FlattenBidirectionalCollection.underestimatedCount
Added FlattenCollection.contains(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenCollection.count
Added FlattenCollection.distance(from: FlattenCollectionIndex<Base>, to: FlattenCollectionIndex<Base>) -> Base.IndexDistance
Added FlattenCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenCollection.filter(_: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
Added FlattenCollection.first
Added FlattenCollection.first(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added FlattenCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added FlattenCollection.forEach(_: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows
Added FlattenCollection.formIndex(_: FlattenCollectionIndex<Base>, offsetBy: Base.IndexDistance)
Added FlattenCollection.formIndex(_: FlattenCollectionIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: FlattenCollectionIndex<Base>) -> Bool
Added FlattenCollection.formIndex(after: FlattenCollectionIndex<Base>)
Added FlattenCollection.index(_: FlattenCollectionIndex<Base>, offsetBy: Base.IndexDistance) -> FlattenCollectionIndex<Base>
Added FlattenCollection.index(_: FlattenCollectionIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: FlattenCollectionIndex<Base>) -> FlattenCollectionIndex<Base>?
Added FlattenCollection.index(after: FlattenCollectionIndex<Base>) -> FlattenCollectionIndex<Base>
Added FlattenCollection.index(of: Base.Iterator.Element.Iterator.Element) -> FlattenCollectionIndex<Base>?
Added FlattenCollection.index(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenCollectionIndex<Base>?
Added FlattenCollection.indices
Added FlattenCollection.joined() -> FlattenCollection<FlattenCollection<Base>>
Added FlattenCollection.joined() -> FlattenSequence<FlattenCollection<Base>>
Added FlattenCollection.lazy
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.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenCollection.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenCollection.max(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenCollection.min(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenCollection.prefix(through: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.prefix(upTo: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
Added FlattenCollection.sorted(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
Added FlattenCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Slice<FlattenCollection<Base>>]
Added FlattenCollection.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<FlattenCollection<Base>>]
Added FlattenCollection.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added FlattenCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix) -> Bool
Added FlattenCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenCollection.subscript(_: Range<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.subscript(_: Range<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.subscript(_: ClosedRange<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.subscript(_: FlattenCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element
Added FlattenCollection.suffix(from: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>>
Added FlattenCollection.underestimatedCount
Added FlattenCollection.underestimatedCount
Added FlattenCollection.underestimatedCount
Added FlattenIterator [struct]
Added FlattenIterator.contains(where: (Base.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenIterator.dropFirst() -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.dropFirst(_: Int) -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.dropLast() -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.dropLast(_: Int) -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element.Iterator.Element>(_: OtherSequence, by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenIterator.enumerated() -> EnumeratedSequence<FlattenIterator<Base>>
Added FlattenIterator.filter(_: (Base.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Element.Iterator.Element]
Added FlattenIterator.first(where: (Base.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Element.Iterator.Element?
Added FlattenIterator.flatMap<ElementOfResult>(_: (Base.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added FlattenIterator.flatMap<SegmentOfResult : Sequence>(_: (Base.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added FlattenIterator.forEach(_: (Base.Element.Iterator.Element) throws -> Void) rethrows
Added FlattenIterator.joined() -> FlattenSequence<FlattenIterator<Base>>
Added FlattenIterator.joined(separator: String) -> String
Added FlattenIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<FlattenIterator<Base>>
Added FlattenIterator.lazy
Added FlattenIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element.Iterator.Element>(_: OtherSequence, by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenIterator.makeIterator() -> FlattenIterator<Base>
Added FlattenIterator.map<T>(_: (Base.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenIterator.max() -> Base.Element.Iterator.Element?
Added FlattenIterator.max(by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Element.Iterator.Element?
Added FlattenIterator.min() -> Base.Element.Iterator.Element?
Added FlattenIterator.min(by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Element.Iterator.Element?
Added FlattenIterator.next() -> Base.Element.Iterator.Element?
Added FlattenIterator.prefix(_: Int) -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.reduce<Result>(_: Result, _: (Result, Base.Element.Iterator.Element) throws -> Result) rethrows -> Result
Added FlattenIterator.reversed() -> [Base.Element.Iterator.Element]
Added FlattenIterator.sorted() -> [Base.Element.Iterator.Element]
Added FlattenIterator.sorted(by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) -> Bool) -> [Base.Element.Iterator.Element]
Added FlattenIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Element.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Element.Iterator.Element>]
Added FlattenIterator.split(separator: Base.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Element.Iterator.Element>]
Added FlattenIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Element.Iterator.Element>(with: PossiblePrefix) -> Bool
Added FlattenIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Element.Iterator.Element>(with: PossiblePrefix, by: (Base.Element.Iterator.Element, Base.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenIterator.suffix(_: Int) -> AnySequence<Base.Element.Iterator.Element>
Added FlattenIterator.underestimatedCount
Added FlattenSequence.contains(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added FlattenSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenSequence.filter(_: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
Added FlattenSequence.first(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenSequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added FlattenSequence.flatMap<ElementOfResult>(_: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added FlattenSequence.forEach(_: (Base.Iterator.Element.Iterator.Element) throws -> Void) rethrows
Added FlattenSequence.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.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added FlattenSequence.max(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenSequence.min(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenSequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
Added FlattenSequence.sorted(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
Added FlattenSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added FlattenSequence.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added FlattenSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix) -> Bool
Added FlattenSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Float.add(_: Float)
Added Float.binade
Added Float.bitPattern
Added Float.customMirror
Added Float.divide(by: Float)
Added Float.exponent
Added Float.exponentBitCount
Added Float.exponentBitPattern
Added Float.formSquareRoot()
Added Float.isCanonical
Added Float.isSignalingNaN
Added Float.multiply(by: Float)
Added Float.nan
Added Float.negate()
Added Float.nextUp
Added Float.pi
Added Float.sign
Added Float.signalingNaN
Added Float.significand
Added Float.significandWidth
Added Float.subtract(_: Float)
Added Float.ulp
Added FloatingPoint
Added FloatingPoint.add(_: Self)
Added FloatingPoint.adding(_: Self) -> Self
Added FloatingPoint.adding(_: Self) -> Self
Added FloatingPoint.addingProduct(_: Self, _: Self) -> Self
Added FloatingPoint.addingProduct(_: Self, _: Self) -> Self
Added FloatingPoint.divide(by: Self)
Added FloatingPoint.divided(by: Self) -> Self
Added FloatingPoint.divided(by: Self) -> Self
Added FloatingPoint.exponent
Added FloatingPoint.floatingPointClass
Added FloatingPoint.floatingPointClass
Added FloatingPoint.infinity
Added FloatingPoint.isFinite
Added FloatingPoint.isInfinite
Added FloatingPoint.isNaN
Added FloatingPoint.isNormal
Added FloatingPoint.isZero
Added FloatingPoint.maximum(_: Self, _: Self) -> Self [class]
Added FloatingPoint.maximum(_: Self, _: Self) -> Self [class]
Added FloatingPoint.maximumMagnitude(_: Self, _: Self) -> Self [class]
Added FloatingPoint.maximumMagnitude(_: Self, _: Self) -> Self [class]
Added FloatingPoint.minimum(_: Self, _: Self) -> Self [class]
Added FloatingPoint.minimum(_: Self, _: Self) -> Self [class]
Added FloatingPoint.minimumMagnitude(_: Self, _: Self) -> Self [class]
Added FloatingPoint.minimumMagnitude(_: Self, _: Self) -> Self [class]
Added FloatingPoint.multiplied(by: Self) -> Self
Added FloatingPoint.multiplied(by: Self) -> Self
Added FloatingPoint.multiply(by: Self)
Added FloatingPoint.nan
Added FloatingPoint.negate()
Added FloatingPoint.negated() -> Self
Added FloatingPoint.negated() -> Self
Added FloatingPoint.nextDown
Added FloatingPoint.nextDown
Added FloatingPoint.nextUp
Added FloatingPoint.pi
Added FloatingPoint.radix
Added FloatingPoint.remainder(dividingBy: Self) -> Self
Added FloatingPoint.remainder(dividingBy: Self) -> Self
Added FloatingPoint.round()
Added FloatingPoint.rounded(_: FloatingPointRoundingRule) -> Self
Added FloatingPoint.rounded(_: FloatingPointRoundingRule) -> Self
Added FloatingPoint.sign
Added FloatingPoint.squareRoot() -> Self
Added FloatingPoint.squareRoot() -> Self
Added FloatingPoint.subtract(_: Self)
Added FloatingPoint.subtracting(_: Self) -> Self
Added FloatingPoint.subtracting(_: Self) -> Self
Added FloatingPoint.truncatingRemainder(dividingBy: Self) -> Self
Added FloatingPoint.truncatingRemainder(dividingBy: Self) -> Self
Added FloatingPoint.ulp
Added FloatingPoint.ulpOfOne
Added FloatingPoint.ulpOfOne
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.UTF16View) -> String.UTF16View.Index
Added Index.samePosition(in: String.UnicodeScalarView) -> String.UnicodeScalarView.Index
Added Indexable.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance
Added Indexable.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance
Added Indexable.formIndex(_: Self.Index, offsetBy: Self.IndexDistance)
Added Indexable.formIndex(_: Self.Index, offsetBy: Self.IndexDistance)
Added Indexable.formIndex(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Bool
Added Indexable.formIndex(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Bool
Added Indexable.formIndex(after: Self.Index)
Added Indexable.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index
Added Indexable.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index
Added Indexable.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added Indexable.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added Indexable.subscript(_: CountableRange<Self.Index>) -> Self.SubSequence
Added Indexable.subscript(_: CountableClosedRange<Self.Index>) -> Self.SubSequence
Added Indexable.subscript(_: ClosedRange<Self.Index>) -> Self.SubSequence
Added IndexableBase
Added IndexableBase.endIndex
Added IndexableBase.formIndex(after: Self.Index)
Added IndexableBase.index(after: Self.Index) -> Self.Index
Added IndexableBase.startIndex
Added IndexableBase.subscript(_: Range<Self.Index>) -> Self.SubSequence
Added IndexableBase.subscript(_: Self.Index) -> Self._Element
Added IndexingIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements._Element>(_: OtherSequence) -> Bool
Added IndexingIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements._Element>(_: OtherSequence, by: (Elements._Element, Elements._Element) throws -> Bool) rethrows -> Bool
Added IndexingIterator.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.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.sorted(by: (Elements._Element, Elements._Element) -> Bool) -> [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 Int.customMirror
Added Int.init(exactly: UInt64)
Added Int.init(exactly: Int8)
Added Int.init(exactly: Int32)
Added Int.init(exactly: Int16)
Added Int.init(exactly: UInt16)
Added Int.init(exactly: Int64)
Added Int.init(exactly: Int)
Added Int.init(exactly: UInt32)
Added Int.init(exactly: UInt8)
Added Int.init(exactly: UInt)
Added Int16.customMirror
Added Int16.init(exactly: Int64)
Added Int16.init(exactly: Int32)
Added Int16.init(exactly: UInt32)
Added Int16.init(exactly: UInt64)
Added Int16.init(exactly: Int16)
Added Int16.init(exactly: UInt16)
Added Int16.init(exactly: UInt)
Added Int16.init(exactly: Int8)
Added Int16.init(exactly: Int)
Added Int16.init(exactly: UInt8)
Added Int32.customMirror
Added Int32.init(exactly: Int64)
Added Int32.init(exactly: UInt64)
Added Int32.init(exactly: Int8)
Added Int32.init(exactly: Int32)
Added Int32.init(exactly: UInt8)
Added Int32.init(exactly: Int16)
Added Int32.init(exactly: UInt)
Added Int32.init(exactly: UInt32)
Added Int32.init(exactly: Int)
Added Int32.init(exactly: UInt16)
Added Int64.customMirror
Added Int64.init(exactly: Int16)
Added Int64.init(exactly: Int32)
Added Int64.init(exactly: UInt32)
Added Int64.init(exactly: Int8)
Added Int64.init(exactly: Int)
Added Int64.init(exactly: UInt64)
Added Int64.init(exactly: UInt16)
Added Int64.init(exactly: UInt8)
Added Int64.init(exactly: UInt)
Added Int64.init(exactly: Int64)
Added Int8.customMirror
Added Int8.init(exactly: UInt64)
Added Int8.init(exactly: UInt32)
Added Int8.init(exactly: Int)
Added Int8.init(exactly: Int8)
Added Int8.init(exactly: Int16)
Added Int8.init(exactly: Int64)
Added Int8.init(exactly: UInt)
Added Int8.init(exactly: UInt8)
Added Int8.init(exactly: UInt16)
Added Int8.init(exactly: Int32)
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.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added IteratorOverOne.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added IteratorOverOne.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added IteratorOverOne.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added IteratorOverOne.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.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
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 IteratorProtocol
Added IteratorSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence) -> Bool
Added IteratorSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence, by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Bool
Added IteratorSequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added IteratorSequence.flatMap<ElementOfResult>(_: (Base.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added IteratorSequence.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.max(by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Base.Element?
Added IteratorSequence.min(by: (Base.Element, Base.Element) throws -> Bool) rethrows -> 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 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.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence) -> Bool
Added JoinedSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added JoinedSequence.filter(_: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
Added JoinedSequence.first(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added JoinedSequence.flatMap<ElementOfResult>(_: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added JoinedSequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added JoinedSequence.forEach(_: (Base.Iterator.Element.Iterator.Element) throws -> Void) rethrows
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.map<T>(_: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T]
Added JoinedSequence.max(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added JoinedSequence.min(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added JoinedSequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
Added JoinedSequence.sorted(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element]
Added JoinedSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added JoinedSequence.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added JoinedSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix) -> Bool
Added JoinedSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyBidirectionalCollection [struct]
Added LazyBidirectionalCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyBidirectionalCollection.count
Added LazyBidirectionalCollection.count
Added LazyBidirectionalCollection.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added LazyBidirectionalCollection.dropFirst() -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.dropFirst(_: Int) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.dropLast() -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.elements
Added LazyBidirectionalCollection.elements
Added LazyBidirectionalCollection.elements
Added LazyBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyBidirectionalCollection.endIndex
Added LazyBidirectionalCollection.enumerated() -> EnumeratedSequence<LazyBidirectionalCollection<Base>>
Added LazyBidirectionalCollection.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterBidirectionalCollection<Base>
Added LazyBidirectionalCollection.first
Added LazyBidirectionalCollection.first
Added LazyBidirectionalCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyBidirectionalCollection.flatMap<SegmentOfResult : Collection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<Base, SegmentOfResult>>>
Added LazyBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<Base, ElementOfResult?>>, ElementOfResult>
Added LazyBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>>
Added LazyBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyBidirectionalCollection.flatMap<SegmentOfResult : Collection where SegmentOfResult : BidirectionalCollection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenBidirectionalCollection<LazyMapBidirectionalCollection<Base, SegmentOfResult>>>
Added LazyBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult>
Added LazyBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<Base, ElementOfResult?>>, ElementOfResult>
Added LazyBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyBidirectionalCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazyBidirectionalCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyBidirectionalCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyBidirectionalCollection.formIndex(after: Base.Index)
Added LazyBidirectionalCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyBidirectionalCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyBidirectionalCollection.index(after: Base.Index) -> Base.Index
Added LazyBidirectionalCollection.index(before: Base.Index) -> Base.Index
Added LazyBidirectionalCollection.index(of: Base.Iterator.Element) -> Base.Index?
Added LazyBidirectionalCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Index?
Added LazyBidirectionalCollection.indices
Added LazyBidirectionalCollection.indices
Added LazyBidirectionalCollection.isEmpty
Added LazyBidirectionalCollection.isEmpty
Added LazyBidirectionalCollection.joined() -> LazyCollection<FlattenBidirectionalCollection<Base>>
Added LazyBidirectionalCollection.joined() -> FlattenSequence<LazyBidirectionalCollection<Base>>
Added LazyBidirectionalCollection.joined() -> LazySequence<FlattenSequence<Base>>
Added LazyBidirectionalCollection.joined() -> FlattenCollection<LazyBidirectionalCollection<Base>>
Added LazyBidirectionalCollection.joined() -> LazyCollection<FlattenCollection<Base>>
Added LazyBidirectionalCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyBidirectionalCollection<Base>>
Added LazyBidirectionalCollection.joined(separator: String) -> String
Added LazyBidirectionalCollection.last
Added LazyBidirectionalCollection.lazy
Added LazyBidirectionalCollection.lazy
Added LazyBidirectionalCollection.lazy
Added LazyBidirectionalCollection.lazy
Added LazyBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyBidirectionalCollection.makeIterator() -> Base.Iterator
Added LazyBidirectionalCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyBidirectionalCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapBidirectionalCollection<Base, U>
Added LazyBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>
Added LazyBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<Base, U>
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) -> [AnySequence<Base.Iterator.Element>]
Added LazyBidirectionalCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [LazyBidirectionalCollection<BidirectionalSlice<Base>>]
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(_: Range<Base.Index>) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.subscript(_: ClosedRange<Base.Index>) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.subscript(_: CountableRange<Base.Index>) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.subscript(_: CountableClosedRange<Base.Index>) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.subscript(_: Base.Index) -> Base.Iterator.Element
Added LazyBidirectionalCollection.suffix(from: Base.Index) -> LazyBidirectionalCollection<BidirectionalSlice<Base>>
Added LazyBidirectionalCollection.underestimatedCount
Added LazyBidirectionalCollection.underestimatedCount
Added LazyBidirectionalCollection.underestimatedCount
Added LazyCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyCollection.count
Added LazyCollection.count
Added LazyCollection.elements
Added LazyCollection.elements
Added LazyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyCollection.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterCollection<Base>
Added LazyCollection.first
Added LazyCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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<SegmentOfResult : Collection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<Base, SegmentOfResult>>>
Added LazyCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<Base, ElementOfResult?>>, ElementOfResult>
Added LazyCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>>
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.indices
Added LazyCollection.isEmpty
Added LazyCollection.joined() -> FlattenCollection<LazyCollection<Base>>
Added LazyCollection.joined() -> FlattenSequence<LazyCollection<Base>>
Added LazyCollection.joined() -> LazyCollection<FlattenCollection<Base>>
Added LazyCollection.joined() -> LazySequence<FlattenSequence<Base>>
Added LazyCollection.lazy
Added LazyCollection.lazy
Added LazyCollection.lazy
Added LazyCollection.lazy
Added LazyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<Base, U>
Added LazyCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>
Added LazyCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyCollection.popFirst() -> Base.Iterator.Element?
Added LazyCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyCollection.removeFirst() -> Base.Iterator.Element
Added LazyCollection.removeFirst(_: Int)
Added LazyCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyCollection<Slice<Base>>]
Added LazyCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazyCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [LazyCollection<Slice<Base>>]
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(_: Base.Index) -> Base.Iterator.Element
Added LazyCollection.subscript(_: CountableRange<Base.Index>) -> LazyCollection<Slice<Base>>
Added LazyCollection.subscript(_: CountableClosedRange<Base.Index>) -> LazyCollection<Slice<Base>>
Added LazyCollection.subscript(_: ClosedRange<Base.Index>) -> LazyCollection<Slice<Base>>
Added LazyCollection.underestimatedCount
Added LazyCollection.underestimatedCount
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<U>(_: (Self.Elements.Iterator.Element) -> U) -> LazyMapCollection<Self.Elements, U>
Added LazyFilterBidirectionalCollection [struct]
Added LazyFilterBidirectionalCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterBidirectionalCollection.count
Added LazyFilterBidirectionalCollection.distance(from: LazyFilterIndex<Base>, to: LazyFilterIndex<Base>) -> Base.IndexDistance
Added LazyFilterBidirectionalCollection.dropFirst() -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.dropFirst(_: Int) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.dropLast() -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.dropLast(_: Int) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.elements
Added LazyFilterBidirectionalCollection.elements
Added LazyFilterBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterBidirectionalCollection.endIndex
Added LazyFilterBidirectionalCollection.enumerated() -> EnumeratedSequence<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterBidirectionalCollection<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.first
Added LazyFilterBidirectionalCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyFilterBidirectionalCollection<Base>, SegmentOfResult>>>
Added LazyFilterBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyFilterBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyFilterBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyFilterBidirectionalCollection<Base>, ElementOfResult?>>, ElementOfResult>
Added LazyFilterBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<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<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyFilterBidirectionalCollection<Base>, ElementOfResult?>>, ElementOfResult>
Added LazyFilterBidirectionalCollection.flatMap<SegmentOfResult : Collection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<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() -> FlattenCollection<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.joined() -> LazyCollection<FlattenCollection<LazyFilterBidirectionalCollection<Base>>>
Added LazyFilterBidirectionalCollection.joined() -> FlattenSequence<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.joined() -> LazySequence<FlattenSequence<LazyFilterBidirectionalCollection<Base>>>
Added LazyFilterBidirectionalCollection.joined() -> FlattenBidirectionalCollection<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.joined() -> LazyCollection<FlattenBidirectionalCollection<LazyFilterBidirectionalCollection<Base>>>
Added LazyFilterBidirectionalCollection.joined(separator: String) -> String
Added LazyFilterBidirectionalCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.last
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lazy
Added LazyFilterBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterBidirectionalCollection.makeIterator() -> LazyFilterIterator<Base.Iterator>
Added LazyFilterBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<LazyFilterBidirectionalCollection<Base>, U>
Added LazyFilterBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<Base>, U>
Added LazyFilterBidirectionalCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyFilterBidirectionalCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyFilterBidirectionalCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterBidirectionalCollection<Base>, U>
Added LazyFilterBidirectionalCollection.max() -> Base.Iterator.Element?
Added LazyFilterBidirectionalCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterBidirectionalCollection.min() -> Base.Iterator.Element?
Added LazyFilterBidirectionalCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterBidirectionalCollection.prefix(_: Int) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.prefix(through: LazyFilterIndex<Base>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.prefix(upTo: LazyFilterIndex<Base>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyFilterBidirectionalCollection.reversed() -> LazyBidirectionalCollection<ReversedCollection<LazyFilterBidirectionalCollection<Base>>>
Added LazyFilterBidirectionalCollection.sorted() -> [Base.Iterator.Element]
Added LazyFilterBidirectionalCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyFilterBidirectionalCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>]
Added LazyFilterBidirectionalCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>]
Added LazyFilterBidirectionalCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
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(_: Range<LazyFilterIndex<Base>>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.subscript(_: ClosedRange<LazyFilterIndex<Base>>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.subscript(_: Range<LazyFilterIndex<Base>>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.subscript(_: LazyFilterIndex<Base>) -> Base.Iterator.Element
Added LazyFilterBidirectionalCollection.suffix(_: Int) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.suffix(from: LazyFilterIndex<Base>) -> BidirectionalSlice<LazyFilterBidirectionalCollection<Base>>
Added LazyFilterBidirectionalCollection.underestimatedCount
Added LazyFilterBidirectionalCollection.underestimatedCount
Added LazyFilterCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterCollection.count
Added LazyFilterCollection.distance(from: LazyFilterIndex<Base>, to: LazyFilterIndex<Base>) -> Base.IndexDistance
Added LazyFilterCollection.elements
Added LazyFilterCollection.elements
Added LazyFilterCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterCollection.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterCollection<LazyFilterCollection<Base>>
Added LazyFilterCollection.first
Added LazyFilterCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyFilterCollection<Base>, ElementOfResult?>>, ElementOfResult>
Added LazyFilterCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyFilterCollection<Base>, SegmentOfResult>>>
Added LazyFilterCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyFilterCollection<Base>, ElementOfResult?>>, ElementOfResult>
Added LazyFilterCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyFilterCollection.flatMap<SegmentOfResult : Collection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyFilterCollection<Base>, SegmentOfResult>>>
Added LazyFilterCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyFilterCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazyFilterCollection.formIndex(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance)
Added LazyFilterCollection.formIndex(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: LazyFilterIndex<Base>) -> Bool
Added LazyFilterCollection.index(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance) -> LazyFilterIndex<Base>
Added LazyFilterCollection.index(_: LazyFilterIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: LazyFilterIndex<Base>) -> LazyFilterIndex<Base>?
Added LazyFilterCollection.index(of: Base.Iterator.Element) -> LazyFilterIndex<Base>?
Added LazyFilterCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> LazyFilterIndex<Base>?
Added LazyFilterCollection.indices
Added LazyFilterCollection.joined() -> LazyCollection<FlattenCollection<LazyFilterCollection<Base>>>
Added LazyFilterCollection.joined() -> FlattenSequence<LazyFilterCollection<Base>>
Added LazyFilterCollection.joined() -> LazySequence<FlattenSequence<LazyFilterCollection<Base>>>
Added LazyFilterCollection.joined() -> FlattenCollection<LazyFilterCollection<Base>>
Added LazyFilterCollection.lazy
Added LazyFilterCollection.lazy
Added LazyFilterCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<LazyFilterCollection<Base>, U>
Added LazyFilterCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyFilterCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterCollection<Base>, U>
Added LazyFilterCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyFilterCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterCollection.prefix(through: LazyFilterIndex<Base>) -> Slice<LazyFilterCollection<Base>>
Added LazyFilterCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyFilterCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyFilterCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [Slice<LazyFilterCollection<Base>>]
Added LazyFilterCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<LazyFilterCollection<Base>>]
Added LazyFilterCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
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(_: Range<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>>
Added LazyFilterCollection.subscript(_: ClosedRange<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>>
Added LazyFilterCollection.subscript(_: Range<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>>
Added LazyFilterCollection.subscript(_: LazyFilterIndex<Base>) -> Base.Iterator.Element
Added LazyFilterCollection.underestimatedCount
Added LazyFilterCollection.underestimatedCount
Added LazyFilterIterator [struct]
Added LazyFilterIterator.base
Added LazyFilterIterator.contains(where: (Base.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterIterator.dropFirst() -> AnySequence<Base.Element>
Added LazyFilterIterator.dropFirst(_: Int) -> AnySequence<Base.Element>
Added LazyFilterIterator.dropLast() -> AnySequence<Base.Element>
Added LazyFilterIterator.dropLast(_: Int) -> AnySequence<Base.Element>
Added LazyFilterIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence) -> Bool
Added LazyFilterIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence, by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterIterator.enumerated() -> EnumeratedSequence<LazyFilterIterator<Base>>
Added LazyFilterIterator.filter(_: (Base.Element) throws -> Bool) rethrows -> [Base.Element]
Added LazyFilterIterator.first(where: (Base.Element) throws -> Bool) rethrows -> Base.Element?
Added LazyFilterIterator.flatMap<SegmentOfResult : Sequence>(_: (Base.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyFilterIterator.flatMap<ElementOfResult>(_: (Base.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyFilterIterator.forEach(_: (Base.Element) throws -> Void) rethrows
Added LazyFilterIterator.joined() -> FlattenSequence<LazyFilterIterator<Base>>
Added LazyFilterIterator.joined(separator: String) -> String
Added LazyFilterIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyFilterIterator<Base>>
Added LazyFilterIterator.lazy
Added LazyFilterIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence) -> Bool
Added LazyFilterIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Element>(_: OtherSequence, by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterIterator.makeIterator() -> LazyFilterIterator<Base>
Added LazyFilterIterator.map<T>(_: (Base.Element) throws -> T) rethrows -> [T]
Added LazyFilterIterator.max() -> Base.Element?
Added LazyFilterIterator.max(by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Base.Element?
Added LazyFilterIterator.min() -> Base.Element?
Added LazyFilterIterator.min(by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Base.Element?
Added LazyFilterIterator.next() -> Base.Element?
Added LazyFilterIterator.prefix(_: Int) -> AnySequence<Base.Element>
Added LazyFilterIterator.reduce<Result>(_: Result, _: (Result, Base.Element) throws -> Result) rethrows -> Result
Added LazyFilterIterator.reversed() -> [Base.Element]
Added LazyFilterIterator.sorted() -> [Base.Element]
Added LazyFilterIterator.sorted(by: (Base.Element, Base.Element) -> Bool) -> [Base.Element]
Added LazyFilterIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Element) throws -> Bool) rethrows -> [AnySequence<Base.Element>]
Added LazyFilterIterator.split(separator: Base.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Element>]
Added LazyFilterIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Element>(with: PossiblePrefix) -> Bool
Added LazyFilterIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Element>(with: PossiblePrefix, by: (Base.Element, Base.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterIterator.suffix(_: Int) -> AnySequence<Base.Element>
Added LazyFilterIterator.underestimatedCount
Added LazyFilterSequence.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterSequence.elements
Added LazyFilterSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyFilterSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyFilterSequence.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterSequence<LazyFilterSequence<Base>>
Added LazyFilterSequence.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterSequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.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<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.lazy
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.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterSequence<Base>, U>
Added LazyFilterSequence.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyFilterSequence.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterSequence.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyFilterSequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyFilterSequence.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyFilterSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>]
Added LazyFilterSequence.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazyFilterSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added LazyFilterSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyMapBidirectionalCollection [struct]
Added LazyMapBidirectionalCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added LazyMapBidirectionalCollection.count
Added LazyMapBidirectionalCollection.count
Added LazyMapBidirectionalCollection.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added LazyMapBidirectionalCollection.dropFirst() -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.dropFirst(_: Int) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.dropLast() -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.dropLast(_: Int) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.elements
Added LazyMapBidirectionalCollection.elements
Added LazyMapBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapBidirectionalCollection.endIndex
Added LazyMapBidirectionalCollection.enumerated() -> EnumeratedSequence<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.filter(_: (Element) -> Bool) -> LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.first
Added LazyMapBidirectionalCollection.first
Added LazyMapBidirectionalCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added LazyMapBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapBidirectionalCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyMapBidirectionalCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyMapBidirectionalCollection.flatMap<SegmentOfResult : Collection where SegmentOfResult : BidirectionalCollection>(_: (Element) -> SegmentOfResult) -> LazyCollection<FlattenBidirectionalCollection<LazyMapBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyMapBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapBidirectionalCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapBidirectionalCollection.flatMap<SegmentOfResult : Collection>(_: (Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyMapBidirectionalCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapBidirectionalCollection.forEach(_: (Element) throws -> Void) rethrows
Added LazyMapBidirectionalCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyMapBidirectionalCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyMapBidirectionalCollection.formIndex(after: Base.Index)
Added LazyMapBidirectionalCollection.formIndex(before: Base.Index)
Added LazyMapBidirectionalCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyMapBidirectionalCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyMapBidirectionalCollection.index(after: Base.Index) -> Base.Index
Added LazyMapBidirectionalCollection.index(before: Base.Index) -> Base.Index
Added LazyMapBidirectionalCollection.index(of: Element) -> Base.Index?
Added LazyMapBidirectionalCollection.index(where: (Element) throws -> Bool) rethrows -> Base.Index?
Added LazyMapBidirectionalCollection.indices
Added LazyMapBidirectionalCollection.indices
Added LazyMapBidirectionalCollection.indices
Added LazyMapBidirectionalCollection.isEmpty
Added LazyMapBidirectionalCollection.isEmpty
Added LazyMapBidirectionalCollection.joined() -> FlattenCollection<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.joined() -> FlattenBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.joined() -> LazySequence<FlattenSequence<LazyMapBidirectionalCollection<Base, Element>>>
Added LazyMapBidirectionalCollection.joined() -> LazyCollection<FlattenCollection<LazyMapBidirectionalCollection<Base, Element>>>
Added LazyMapBidirectionalCollection.joined() -> FlattenSequence<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.joined() -> LazyCollection<FlattenBidirectionalCollection<LazyMapBidirectionalCollection<Base, Element>>>
Added LazyMapBidirectionalCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.joined(separator: String) -> String
Added LazyMapBidirectionalCollection.last
Added LazyMapBidirectionalCollection.last
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lazy
Added LazyMapBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapBidirectionalCollection.makeIterator() -> LazyMapIterator<Base.Iterator, Element>
Added LazyMapBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapBidirectionalCollection.map<U>(_: (Element) -> U) -> LazyMapCollection<LazyMapBidirectionalCollection<Base, Element>, U>
Added LazyMapBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapBidirectionalCollection.map<U>(_: (Element) -> U) -> LazyMapSequence<LazyMapBidirectionalCollection<Base, Element>, U>
Added LazyMapBidirectionalCollection.map<U>(_: (Element) -> U) -> LazyMapBidirectionalCollection<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) -> [AnySequence<Element>]
Added LazyMapBidirectionalCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<LazyMapBidirectionalCollection<Base, 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(_: Range<Base.Index>) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.subscript(_: Base.Index) -> Element
Added LazyMapBidirectionalCollection.subscript(_: ClosedRange<Base.Index>) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.subscript(_: CountableRange<Base.Index>) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.subscript(_: Range<Base.Index>) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.suffix(_: Int) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.suffix(from: Base.Index) -> BidirectionalSlice<LazyMapBidirectionalCollection<Base, Element>>
Added LazyMapBidirectionalCollection.underestimatedCount
Added LazyMapBidirectionalCollection.underestimatedCount
Added LazyMapBidirectionalCollection.underestimatedCount
Added LazyMapCollection.count
Added LazyMapCollection.count
Added LazyMapCollection.elements
Added LazyMapCollection.elements
Added LazyMapCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapCollection.first
Added LazyMapCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyMapCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyMapCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyMapCollection.flatMap<SegmentOfResult : Collection>(_: (Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyMapCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyMapCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyMapCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyMapCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyMapCollection.index(of: Element) -> Base.Index?
Added LazyMapCollection.index(where: (Element) throws -> Bool) rethrows -> Base.Index?
Added LazyMapCollection.isEmpty
Added LazyMapCollection.joined() -> FlattenSequence<LazyMapCollection<Base, Element>>
Added LazyMapCollection.joined() -> LazyCollection<FlattenCollection<LazyMapCollection<Base, Element>>>
Added LazyMapCollection.joined() -> FlattenCollection<LazyMapCollection<Base, Element>>
Added LazyMapCollection.joined() -> LazySequence<FlattenSequence<LazyMapCollection<Base, Element>>>
Added LazyMapCollection.lazy
Added LazyMapCollection.lazy
Added LazyMapCollection.lazy
Added LazyMapCollection.lazy
Added LazyMapCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapCollection.map<U>(_: (Element) -> U) -> LazyMapSequence<LazyMapCollection<Base, Element>, U>
Added LazyMapCollection.map<U>(_: (Element) -> U) -> LazyMapCollection<LazyMapCollection<Base, Element>, U>
Added LazyMapCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<LazyMapCollection<Base, Element>>]
Added LazyMapCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<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(_: ClosedRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>>
Added LazyMapCollection.subscript(_: Range<Base.Index>) -> Slice<LazyMapCollection<Base, Element>>
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.underestimatedCount
Added LazyMapCollection.underestimatedCount
Added LazyMapCollection.underestimatedCount
Added LazyMapIterator [struct]
Added LazyMapIterator.base
Added LazyMapIterator.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added LazyMapIterator.dropFirst() -> AnySequence<Element>
Added LazyMapIterator.dropFirst(_: Int) -> AnySequence<Element>
Added LazyMapIterator.dropLast() -> AnySequence<Element>
Added LazyMapIterator.dropLast(_: Int) -> AnySequence<Element>
Added LazyMapIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapIterator.enumerated() -> EnumeratedSequence<LazyMapIterator<Base, Element>>
Added LazyMapIterator.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added LazyMapIterator.first(where: (Element) throws -> Bool) rethrows -> Element?
Added LazyMapIterator.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyMapIterator.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyMapIterator.forEach(_: (Element) throws -> Void) rethrows
Added LazyMapIterator.joined() -> FlattenSequence<LazyMapIterator<Base, Element>>
Added LazyMapIterator.joined(separator: String) -> String
Added LazyMapIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyMapIterator<Base, Element>>
Added LazyMapIterator.lazy
Added LazyMapIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapIterator.makeIterator() -> LazyMapIterator<Base, Element>
Added LazyMapIterator.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapIterator.max() -> Element?
Added LazyMapIterator.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added LazyMapIterator.min() -> Element?
Added LazyMapIterator.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added LazyMapIterator.next() -> Element?
Added LazyMapIterator.prefix(_: Int) -> AnySequence<Element>
Added LazyMapIterator.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added LazyMapIterator.reversed() -> [Element]
Added LazyMapIterator.sorted() -> [Element]
Added LazyMapIterator.sorted(by: (Element, Element) -> Bool) -> [Element]
Added LazyMapIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
Added LazyMapIterator.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added LazyMapIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added LazyMapIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapIterator.suffix(_: Int) -> AnySequence<Element>
Added LazyMapIterator.underestimatedCount
Added LazyMapRandomAccessCollection [struct]
Added LazyMapRandomAccessCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added LazyMapRandomAccessCollection.count
Added LazyMapRandomAccessCollection.count
Added LazyMapRandomAccessCollection.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added LazyMapRandomAccessCollection.dropFirst() -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.dropFirst(_: Int) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.dropLast() -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.dropLast(_: Int) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.elements
Added LazyMapRandomAccessCollection.elements
Added LazyMapRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapRandomAccessCollection.endIndex
Added LazyMapRandomAccessCollection.enumerated() -> EnumeratedSequence<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.filter(_: (Element) -> Bool) -> LazyFilterBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.first
Added LazyMapRandomAccessCollection.first
Added LazyMapRandomAccessCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added LazyMapRandomAccessCollection.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapBidirectionalCollection<LazyFilterBidirectionalCollection<LazyMapBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapRandomAccessCollection<Base, Element>, SegmentOfResult>>>
Added LazyMapRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.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?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapRandomAccessCollection<Base, Element>, ElementOfResult?>>, ElementOfResult>
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.forEach(_: (Element) throws -> Void) rethrows
Added LazyMapRandomAccessCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyMapRandomAccessCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyMapRandomAccessCollection.formIndex(after: Base.Index)
Added LazyMapRandomAccessCollection.formIndex(before: Base.Index)
Added LazyMapRandomAccessCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyMapRandomAccessCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyMapRandomAccessCollection.index(after: Base.Index) -> Base.Index
Added LazyMapRandomAccessCollection.index(before: Base.Index) -> Base.Index
Added LazyMapRandomAccessCollection.index(of: Element) -> Base.Index?
Added LazyMapRandomAccessCollection.index(where: (Element) throws -> Bool) rethrows -> Base.Index?
Added LazyMapRandomAccessCollection.indices
Added LazyMapRandomAccessCollection.indices
Added LazyMapRandomAccessCollection.indices
Added LazyMapRandomAccessCollection.indices
Added LazyMapRandomAccessCollection.indices
Added LazyMapRandomAccessCollection.isEmpty
Added LazyMapRandomAccessCollection.isEmpty
Added LazyMapRandomAccessCollection.joined() -> FlattenSequence<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.joined() -> FlattenCollection<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.joined() -> LazyCollection<FlattenBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>>>
Added LazyMapRandomAccessCollection.joined() -> LazyCollection<FlattenCollection<LazyMapRandomAccessCollection<Base, Element>>>
Added LazyMapRandomAccessCollection.joined() -> LazySequence<FlattenSequence<LazyMapRandomAccessCollection<Base, Element>>>
Added LazyMapRandomAccessCollection.joined() -> FlattenBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.joined(separator: String) -> String
Added LazyMapRandomAccessCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.last
Added LazyMapRandomAccessCollection.last
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lazy
Added LazyMapRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapRandomAccessCollection.makeIterator() -> LazyMapIterator<Base.Iterator, Element>
Added LazyMapRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapRandomAccessCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added LazyMapRandomAccessCollection.map<U>(_: (Element) -> U) -> LazyMapSequence<LazyMapRandomAccessCollection<Base, Element>, U>
Added LazyMapRandomAccessCollection.map<U>(_: (Element) -> U) -> LazyMapCollection<LazyMapRandomAccessCollection<Base, Element>, U>
Added LazyMapRandomAccessCollection.map<U>(_: (Element) -> U) -> LazyMapBidirectionalCollection<LazyMapRandomAccessCollection<Base, Element>, U>
Added LazyMapRandomAccessCollection.map<U>(_: (Element) -> U) -> LazyMapRandomAccessCollection<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) -> [AnySequence<Element>]
Added LazyMapRandomAccessCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<LazyMapRandomAccessCollection<Base, 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(_: Range<Base.Index>) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.subscript(_: CountableClosedRange<Base.Index>) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.subscript(_: Base.Index) -> Element
Added LazyMapRandomAccessCollection.subscript(_: CountableRange<Base.Index>) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.subscript(_: ClosedRange<Base.Index>) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.subscript(_: Range<Base.Index>) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.suffix(_: Int) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.suffix(from: Base.Index) -> RandomAccessSlice<LazyMapRandomAccessCollection<Base, Element>>
Added LazyMapRandomAccessCollection.underestimatedCount
Added LazyMapRandomAccessCollection.underestimatedCount
Added LazyMapRandomAccessCollection.underestimatedCount
Added LazyMapSequence.elements
Added LazyMapSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added LazyMapSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapSequence.filter(_: (Element) -> Bool) -> LazyFilterSequence<LazyMapSequence<Base, Element>>
Added LazyMapSequence.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyMapSequence.flatMap<ElementOfResult>(_: (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapSequence<Base, Element>, ElementOfResult?>>, ElementOfResult>
Added LazyMapSequence.flatMap<SegmentOfResult : Sequence>(_: (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapSequence<Base, Element>, SegmentOfResult>>>
Added LazyMapSequence.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyMapSequence.joined() -> LazySequence<FlattenSequence<LazyMapSequence<Base, Element>>>
Added LazyMapSequence.joined() -> FlattenSequence<LazyMapSequence<Base, Element>>
Added LazyMapSequence.lazy
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.map<U>(_: (Element) -> U) -> LazyMapSequence<LazyMapSequence<Base, Element>, U>
Added LazyMapSequence.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added LazyMapSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added LazyMapSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added LazyMapSequence.underestimatedCount
Added LazyMapSequence.underestimatedCount
Added LazyRandomAccessCollection [struct]
Added LazyRandomAccessCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyRandomAccessCollection.count
Added LazyRandomAccessCollection.count
Added LazyRandomAccessCollection.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added LazyRandomAccessCollection.dropFirst() -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.dropFirst(_: Int) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.dropLast() -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.elements
Added LazyRandomAccessCollection.elements
Added LazyRandomAccessCollection.elements
Added LazyRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyRandomAccessCollection.endIndex
Added LazyRandomAccessCollection.enumerated() -> EnumeratedSequence<LazyRandomAccessCollection<Base>>
Added LazyRandomAccessCollection.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterBidirectionalCollection<Base>
Added LazyRandomAccessCollection.first
Added LazyRandomAccessCollection.first
Added LazyRandomAccessCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>>
Added LazyRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazyRandomAccessCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazyRandomAccessCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult>
Added LazyRandomAccessCollection.flatMap<SegmentOfResult : Collection>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<Base, SegmentOfResult>>>
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<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<Base, ElementOfResult?>>, ElementOfResult>
Added LazyRandomAccessCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazyRandomAccessCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added LazyRandomAccessCollection.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added LazyRandomAccessCollection.formIndex(after: Base.Index)
Added LazyRandomAccessCollection.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added LazyRandomAccessCollection.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added LazyRandomAccessCollection.index(after: Base.Index) -> Base.Index
Added LazyRandomAccessCollection.index(before: Base.Index) -> Base.Index
Added LazyRandomAccessCollection.index(of: Base.Iterator.Element) -> Base.Index?
Added LazyRandomAccessCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Index?
Added LazyRandomAccessCollection.indices
Added LazyRandomAccessCollection.indices
Added LazyRandomAccessCollection.isEmpty
Added LazyRandomAccessCollection.isEmpty
Added LazyRandomAccessCollection.joined() -> LazySequence<FlattenSequence<Base>>
Added LazyRandomAccessCollection.joined() -> LazyCollection<FlattenBidirectionalCollection<Base>>
Added LazyRandomAccessCollection.joined() -> FlattenCollection<LazyRandomAccessCollection<Base>>
Added LazyRandomAccessCollection.joined() -> LazyCollection<FlattenCollection<Base>>
Added LazyRandomAccessCollection.joined() -> FlattenSequence<LazyRandomAccessCollection<Base>>
Added LazyRandomAccessCollection.joined(separator: String) -> String
Added LazyRandomAccessCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<LazyRandomAccessCollection<Base>>
Added LazyRandomAccessCollection.last
Added LazyRandomAccessCollection.lazy
Added LazyRandomAccessCollection.lazy
Added LazyRandomAccessCollection.lazy
Added LazyRandomAccessCollection.lazy
Added LazyRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazyRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyRandomAccessCollection.makeIterator() -> Base.Iterator
Added LazyRandomAccessCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyRandomAccessCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapBidirectionalCollection<Base, U>
Added LazyRandomAccessCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>
Added LazyRandomAccessCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapCollection<Base, U>
Added LazyRandomAccessCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazyRandomAccessCollection.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapRandomAccessCollection<Base, U>
Added LazyRandomAccessCollection.max() -> Base.Iterator.Element?
Added LazyRandomAccessCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyRandomAccessCollection.min() -> Base.Iterator.Element?
Added LazyRandomAccessCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazyRandomAccessCollection.popFirst() -> Base.Iterator.Element?
Added LazyRandomAccessCollection.prefix(_: Int) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.prefix(through: Base.Index) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.prefix(upTo: Base.Index) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazyRandomAccessCollection.removeFirst() -> Base.Iterator.Element
Added LazyRandomAccessCollection.removeFirst(_: Int)
Added LazyRandomAccessCollection.reversed() -> LazyRandomAccessCollection<ReversedRandomAccessCollection<Base>>
Added LazyRandomAccessCollection.sorted() -> [Base.Iterator.Element]
Added LazyRandomAccessCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazyRandomAccessCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyRandomAccessCollection<RandomAccessSlice<Base>>]
Added LazyRandomAccessCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazyRandomAccessCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [LazyRandomAccessCollection<RandomAccessSlice<Base>>]
Added LazyRandomAccessCollection.startIndex
Added LazyRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added LazyRandomAccessCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazyRandomAccessCollection.subscript(_: Base.Index) -> Base.Iterator.Element
Added LazyRandomAccessCollection.subscript(_: Range<Base.Index>) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.subscript(_: CountableClosedRange<Base.Index>) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.subscript(_: ClosedRange<Base.Index>) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.subscript(_: CountableRange<Base.Index>) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.suffix(from: Base.Index) -> LazyRandomAccessCollection<RandomAccessSlice<Base>>
Added LazyRandomAccessCollection.underestimatedCount
Added LazyRandomAccessCollection.underestimatedCount
Added LazyRandomAccessCollection.underestimatedCount
Added LazySequence.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazySequence.elements
Added LazySequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added LazySequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazySequence.filter(_: (Base.Iterator.Element) -> Bool) -> LazyFilterSequence<Base>
Added LazySequence.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazySequence.flatMap<ElementOfResult>(_: (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult>
Added LazySequence.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added LazySequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added LazySequence.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>>
Added LazySequence.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added LazySequence.joined() -> LazySequence<FlattenSequence<Base>>
Added LazySequence.joined() -> FlattenSequence<LazySequence<Base>>
Added LazySequence.lazy
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.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazySequence.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added LazySequence.map<U>(_: (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U>
Added LazySequence.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazySequence.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added LazySequence.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added LazySequence.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added LazySequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>]
Added LazySequence.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added LazySequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added LazySequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added LazySequence.underestimatedCount
Added LazySequence.underestimatedCount
Added LazySequenceProtocol
Added LazySequenceProtocol.filter(_: (Self.Elements.Iterator.Element) -> Bool) -> LazyFilterSequence<Self.Elements>
Added LazySequenceProtocol.flatMap<SegmentOfResult : Sequence>(_: (Self.Elements.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Self.Elements, SegmentOfResult>>>
Added LazySequenceProtocol.flatMap<ElementOfResult>(_: (Self.Elements.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Self.Elements, ElementOfResult?>>, ElementOfResult>
Added LazySequenceProtocol.lazy
Added LazySequenceProtocol.map<U>(_: (Self.Elements.Iterator.Element) -> U) -> LazyMapSequence<Self.Elements, U>
Added ManagedBuffer.capacity
Added ManagedBuffer.header
Added MemoryLayout [enum]
Added MemoryLayout.alignment
Added MemoryLayout.size
Added MemoryLayout.stride
Added Mirror.customMirror
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.DisplayStyle.enum
Added Mirror.DisplayStyle.set
Added Mirror.LegacyChildren.contains(where: (String?, Any) throws -> Bool) rethrows -> Bool
Added Mirror.LegacyChildren.count
Added Mirror.LegacyChildren.distance(from: Int, to: Int) -> Int
Added Mirror.LegacyChildren.dropFirst() -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.dropFirst(_: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.dropLast() -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.dropLast(_: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (label: String?, value: Any)>(_: OtherSequence, by: ((label: String?, value: Any), (label: String?, value: Any)) throws -> Bool) rethrows -> Bool
Added Mirror.LegacyChildren.enumerated() -> EnumeratedSequence<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.filter(_: (String?, Any) throws -> Bool) rethrows -> [(label: String?, value: Any)]
Added Mirror.LegacyChildren.first
Added Mirror.LegacyChildren.first(where: (String?, Any) throws -> Bool) rethrows -> (label: String?, value: Any)?
Added Mirror.LegacyChildren.flatMap<SegmentOfResult : Sequence>(_: (String?, Any) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Mirror.LegacyChildren.flatMap<ElementOfResult>(_: (String?, Any) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Mirror.LegacyChildren.forEach(_: (String?, Any) throws -> Void) rethrows
Added Mirror.LegacyChildren.formIndex(_: Int, offsetBy: Int)
Added Mirror.LegacyChildren.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Mirror.LegacyChildren.formIndex(after: Int)
Added Mirror.LegacyChildren.formIndex(before: Int)
Added Mirror.LegacyChildren.index(_: Int, offsetBy: Int) -> Int
Added Mirror.LegacyChildren.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added Mirror.LegacyChildren.index(after: Int) -> Int
Added Mirror.LegacyChildren.index(before: Int) -> Int
Added Mirror.LegacyChildren.index(where: (String?, Any) throws -> Bool) rethrows -> Int?
Added Mirror.LegacyChildren.indices
Added Mirror.LegacyChildren.isEmpty
Added Mirror.LegacyChildren.last
Added Mirror.LegacyChildren.lazy
Added Mirror.LegacyChildren.lazy
Added Mirror.LegacyChildren.lazy
Added Mirror.LegacyChildren.lazy
Added Mirror.LegacyChildren.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (label: String?, value: Any)>(_: OtherSequence, by: ((label: String?, value: Any), (label: String?, value: Any)) throws -> Bool) rethrows -> Bool
Added Mirror.LegacyChildren.makeIterator() -> IndexingIterator<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.map<T>(_: (String?, Any) throws -> T) rethrows -> [T]
Added Mirror.LegacyChildren.map<T>(_: (String?, Any) throws -> T) rethrows -> [T]
Added Mirror.LegacyChildren.max(by: ((label: String?, value: Any), (label: String?, value: Any)) throws -> Bool) rethrows -> (label: String?, value: Any)?
Added Mirror.LegacyChildren.min(by: ((label: String?, value: Any), (label: String?, value: Any)) throws -> Bool) rethrows -> (label: String?, value: Any)?
Added Mirror.LegacyChildren.prefix(_: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.prefix(through: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.prefix(upTo: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.reduce<Result>(_: Result, _: (Result, (label: String?, value: Any)) throws -> Result) rethrows -> Result
Added Mirror.LegacyChildren.reversed() -> ReversedRandomAccessCollection<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.sorted(by: ((label: String?, value: Any), (label: String?, value: Any)) -> Bool) -> [(label: String?, value: Any)]
Added Mirror.LegacyChildren.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (String?, Any) throws -> Bool) rethrows -> [RandomAccessSlice<Mirror.LegacyChildren>]
Added Mirror.LegacyChildren.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (label: String?, value: Any)>(with: PossiblePrefix, by: ((label: String?, value: Any), (label: String?, value: Any)) throws -> Bool) rethrows -> Bool
Added Mirror.LegacyChildren.subscript(_: CountableRange<Int>) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.subscript(_: Range<Int>) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.suffix(_: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.suffix(from: Int) -> RandomAccessSlice<Mirror.LegacyChildren>
Added Mirror.LegacyChildren.underestimatedCount
Added Mirror.LegacyChildren.underestimatedCount
Added 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() -> FlattenBidirectionalCollection<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.joined() -> FlattenCollection<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.joined() -> FlattenSequence<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.joined(separator: String) -> String
Added MutableBidirectionalSlice.last
Added MutableBidirectionalSlice.lazy
Added MutableBidirectionalSlice.lazy
Added MutableBidirectionalSlice.lazy
Added MutableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableBidirectionalSlice.makeIterator() -> IndexingIterator<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableBidirectionalSlice.max() -> Base._Element?
Added MutableBidirectionalSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableBidirectionalSlice.min() -> Base._Element?
Added MutableBidirectionalSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableBidirectionalSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableBidirectionalSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableBidirectionalSlice.popFirst() -> Base._Element?
Added MutableBidirectionalSlice.popLast() -> Base._Element?
Added MutableBidirectionalSlice.prefix(_: Int) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.prefix(through: Base.Index) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.prefix(upTo: Base.Index) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableBidirectionalSlice.removeFirst() -> Base._Element
Added MutableBidirectionalSlice.removeFirst(_: Int)
Added MutableBidirectionalSlice.removeLast() -> Base._Element
Added MutableBidirectionalSlice.removeLast(_: Int)
Added MutableBidirectionalSlice.reversed() -> ReversedCollection<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.sorted() -> [Base._Element]
Added MutableBidirectionalSlice.sorted() -> [Base._Element]
Added MutableBidirectionalSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableBidirectionalSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableBidirectionalSlice<Base>]
Added MutableBidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableBidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableBidirectionalSlice<Base>]
Added MutableBidirectionalSlice.startIndex
Added MutableBidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added MutableBidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableBidirectionalSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableBidirectionalSlice<Base>>
Added MutableBidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: Range<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: Base.Index) -> Base._Element
Added MutableBidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.suffix(_: Int) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.suffix(from: Base.Index) -> MutableBidirectionalSlice<Base>
Added MutableBidirectionalSlice.underestimatedCount
Added MutableBidirectionalSlice.underestimatedCount
Added MutableCollection
Added MutableCollection.partition(by: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Index
Added MutableCollection.partition(by: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Index
Added MutableCollection.sorted() -> [Self.Iterator.Element]
Added MutableCollection.sorted(by: (Self.Iterator.Element, Self.Iterator.Element) -> Bool) -> [Self.Iterator.Element]
Added MutableCollection.subscript(_: Range<Self.Index>) -> Self.SubSequence
Added MutableCollection.subscript(_: Range<Self.Index>) -> MutableSlice<Self>
Added MutableIndexable.formIndex(after: Self.Index)
Added MutableIndexable.index(after: Self.Index) -> Self.Index
Added MutableIndexable.subscript(_: Range<Self.Index>) -> Self.SubSequence
Added MutableIndexable.subscript(_: CountableClosedRange<Self.Index>) -> Self.SubSequence
Added MutableIndexable.subscript(_: ClosedRange<Self.Index>) -> Self.SubSequence
Added MutableIndexable.subscript(_: CountableRange<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() -> FlattenBidirectionalCollection<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.joined() -> FlattenSequence<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.joined() -> FlattenCollection<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.joined(separator: String) -> String
Added MutableRandomAccessSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.last
Added MutableRandomAccessSlice.lazy
Added MutableRandomAccessSlice.lazy
Added MutableRandomAccessSlice.lazy
Added MutableRandomAccessSlice.lazy
Added MutableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRandomAccessSlice.makeIterator() -> IndexingIterator<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRandomAccessSlice.max() -> Base._Element?
Added MutableRandomAccessSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRandomAccessSlice.min() -> Base._Element?
Added MutableRandomAccessSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRandomAccessSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRandomAccessSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRandomAccessSlice.popFirst() -> Base._Element?
Added MutableRandomAccessSlice.popLast() -> Base._Element?
Added MutableRandomAccessSlice.prefix(_: Int) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.prefix(through: Base.Index) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.prefix(upTo: Base.Index) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableRandomAccessSlice.removeFirst() -> Base._Element
Added MutableRandomAccessSlice.removeFirst(_: Int)
Added MutableRandomAccessSlice.removeLast() -> Base._Element
Added MutableRandomAccessSlice.removeLast(_: Int)
Added MutableRandomAccessSlice.reversed() -> ReversedRandomAccessCollection<MutableRandomAccessSlice<Base>>
Added MutableRandomAccessSlice.sort()
Added MutableRandomAccessSlice.sort(by: (Base._Element, Base._Element) -> Bool)
Added MutableRandomAccessSlice.sorted() -> [Base._Element]
Added MutableRandomAccessSlice.sorted() -> [Base._Element]
Added MutableRandomAccessSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableRandomAccessSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<Base>]
Added MutableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRandomAccessSlice<Base>]
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(_: CountableRange<Base.Index>) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.subscript(_: Range<Base.Index>) -> MutableRandomAccessSlice<Base>
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.suffix(_: Int) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.suffix(from: Base.Index) -> MutableRandomAccessSlice<Base>
Added MutableRandomAccessSlice.underestimatedCount
Added MutableRandomAccessSlice.underestimatedCount
Added MutableRangeReplaceableBidirectionalSlice [struct]
Added MutableRangeReplaceableBidirectionalSlice.append(_: Base._Element)
Added MutableRangeReplaceableBidirectionalSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added MutableRangeReplaceableBidirectionalSlice.base
Added MutableRangeReplaceableBidirectionalSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableBidirectionalSlice.count
Added MutableRangeReplaceableBidirectionalSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added MutableRangeReplaceableBidirectionalSlice.dropFirst() -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.dropFirst(_: Int) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.dropLast() -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.dropLast(_: Int) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableBidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableBidirectionalSlice.endIndex
Added MutableRangeReplaceableBidirectionalSlice.enumerated() -> EnumeratedSequence<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added MutableRangeReplaceableBidirectionalSlice.first
Added MutableRangeReplaceableBidirectionalSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added MutableRangeReplaceableBidirectionalSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added MutableRangeReplaceableBidirectionalSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added MutableRangeReplaceableBidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added MutableRangeReplaceableBidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added MutableRangeReplaceableBidirectionalSlice.formIndex(after: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.formIndex(before: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added MutableRangeReplaceableBidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added MutableRangeReplaceableBidirectionalSlice.index(after: Base.Index) -> Base.Index
Added MutableRangeReplaceableBidirectionalSlice.index(before: Base.Index) -> Base.Index
Added MutableRangeReplaceableBidirectionalSlice.index(of: Base._Element) -> Base.Index?
Added MutableRangeReplaceableBidirectionalSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added MutableRangeReplaceableBidirectionalSlice.indices
Added MutableRangeReplaceableBidirectionalSlice.init()
Added MutableRangeReplaceableBidirectionalSlice.init<S : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableBidirectionalSlice.init<S where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableBidirectionalSlice.init(base: Base, bounds: Range<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableBidirectionalSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableBidirectionalSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added MutableRangeReplaceableBidirectionalSlice.isEmpty
Added MutableRangeReplaceableBidirectionalSlice.joined() -> FlattenBidirectionalCollection<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.joined() -> FlattenSequence<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.joined() -> FlattenCollection<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.joined(separator: String) -> String
Added MutableRangeReplaceableBidirectionalSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.last
Added MutableRangeReplaceableBidirectionalSlice.lazy
Added MutableRangeReplaceableBidirectionalSlice.lazy
Added MutableRangeReplaceableBidirectionalSlice.lazy
Added MutableRangeReplaceableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableBidirectionalSlice.makeIterator() -> IndexingIterator<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableBidirectionalSlice.max() -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.min() -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRangeReplaceableBidirectionalSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRangeReplaceableBidirectionalSlice.popFirst() -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.popLast() -> Base._Element?
Added MutableRangeReplaceableBidirectionalSlice.prefix(_: Int) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.prefix(through: Base.Index) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.prefix(upTo: Base.Index) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableRangeReplaceableBidirectionalSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeAll(keepingCapacity: Bool)
Added MutableRangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added MutableRangeReplaceableBidirectionalSlice.removeSubrange(_: CountableRange<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.removeSubrange(_: ClosedRange<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.removeSubrange(_: Range<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added MutableRangeReplaceableBidirectionalSlice.removeSubrange(_: Range<Base.Index>)
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>(_: CountableClosedRange<Base.Index>, with: C)
Added MutableRangeReplaceableBidirectionalSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: ClosedRange<Base.Index>, with: C)
Added MutableRangeReplaceableBidirectionalSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: Range<Base.Index>, with: C)
Added MutableRangeReplaceableBidirectionalSlice.reserveCapacity(_: Base.IndexDistance)
Added MutableRangeReplaceableBidirectionalSlice.reversed() -> ReversedCollection<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableBidirectionalSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableBidirectionalSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableRangeReplaceableBidirectionalSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableRangeReplaceableBidirectionalSlice<Base>]
Added MutableRangeReplaceableBidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRangeReplaceableBidirectionalSlice<Base>]
Added MutableRangeReplaceableBidirectionalSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableRangeReplaceableBidirectionalSlice.startIndex
Added MutableRangeReplaceableBidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added MutableRangeReplaceableBidirectionalSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: Base.Index) -> Base._Element
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableRangeReplaceableBidirectionalSlice<Base>>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.subscript(_: Range<Base.Index>) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.suffix(_: Int) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.suffix(from: Base.Index) -> MutableRangeReplaceableBidirectionalSlice<Base>
Added MutableRangeReplaceableBidirectionalSlice.underestimatedCount
Added MutableRangeReplaceableBidirectionalSlice.underestimatedCount
Added MutableRangeReplaceableRandomAccessSlice [struct]
Added MutableRangeReplaceableRandomAccessSlice.append(_: Base._Element)
Added MutableRangeReplaceableRandomAccessSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added MutableRangeReplaceableRandomAccessSlice.base
Added MutableRangeReplaceableRandomAccessSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableRandomAccessSlice.count
Added MutableRangeReplaceableRandomAccessSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added MutableRangeReplaceableRandomAccessSlice.dropFirst() -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.dropFirst(_: Int) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.dropLast() -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.dropLast(_: Int) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableRandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableRandomAccessSlice.endIndex
Added MutableRangeReplaceableRandomAccessSlice.enumerated() -> EnumeratedSequence<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added MutableRangeReplaceableRandomAccessSlice.first
Added MutableRangeReplaceableRandomAccessSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added MutableRangeReplaceableRandomAccessSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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 : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableRandomAccessSlice.init<S where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableRandomAccessSlice.init(base: Base, bounds: Range<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableRandomAccessSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableRandomAccessSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableRandomAccessSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableRandomAccessSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added MutableRangeReplaceableRandomAccessSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added MutableRangeReplaceableRandomAccessSlice.isEmpty
Added MutableRangeReplaceableRandomAccessSlice.joined() -> FlattenBidirectionalCollection<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.joined() -> FlattenCollection<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.joined() -> FlattenSequence<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.joined(separator: String) -> String
Added MutableRangeReplaceableRandomAccessSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.last
Added MutableRangeReplaceableRandomAccessSlice.lazy
Added MutableRangeReplaceableRandomAccessSlice.lazy
Added MutableRangeReplaceableRandomAccessSlice.lazy
Added MutableRangeReplaceableRandomAccessSlice.lazy
Added MutableRangeReplaceableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableRandomAccessSlice.makeIterator() -> IndexingIterator<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableRandomAccessSlice.max() -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.min() -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRangeReplaceableRandomAccessSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRangeReplaceableRandomAccessSlice.popFirst() -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.popLast() -> Base._Element?
Added MutableRangeReplaceableRandomAccessSlice.prefix(_: Int) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.prefix(through: Base.Index) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.prefix(upTo: Base.Index) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableRangeReplaceableRandomAccessSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeAll(keepingCapacity: Bool)
Added MutableRangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added MutableRangeReplaceableRandomAccessSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.removeSubrange(_: Range<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.removeSubrange(_: Range<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.removeSubrange(_: CountableRange<Base.Index>)
Added MutableRangeReplaceableRandomAccessSlice.removeSubrange(_: ClosedRange<Base.Index>)
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>(_: Range<Base.Index>, with: C)
Added MutableRangeReplaceableRandomAccessSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableRange<Base.Index>, with: C)
Added MutableRangeReplaceableRandomAccessSlice.replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_: CountableClosedRange<Base.Index>, with: C)
Added MutableRangeReplaceableRandomAccessSlice.reserveCapacity(_: Base.IndexDistance)
Added MutableRangeReplaceableRandomAccessSlice.reversed() -> ReversedRandomAccessCollection<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.sort()
Added MutableRangeReplaceableRandomAccessSlice.sort(by: (Base._Element, Base._Element) -> Bool)
Added MutableRangeReplaceableRandomAccessSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableRandomAccessSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableRandomAccessSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableRangeReplaceableRandomAccessSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableRangeReplaceableRandomAccessSlice<Base>]
Added MutableRangeReplaceableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableRangeReplaceableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRangeReplaceableRandomAccessSlice<Base>]
Added MutableRangeReplaceableRandomAccessSlice.startIndex
Added MutableRangeReplaceableRandomAccessSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added MutableRangeReplaceableRandomAccessSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: Range<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: Base.Index) -> Base._Element
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableRangeReplaceableRandomAccessSlice<Base>>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.suffix(_: Int) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.suffix(from: Base.Index) -> MutableRangeReplaceableRandomAccessSlice<Base>
Added MutableRangeReplaceableRandomAccessSlice.underestimatedCount
Added MutableRangeReplaceableRandomAccessSlice.underestimatedCount
Added MutableRangeReplaceableSlice [struct]
Added MutableRangeReplaceableSlice.append(_: Base._Element)
Added MutableRangeReplaceableSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added MutableRangeReplaceableSlice.base
Added MutableRangeReplaceableSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableSlice.count
Added MutableRangeReplaceableSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added MutableRangeReplaceableSlice.dropFirst() -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.dropFirst(_: Int) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.dropLast() -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.dropLast(_: Int) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableSlice.endIndex
Added MutableRangeReplaceableSlice.enumerated() -> EnumeratedSequence<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added MutableRangeReplaceableSlice.first
Added MutableRangeReplaceableSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added MutableRangeReplaceableSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added MutableRangeReplaceableSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added MutableRangeReplaceableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added MutableRangeReplaceableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added MutableRangeReplaceableSlice.formIndex(after: Base.Index)
Added MutableRangeReplaceableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added MutableRangeReplaceableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added MutableRangeReplaceableSlice.index(after: Base.Index) -> Base.Index
Added MutableRangeReplaceableSlice.index(of: Base._Element) -> Base.Index?
Added MutableRangeReplaceableSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added MutableRangeReplaceableSlice.indices
Added MutableRangeReplaceableSlice.init()
Added MutableRangeReplaceableSlice.init<S where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableSlice.init<S : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added MutableRangeReplaceableSlice.init(base: Base, bounds: Range<Base.Index>)
Added MutableRangeReplaceableSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableSlice.init(repeating: Base._Element, count: Int)
Added MutableRangeReplaceableSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableSlice.insert(_: Base._Element, at: Base.Index)
Added MutableRangeReplaceableSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added MutableRangeReplaceableSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added MutableRangeReplaceableSlice.isEmpty
Added MutableRangeReplaceableSlice.joined() -> FlattenCollection<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.joined() -> FlattenSequence<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.joined(separator: String) -> String
Added MutableRangeReplaceableSlice.lazy
Added MutableRangeReplaceableSlice.lazy
Added MutableRangeReplaceableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableRangeReplaceableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableRangeReplaceableSlice.makeIterator() -> IndexingIterator<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableRangeReplaceableSlice.max() -> Base._Element?
Added MutableRangeReplaceableSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableSlice.min() -> Base._Element?
Added MutableRangeReplaceableSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableRangeReplaceableSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableRangeReplaceableSlice.popFirst() -> Base._Element?
Added MutableRangeReplaceableSlice.prefix(_: Int) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.prefix(through: Base.Index) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.prefix(upTo: Base.Index) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableRangeReplaceableSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableSlice.remove(at: Base.Index) -> Base._Element
Added MutableRangeReplaceableSlice.removeAll(keepingCapacity: Bool)
Added MutableRangeReplaceableSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableSlice.removeFirst() -> Base._Element
Added MutableRangeReplaceableSlice.removeFirst(_: Int)
Added MutableRangeReplaceableSlice.removeFirst(_: Int)
Added MutableRangeReplaceableSlice.removeFirst(_: Int)
Added MutableRangeReplaceableSlice.removeSubrange(_: ClosedRange<Base.Index>)
Added MutableRangeReplaceableSlice.removeSubrange(_: Range<Base.Index>)
Added MutableRangeReplaceableSlice.removeSubrange(_: CountableRange<Base.Index>)
Added MutableRangeReplaceableSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added MutableRangeReplaceableSlice.removeSubrange(_: Range<Base.Index>)
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.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>(_: ClosedRange<Base.Index>, with: C)
Added MutableRangeReplaceableSlice.reserveCapacity(_: Base.IndexDistance)
Added MutableRangeReplaceableSlice.reversed() -> [Base._Element]
Added MutableRangeReplaceableSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableSlice.sorted() -> [Base._Element]
Added MutableRangeReplaceableSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableRangeReplaceableSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableRangeReplaceableSlice<Base>]
Added MutableRangeReplaceableSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRangeReplaceableSlice<Base>]
Added MutableRangeReplaceableSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
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(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: ClosedRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: Base.Index) -> Base._Element
Added MutableRangeReplaceableSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableRangeReplaceableSlice<Base>>
Added MutableRangeReplaceableSlice.subscript(_: Range<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.subscript(_: CountableRange<Base.Index>) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.suffix(_: Int) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.suffix(from: Base.Index) -> MutableRangeReplaceableSlice<Base>
Added MutableRangeReplaceableSlice.underestimatedCount
Added MutableRangeReplaceableSlice.underestimatedCount
Added MutableSlice.base
Added MutableSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added MutableSlice.count
Added MutableSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added MutableSlice.dropFirst() -> MutableSlice<Base>
Added MutableSlice.dropFirst(_: Int) -> MutableSlice<Base>
Added MutableSlice.dropLast() -> MutableSlice<Base>
Added MutableSlice.dropLast(_: Int) -> MutableSlice<Base>
Added MutableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableSlice.enumerated() -> EnumeratedSequence<MutableSlice<Base>>
Added MutableSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added MutableSlice.first
Added MutableSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added MutableSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added MutableSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added MutableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added MutableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added MutableSlice.formIndex(after: Base.Index)
Added MutableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added MutableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added MutableSlice.index(after: Base.Index) -> Base.Index
Added MutableSlice.index(of: Base._Element) -> Base.Index?
Added MutableSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added MutableSlice.indices
Added MutableSlice.isEmpty
Added MutableSlice.joined() -> FlattenCollection<MutableSlice<Base>>
Added MutableSlice.joined() -> FlattenSequence<MutableSlice<Base>>
Added MutableSlice.joined(separator: String) -> String
Added MutableSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<MutableSlice<Base>>
Added MutableSlice.lazy
Added MutableSlice.lazy
Added MutableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added MutableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableSlice.makeIterator() -> IndexingIterator<MutableSlice<Base>>
Added MutableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added MutableSlice.max() -> Base._Element?
Added MutableSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableSlice.min() -> Base._Element?
Added MutableSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added MutableSlice.partition(by: (Base._Element) throws -> Bool) rethrows -> Base.Index
Added MutableSlice.popFirst() -> Base._Element?
Added MutableSlice.prefix(_: Int) -> MutableSlice<Base>
Added MutableSlice.prefix(through: Base.Index) -> MutableSlice<Base>
Added MutableSlice.prefix(upTo: Base.Index) -> MutableSlice<Base>
Added MutableSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added MutableSlice.removeFirst() -> Base._Element
Added MutableSlice.removeFirst(_: Int)
Added MutableSlice.reversed() -> [Base._Element]
Added MutableSlice.sorted() -> [Base._Element]
Added MutableSlice.sorted() -> [Base._Element]
Added MutableSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added MutableSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableSlice<Base>]
Added MutableSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableSlice<Base>]
Added MutableSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
Added MutableSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix) -> Bool
Added MutableSlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with: PossiblePrefix, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added MutableSlice.subscript(_: Range<Base.Index>) -> MutableSlice<MutableSlice<Base>>
Added MutableSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.subscript(_: CountableClosedRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.subscript(_: CountableRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.subscript(_: ClosedRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.subscript(_: CountableRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.subscript(_: ClosedRange<Base.Index>) -> MutableSlice<Base>
Added MutableSlice.suffix(_: Int) -> MutableSlice<Base>
Added MutableSlice.suffix(from: Base.Index) -> MutableSlice<Base>
Added MutableSlice.underestimatedCount
Added MutableSlice.underestimatedCount
Added Never [enum]
Added OpaquePointer [struct]
Added OpaquePointer.hashValue
Added Optional.customMirror
Added Optional.none
Added Optional.some
Added OptionSet
Added OptionSet.init()
Added PlaygroundQuickLook.bool
Added PlaygroundQuickLook.int
Added PlaygroundQuickLook.size
Added PlaygroundQuickLook.text
Added PlaygroundQuickLook.uInt
Added PlaygroundQuickLook.url
Added PlaygroundQuickLook.view
Added RandomAccessCollection
Added RandomAccessCollection.indices
Added RandomAccessCollection.indices
Added RandomAccessCollection.lazy
Added RandomAccessCollection.reversed() -> ReversedRandomAccessCollection<Self>
Added RandomAccessCollection.subscript(_: Range<Self.Index>) -> RandomAccessSlice<Self>
Added RandomAccessIndexable
Added RandomAccessIndexable.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added RandomAccessSlice [struct]
Added RandomAccessSlice.base
Added RandomAccessSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added RandomAccessSlice.count
Added RandomAccessSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added RandomAccessSlice.dropFirst() -> RandomAccessSlice<Base>
Added RandomAccessSlice.dropFirst(_: Int) -> RandomAccessSlice<Base>
Added RandomAccessSlice.dropLast() -> RandomAccessSlice<Base>
Added RandomAccessSlice.dropLast(_: Int) -> RandomAccessSlice<Base>
Added RandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RandomAccessSlice.endIndex
Added RandomAccessSlice.enumerated() -> EnumeratedSequence<RandomAccessSlice<Base>>
Added RandomAccessSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added RandomAccessSlice.first
Added RandomAccessSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RandomAccessSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added RandomAccessSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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() -> FlattenSequence<RandomAccessSlice<Base>>
Added RandomAccessSlice.joined() -> FlattenBidirectionalCollection<RandomAccessSlice<Base>>
Added RandomAccessSlice.joined() -> FlattenCollection<RandomAccessSlice<Base>>
Added RandomAccessSlice.joined(separator: String) -> String
Added RandomAccessSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<RandomAccessSlice<Base>>
Added RandomAccessSlice.last
Added RandomAccessSlice.lazy
Added RandomAccessSlice.lazy
Added RandomAccessSlice.lazy
Added RandomAccessSlice.lazy
Added RandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RandomAccessSlice.makeIterator() -> IndexingIterator<RandomAccessSlice<Base>>
Added RandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RandomAccessSlice.max() -> Base._Element?
Added RandomAccessSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RandomAccessSlice.min() -> Base._Element?
Added RandomAccessSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RandomAccessSlice.popFirst() -> Base._Element?
Added RandomAccessSlice.popLast() -> Base._Element?
Added RandomAccessSlice.prefix(_: Int) -> RandomAccessSlice<Base>
Added RandomAccessSlice.prefix(through: Base.Index) -> RandomAccessSlice<Base>
Added RandomAccessSlice.prefix(upTo: Base.Index) -> RandomAccessSlice<Base>
Added RandomAccessSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added RandomAccessSlice.removeFirst() -> Base._Element
Added RandomAccessSlice.removeFirst(_: Int)
Added RandomAccessSlice.removeLast() -> Base._Element
Added RandomAccessSlice.removeLast(_: Int)
Added RandomAccessSlice.reversed() -> ReversedRandomAccessCollection<RandomAccessSlice<Base>>
Added RandomAccessSlice.sorted() -> [Base._Element]
Added RandomAccessSlice.sorted(by: (Base._Element, Base._Element) -> Bool) -> [Base._Element]
Added RandomAccessSlice.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base._Element) throws -> Bool) rethrows -> [RandomAccessSlice<Base>]
Added RandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<Base>]
Added RandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
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(_: CountableRange<Base.Index>) -> RandomAccessSlice<Base>
Added RandomAccessSlice.subscript(_: Range<Base.Index>) -> RandomAccessSlice<Base>
Added RandomAccessSlice.subscript(_: Base.Index) -> Base._Element
Added RandomAccessSlice.subscript(_: Range<Base.Index>) -> RandomAccessSlice<RandomAccessSlice<Base>>
Added RandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> RandomAccessSlice<Base>
Added RandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> RandomAccessSlice<Base>
Added RandomAccessSlice.suffix(_: Int) -> RandomAccessSlice<Base>
Added RandomAccessSlice.suffix(from: Base.Index) -> RandomAccessSlice<Base>
Added RandomAccessSlice.underestimatedCount
Added RandomAccessSlice.underestimatedCount
Added Range.customMirror
Added Range.isEmpty
Added Range.lowerBound
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.init(repeating: Base._Element, count: Int)
Added RangeReplaceableBidirectionalSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableBidirectionalSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableBidirectionalSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added RangeReplaceableBidirectionalSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added RangeReplaceableBidirectionalSlice.isEmpty
Added RangeReplaceableBidirectionalSlice.joined() -> FlattenSequence<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.joined() -> FlattenCollection<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.joined() -> FlattenBidirectionalCollection<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.joined(separator: String) -> String
Added RangeReplaceableBidirectionalSlice.last
Added RangeReplaceableBidirectionalSlice.lazy
Added RangeReplaceableBidirectionalSlice.lazy
Added RangeReplaceableBidirectionalSlice.lazy
Added RangeReplaceableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableBidirectionalSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableBidirectionalSlice.makeIterator() -> IndexingIterator<RangeReplaceableBidirectionalSlice<Base>>
Added RangeReplaceableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableBidirectionalSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableBidirectionalSlice.max() -> Base._Element?
Added RangeReplaceableBidirectionalSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableBidirectionalSlice.min() -> Base._Element?
Added RangeReplaceableBidirectionalSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableBidirectionalSlice.popFirst() -> Base._Element?
Added RangeReplaceableBidirectionalSlice.popLast() -> Base._Element?
Added RangeReplaceableBidirectionalSlice.prefix(_: Int) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.prefix(through: Base.Index) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.prefix(upTo: Base.Index) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added RangeReplaceableBidirectionalSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableBidirectionalSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeAll(keepingCapacity: Bool)
Added RangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeFirst() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added RangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added RangeReplaceableBidirectionalSlice.removeFirst(_: Int)
Added RangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeLast() -> Base._Element
Added RangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added RangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added RangeReplaceableBidirectionalSlice.removeLast(_: Int)
Added RangeReplaceableBidirectionalSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added RangeReplaceableBidirectionalSlice.removeSubrange(_: Range<Base.Index>)
Added RangeReplaceableBidirectionalSlice.removeSubrange(_: ClosedRange<Base.Index>)
Added RangeReplaceableBidirectionalSlice.removeSubrange(_: CountableRange<Base.Index>)
Added RangeReplaceableBidirectionalSlice.removeSubrange(_: Range<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>(_: ClosedRange<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>(_: CountableClosedRange<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(_: CountableClosedRange<Base.Index>) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.subscript(_: ClosedRange<Base.Index>) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.subscript(_: Base.Index) -> Base._Element
Added RangeReplaceableBidirectionalSlice.subscript(_: Range<Base.Index>) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.suffix(_: Int) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.suffix(from: Base.Index) -> RangeReplaceableBidirectionalSlice<Base>
Added RangeReplaceableBidirectionalSlice.underestimatedCount
Added RangeReplaceableBidirectionalSlice.underestimatedCount
Added RangeReplaceableCollection.append(_: Self.Iterator.Element)
Added RangeReplaceableCollection.append(_: Self.Iterator.Element)
Added RangeReplaceableCollection.append<S : Sequence where S.Iterator.Element == Iterator.Element>(contentsOf: S)
Added RangeReplaceableCollection.append<S : Sequence where S.Iterator.Element == Iterator.Element>(contentsOf: S)
Added RangeReplaceableCollection.init<S : Sequence where S.Iterator.Element == Iterator.Element>(_: S)
Added RangeReplaceableCollection.init<S : Sequence where S.Iterator.Element == Iterator.Element>(_: S)
Added RangeReplaceableCollection.init(repeating: Self.Iterator.Element, count: Int)
Added RangeReplaceableCollection.init(repeating: Self.Iterator.Element, count: Int)
Added RangeReplaceableCollection.insert(_: Self.Iterator.Element, at: Self.Index)
Added RangeReplaceableCollection.insert(_: Self.Iterator.Element, at: Self.Index)
Added RangeReplaceableCollection.insert<S : Collection where S.Iterator.Element == Iterator.Element>(contentsOf: S, at: Self.Index)
Added RangeReplaceableCollection.insert<C : Collection where C.Iterator.Element == Iterator.Element>(contentsOf: C, at: Self.Index)
Added RangeReplaceableCollection.remove(at: Self.Index) -> Self.Iterator.Element
Added RangeReplaceableCollection.remove(at: Self.Index) -> Self.Iterator.Element
Added RangeReplaceableCollection.removeAll(keepingCapacity: Bool)
Added RangeReplaceableCollection.removeAll(keepingCapacity: Bool)
Added RangeReplaceableCollection.removeFirst() -> Self.Iterator.Element
Added RangeReplaceableCollection.removeFirst() -> Self.Iterator.Element
Added RangeReplaceableCollection.removeFirst() -> Self.Iterator.Element
Added RangeReplaceableCollection.removeFirst(_: Int)
Added RangeReplaceableCollection.removeFirst(_: Int)
Added RangeReplaceableCollection.removeFirst(_: Int)
Added RangeReplaceableCollection.removeSubrange(_: CountableClosedRange<Self.Index>)
Added RangeReplaceableCollection.removeSubrange(_: ClosedRange<Self.Index>)
Added RangeReplaceableCollection.removeSubrange(_: Range<Self.Index>)
Added RangeReplaceableCollection.removeSubrange(_: CountableRange<Self.Index>)
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>(_: CountableClosedRange<Self.Index>, with: C)
Added RangeReplaceableCollection.replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_: CountableRange<Self.Index>, with: C)
Added RangeReplaceableCollection.replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_: ClosedRange<Self.Index>, with: C)
Added RangeReplaceableCollection.reserveCapacity(_: Self.IndexDistance)
Added RangeReplaceableCollection.reserveCapacity(_: Self.IndexDistance)
Added RangeReplaceableIndexable
Added RangeReplaceableIndexable.init()
Added RangeReplaceableIndexable.init<S : Sequence where S.Iterator.Element == _Element>(_: S)
Added RangeReplaceableIndexable.init(repeating: Self._Element, count: Int)
Added RangeReplaceableIndexable.insert(_: Self._Element, at: Self.Index)
Added RangeReplaceableIndexable.insert<S : Collection where S.Iterator.Element == _Element>(contentsOf: S, at: Self.Index)
Added RangeReplaceableIndexable.remove(at: Self.Index) -> Self._Element
Added RangeReplaceableIndexable.removeSubrange(_: Range<Self.Index>)
Added RangeReplaceableIndexable.replaceSubrange<C where C : Collection, C.Iterator.Element == _Element>(_: Range<Self.Index>, with: C)
Added RangeReplaceableRandomAccessSlice [struct]
Added RangeReplaceableRandomAccessSlice.append(_: Base._Element)
Added RangeReplaceableRandomAccessSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added RangeReplaceableRandomAccessSlice.base
Added RangeReplaceableRandomAccessSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableRandomAccessSlice.count
Added RangeReplaceableRandomAccessSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added RangeReplaceableRandomAccessSlice.dropFirst() -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.dropFirst(_: Int) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.dropLast() -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.dropLast(_: Int) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableRandomAccessSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableRandomAccessSlice.endIndex
Added RangeReplaceableRandomAccessSlice.enumerated() -> EnumeratedSequence<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added RangeReplaceableRandomAccessSlice.first
Added RangeReplaceableRandomAccessSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableRandomAccessSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added RangeReplaceableRandomAccessSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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 where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added RangeReplaceableRandomAccessSlice.init<S : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added RangeReplaceableRandomAccessSlice.init(base: Base, bounds: Range<Base.Index>)
Added RangeReplaceableRandomAccessSlice.init(repeating: Base._Element, count: Int)
Added RangeReplaceableRandomAccessSlice.init(repeating: Base._Element, count: Int)
Added RangeReplaceableRandomAccessSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableRandomAccessSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableRandomAccessSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added RangeReplaceableRandomAccessSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added RangeReplaceableRandomAccessSlice.isEmpty
Added RangeReplaceableRandomAccessSlice.joined() -> FlattenSequence<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.joined() -> FlattenBidirectionalCollection<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.joined() -> FlattenCollection<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.joined(separator: String) -> String
Added RangeReplaceableRandomAccessSlice.last
Added RangeReplaceableRandomAccessSlice.lazy
Added RangeReplaceableRandomAccessSlice.lazy
Added RangeReplaceableRandomAccessSlice.lazy
Added RangeReplaceableRandomAccessSlice.lazy
Added RangeReplaceableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableRandomAccessSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableRandomAccessSlice.makeIterator() -> IndexingIterator<RangeReplaceableRandomAccessSlice<Base>>
Added RangeReplaceableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableRandomAccessSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableRandomAccessSlice.max() -> Base._Element?
Added RangeReplaceableRandomAccessSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableRandomAccessSlice.min() -> Base._Element?
Added RangeReplaceableRandomAccessSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableRandomAccessSlice.popFirst() -> Base._Element?
Added RangeReplaceableRandomAccessSlice.popLast() -> Base._Element?
Added RangeReplaceableRandomAccessSlice.prefix(_: Int) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.prefix(through: Base.Index) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.prefix(upTo: Base.Index) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added RangeReplaceableRandomAccessSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableRandomAccessSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeAll(keepingCapacity: Bool)
Added RangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeFirst() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added RangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added RangeReplaceableRandomAccessSlice.removeFirst(_: Int)
Added RangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeLast() -> Base._Element
Added RangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added RangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added RangeReplaceableRandomAccessSlice.removeLast(_: Int)
Added RangeReplaceableRandomAccessSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added RangeReplaceableRandomAccessSlice.removeSubrange(_: Range<Base.Index>)
Added RangeReplaceableRandomAccessSlice.removeSubrange(_: ClosedRange<Base.Index>)
Added RangeReplaceableRandomAccessSlice.removeSubrange(_: CountableRange<Base.Index>)
Added RangeReplaceableRandomAccessSlice.removeSubrange(_: Range<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) -> [RangeReplaceableRandomAccessSlice<Base>]
Added RangeReplaceableRandomAccessSlice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
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(_: Base.Index) -> Base._Element
Added RangeReplaceableRandomAccessSlice.subscript(_: ClosedRange<Base.Index>) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.subscript(_: CountableRange<Base.Index>) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.subscript(_: CountableClosedRange<Base.Index>) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.subscript(_: Range<Base.Index>) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.suffix(_: Int) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.suffix(from: Base.Index) -> RangeReplaceableRandomAccessSlice<Base>
Added RangeReplaceableRandomAccessSlice.underestimatedCount
Added RangeReplaceableRandomAccessSlice.underestimatedCount
Added RangeReplaceableSlice [struct]
Added RangeReplaceableSlice.append(_: Base._Element)
Added RangeReplaceableSlice.append<S : Sequence where S.Iterator.Element == Base._Element>(contentsOf: S)
Added RangeReplaceableSlice.base
Added RangeReplaceableSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableSlice.count
Added RangeReplaceableSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added RangeReplaceableSlice.dropFirst() -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.dropFirst(_: Int) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.dropLast() -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.dropLast(_: Int) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableSlice.endIndex
Added RangeReplaceableSlice.enumerated() -> EnumeratedSequence<RangeReplaceableSlice<Base>>
Added RangeReplaceableSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added RangeReplaceableSlice.first
Added RangeReplaceableSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added RangeReplaceableSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added RangeReplaceableSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added RangeReplaceableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added RangeReplaceableSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added RangeReplaceableSlice.formIndex(after: Base.Index)
Added RangeReplaceableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added RangeReplaceableSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added RangeReplaceableSlice.index(after: Base.Index) -> Base.Index
Added RangeReplaceableSlice.index(of: Base._Element) -> Base.Index?
Added RangeReplaceableSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added RangeReplaceableSlice.indices
Added RangeReplaceableSlice.init()
Added RangeReplaceableSlice.init<S where S : Sequence, S.Iterator.Element == Base._Element>(_: S)
Added RangeReplaceableSlice.init<S : Sequence where S.Iterator.Element == Base._Element>(_: S)
Added RangeReplaceableSlice.init(base: Base, bounds: Range<Base.Index>)
Added RangeReplaceableSlice.init(repeating: Base._Element, count: Int)
Added RangeReplaceableSlice.init(repeating: Base._Element, count: Int)
Added RangeReplaceableSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableSlice.insert(_: Base._Element, at: Base.Index)
Added RangeReplaceableSlice.insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf: S, at: Base.Index)
Added RangeReplaceableSlice.insert<C : Collection where C.Iterator.Element == Base._Element>(contentsOf: C, at: Base.Index)
Added RangeReplaceableSlice.isEmpty
Added RangeReplaceableSlice.joined() -> FlattenSequence<RangeReplaceableSlice<Base>>
Added RangeReplaceableSlice.joined() -> FlattenCollection<RangeReplaceableSlice<Base>>
Added RangeReplaceableSlice.joined(separator: String) -> String
Added RangeReplaceableSlice.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<RangeReplaceableSlice<Base>>
Added RangeReplaceableSlice.lazy
Added RangeReplaceableSlice.lazy
Added RangeReplaceableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added RangeReplaceableSlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added RangeReplaceableSlice.makeIterator() -> IndexingIterator<RangeReplaceableSlice<Base>>
Added RangeReplaceableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableSlice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added RangeReplaceableSlice.max() -> Base._Element?
Added RangeReplaceableSlice.max(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableSlice.min() -> Base._Element?
Added RangeReplaceableSlice.min(by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element?
Added RangeReplaceableSlice.popFirst() -> Base._Element?
Added RangeReplaceableSlice.prefix(_: Int) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.prefix(through: Base.Index) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.prefix(upTo: Base.Index) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added RangeReplaceableSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableSlice.remove(at: Base.Index) -> Base._Element
Added RangeReplaceableSlice.removeAll(keepingCapacity: Bool)
Added RangeReplaceableSlice.removeFirst() -> Base._Element
Added RangeReplaceableSlice.removeFirst() -> Base._Element
Added RangeReplaceableSlice.removeFirst() -> Base._Element
Added RangeReplaceableSlice.removeFirst(_: Int)
Added RangeReplaceableSlice.removeFirst(_: Int)
Added RangeReplaceableSlice.removeFirst(_: Int)
Added RangeReplaceableSlice.removeSubrange(_: Range<Base.Index>)
Added RangeReplaceableSlice.removeSubrange(_: Range<Base.Index>)
Added RangeReplaceableSlice.removeSubrange(_: CountableRange<Base.Index>)
Added RangeReplaceableSlice.removeSubrange(_: CountableClosedRange<Base.Index>)
Added RangeReplaceableSlice.removeSubrange(_: ClosedRange<Base.Index>)
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>(_: ClosedRange<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(_: ClosedRange<Base.Index>) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.subscript(_: CountableRange<Base.Index>) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.subscript(_: Range<Base.Index>) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.subscript(_: Base.Index) -> Base._Element
Added RangeReplaceableSlice.subscript(_: CountableClosedRange<Base.Index>) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.suffix(_: Int) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.suffix(from: Base.Index) -> RangeReplaceableSlice<Base>
Added RangeReplaceableSlice.underestimatedCount
Added RangeReplaceableSlice.underestimatedCount
Added Repeated [struct]
Added Repeated.count
Added Repeated.count
Added Repeated.distance(from: Int, to: Int) -> Int
Added Repeated.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Repeated.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Repeated.endIndex
Added Repeated.first
Added Repeated.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Repeated.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Repeated.formIndex(_: Int, offsetBy: Int)
Added Repeated.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Repeated.formIndex(after: Int)
Added Repeated.formIndex(before: Int)
Added Repeated.index(_: Int, offsetBy: Int) -> Int
Added Repeated.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added Repeated.index(after: Int) -> Int
Added Repeated.index(before: Int) -> Int
Added Repeated.index(of: Element) -> Int?
Added Repeated.index(where: (Element) throws -> Bool) rethrows -> Int?
Added Repeated.indices
Added Repeated.isEmpty
Added Repeated.joined() -> FlattenSequence<Repeated<Element>>
Added Repeated.joined() -> FlattenCollection<Repeated<Element>>
Added Repeated.joined() -> FlattenBidirectionalCollection<Repeated<Element>>
Added Repeated.joined(separator: String) -> String
Added Repeated.last
Added Repeated.lazy
Added Repeated.lazy
Added Repeated.lazy
Added Repeated.lazy
Added Repeated.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Repeated.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Repeated.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Repeated.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Repeated.repeatedValue
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(_: CountableClosedRange<Int>) -> RandomAccessSlice<Repeated<Element>>
Added Repeated.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Repeated<Element>>
Added Repeated.subscript(_: CountableRange<Int>) -> RandomAccessSlice<Repeated<Element>>
Added Repeated.subscript(_: Range<Int>) -> RandomAccessSlice<Repeated<Element>>
Added Repeated.underestimatedCount
Added Repeated.underestimatedCount
Added ReversedCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedCollection.count
Added ReversedCollection.distance(from: ReversedIndex<Base>, to: ReversedIndex<Base>) -> Base.IndexDistance
Added ReversedCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added ReversedCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedCollection.endIndex
Added ReversedCollection.filter(_: (Base.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element]
Added ReversedCollection.first
Added ReversedCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ReversedCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ReversedCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added ReversedCollection.formIndex(_: ReversedIndex<Base>, offsetBy: Base.IndexDistance)
Added ReversedCollection.formIndex(_: ReversedIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: ReversedIndex<Base>) -> Bool
Added ReversedCollection.formIndex(after: ReversedIndex<Base>)
Added ReversedCollection.formIndex(before: ReversedIndex<Base>)
Added ReversedCollection.index(_: ReversedIndex<Base>, offsetBy: Base.IndexDistance) -> ReversedIndex<Base>
Added ReversedCollection.index(_: ReversedIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: ReversedIndex<Base>) -> ReversedIndex<Base>?
Added ReversedCollection.index(after: ReversedIndex<Base>) -> ReversedIndex<Base>
Added ReversedCollection.index(before: ReversedIndex<Base>) -> ReversedIndex<Base>
Added ReversedCollection.index(of: Base.Iterator.Element) -> ReversedIndex<Base>?
Added ReversedCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> ReversedIndex<Base>?
Added ReversedCollection.indices
Added ReversedCollection.joined() -> FlattenSequence<ReversedCollection<Base>>
Added ReversedCollection.joined() -> FlattenCollection<ReversedCollection<Base>>
Added ReversedCollection.joined() -> FlattenBidirectionalCollection<ReversedCollection<Base>>
Added ReversedCollection.joined(separator: String) -> String
Added ReversedCollection.last
Added ReversedCollection.lazy
Added ReversedCollection.lazy
Added ReversedCollection.lazy
Added ReversedCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added ReversedCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added ReversedCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added ReversedCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedCollection.prefix(through: ReversedIndex<Base>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.prefix(upTo: ReversedIndex<Base>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added ReversedCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added ReversedCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<ReversedCollection<Base>>]
Added ReversedCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<ReversedCollection<Base>>]
Added ReversedCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added ReversedCollection.startIndex
Added ReversedCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix) -> Bool
Added ReversedCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with: PossiblePrefix, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedCollection.subscript(_: Range<ReversedIndex<Base>>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.subscript(_: Range<ReversedIndex<Base>>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.subscript(_: ReversedIndex<Base>) -> Base.Iterator.Element
Added ReversedCollection.subscript(_: ClosedRange<ReversedIndex<Base>>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.suffix(from: ReversedIndex<Base>) -> BidirectionalSlice<ReversedCollection<Base>>
Added ReversedCollection.underestimatedCount
Added ReversedCollection.underestimatedCount
Added ReversedIndex [struct]
Added ReversedIndex.base
Added ReversedIndex.init(_: Base.Index)
Added ReversedRandomAccessCollection [struct]
Added ReversedRandomAccessCollection.contains(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedRandomAccessCollection.count
Added ReversedRandomAccessCollection.distance(from: ReversedRandomAccessIndex<Base>, to: ReversedRandomAccessIndex<Base>) -> Base.IndexDistance
Added ReversedRandomAccessCollection.dropFirst() -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.dropFirst(_: Int) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.dropLast() -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.dropLast(_: Int) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added ReversedRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedRandomAccessCollection.endIndex
Added ReversedRandomAccessCollection.enumerated() -> EnumeratedSequence<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.filter(_: (Base.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element]
Added ReversedRandomAccessCollection.first
Added ReversedRandomAccessCollection.first(where: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ReversedRandomAccessCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ReversedRandomAccessCollection.forEach(_: (Base.Iterator.Element) throws -> Void) rethrows
Added ReversedRandomAccessCollection.formIndex(_: ReversedRandomAccessIndex<Base>, offsetBy: Base.IndexDistance)
Added ReversedRandomAccessCollection.formIndex(_: ReversedRandomAccessIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: ReversedRandomAccessIndex<Base>) -> Bool
Added ReversedRandomAccessCollection.formIndex(after: ReversedRandomAccessIndex<Base>)
Added ReversedRandomAccessCollection.formIndex(before: ReversedRandomAccessIndex<Base>)
Added ReversedRandomAccessCollection.index(_: ReversedRandomAccessIndex<Base>, offsetBy: Base.IndexDistance) -> ReversedRandomAccessIndex<Base>
Added ReversedRandomAccessCollection.index(_: ReversedRandomAccessIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: ReversedRandomAccessIndex<Base>) -> ReversedRandomAccessIndex<Base>?
Added ReversedRandomAccessCollection.index(after: ReversedRandomAccessIndex<Base>) -> ReversedRandomAccessIndex<Base>
Added ReversedRandomAccessCollection.index(before: ReversedRandomAccessIndex<Base>) -> ReversedRandomAccessIndex<Base>
Added ReversedRandomAccessCollection.index(of: Base.Iterator.Element) -> ReversedRandomAccessIndex<Base>?
Added ReversedRandomAccessCollection.index(where: (Base.Iterator.Element) throws -> Bool) rethrows -> ReversedRandomAccessIndex<Base>?
Added ReversedRandomAccessCollection.indices
Added ReversedRandomAccessCollection.isEmpty
Added ReversedRandomAccessCollection.joined() -> FlattenSequence<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.joined() -> FlattenCollection<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.joined() -> FlattenBidirectionalCollection<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.joined(separator: String) -> String
Added ReversedRandomAccessCollection.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.last
Added ReversedRandomAccessCollection.lazy
Added ReversedRandomAccessCollection.lazy
Added ReversedRandomAccessCollection.lazy
Added ReversedRandomAccessCollection.lazy
Added ReversedRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence) -> Bool
Added ReversedRandomAccessCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_: OtherSequence, by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added ReversedRandomAccessCollection.makeIterator() -> IndexingIterator<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added ReversedRandomAccessCollection.map<T>(_: (Base.Iterator.Element) throws -> T) rethrows -> [T]
Added ReversedRandomAccessCollection.max() -> Base.Iterator.Element?
Added ReversedRandomAccessCollection.max(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedRandomAccessCollection.min() -> Base.Iterator.Element?
Added ReversedRandomAccessCollection.min(by: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element?
Added ReversedRandomAccessCollection.prefix(_: Int) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.prefix(through: ReversedRandomAccessIndex<Base>) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.prefix(upTo: ReversedRandomAccessIndex<Base>) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result
Added ReversedRandomAccessCollection.reversed() -> ReversedRandomAccessCollection<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.sorted() -> [Base.Iterator.Element]
Added ReversedRandomAccessCollection.sorted(by: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element]
Added ReversedRandomAccessCollection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [RandomAccessSlice<ReversedRandomAccessCollection<Base>>]
Added ReversedRandomAccessCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base.Iterator.Element>]
Added ReversedRandomAccessCollection.split(separator: Base.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<ReversedRandomAccessCollection<Base>>]
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(_: ClosedRange<ReversedRandomAccessIndex<Base>>) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.subscript(_: ReversedRandomAccessIndex<Base>) -> Base.Iterator.Element
Added ReversedRandomAccessCollection.subscript(_: Range<ReversedRandomAccessIndex<Base>>) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.suffix(_: Int) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.suffix(from: ReversedRandomAccessIndex<Base>) -> RandomAccessSlice<ReversedRandomAccessCollection<Base>>
Added ReversedRandomAccessCollection.underestimatedCount
Added ReversedRandomAccessCollection.underestimatedCount
Added ReversedRandomAccessIndex [struct]
Added ReversedRandomAccessIndex.base
Added ReversedRandomAccessIndex.init(_: Base.Index)
Added Sequence
Added Sequence.contains(_: Self.Iterator.Element) -> Bool
Added Sequence.contains(where: (Self.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Sequence.dropFirst(_: Int) -> Self.SubSequence
Added Sequence.dropFirst(_: Int) -> AnySequence<Self.Iterator.Element>
Added Sequence.dropLast(_: Int) -> AnySequence<Self.Iterator.Element>
Added Sequence.dropLast(_: Int) -> Self.SubSequence
Added Sequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_: OtherSequence) -> Bool
Added Sequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_: OtherSequence, by: (Self.Iterator.Element, Self.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Sequence.filter(_: (Self.Iterator.Element) throws -> Bool) rethrows -> [Self.Iterator.Element]
Added Sequence.filter(_: (Self.Iterator.Element) throws -> Bool) rethrows -> [Self.Iterator.Element]
Added Sequence.first(where: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Iterator.Element?
Added Sequence.first(where: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Iterator.Element?
Added Sequence.flatMap<SegmentOfResult : Sequence>(_: (Self.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Sequence.flatMap<ElementOfResult>(_: (Self.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Sequence.forEach(_: (Self.Iterator.Element) throws -> Swift.Void) rethrows
Added Sequence.forEach(_: (Self.Iterator.Element) throws -> Swift.Void) rethrows
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.map<T>(_: (Self.Iterator.Element) throws -> T) rethrows -> [T]
Added Sequence.max(by: (Self.Iterator.Element, Self.Iterator.Element) throws -> Bool) rethrows -> Self.Iterator.Element?
Added Sequence.min(by: (Self.Iterator.Element, Self.Iterator.Element) throws -> Bool) rethrows -> Self.Iterator.Element?
Added Sequence.prefix(_: Int) -> AnySequence<Self.Iterator.Element>
Added Sequence.prefix(_: Int) -> Self.SubSequence
Added Sequence.reduce<Result>(_: Result, _: (Result, Self.Iterator.Element) throws -> Result) rethrows -> Result
Added Sequence.sorted(by: (Self.Iterator.Element, Self.Iterator.Element) -> Bool) -> [Self.Iterator.Element]
Added Sequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Self.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Self.Iterator.Element>]
Added Sequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Self.Iterator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Added Sequence.split(separator: Self.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Self.Iterator.Element>]
Added Sequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(with: PossiblePrefix) -> Bool
Added Sequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(with: PossiblePrefix, by: (Self.Iterator.Element, Self.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Sequence.suffix(_: Int) -> Self.SubSequence
Added Sequence.suffix(_: Int) -> AnySequence<Self.Iterator.Element>
Added Sequence.underestimatedCount
Added Sequence.underestimatedCount
Added Set.count
Added Set.customMirror
Added Set.distance(from: SetIndex<Element>, to: SetIndex<Element>) -> Int
Added Set.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Set.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Set.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added Set.first
Added Set.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Set.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Set.formIndex(_: SetIndex<Element>, offsetBy: Int)
Added Set.formIndex(_: SetIndex<Element>, offsetBy: Int, limitedBy: SetIndex<Element>) -> Bool
Added Set.formIndex(after: SetIndex<Element>)
Added Set.formIntersection<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Set.formSymmetricDifference<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Set.formUnion<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Set.index(_: SetIndex<Element>, offsetBy: Int) -> SetIndex<Element>
Added Set.index(_: SetIndex<Element>, offsetBy: Int, limitedBy: SetIndex<Element>) -> SetIndex<Element>?
Added Set.index(after: SetIndex<Element>) -> SetIndex<Element>
Added Set.index(of: Element) -> SetIndex<Element>?
Added Set.index(where: (Element) throws -> Bool) rethrows -> SetIndex<Element>?
Added Set.indices
Added Set.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Set.init<Source : Sequence where Source.Iterator.Element == Element>(_: Source)
Added Set.init(arrayLiteral: Element)
Added Set.insert<ConcreteElement : Hashable>(_: ConcreteElement) -> (inserted: Bool, memberAfterInsert: ConcreteElement)
Added Set.intersection<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>
Added Set.isDisjoint<S : Sequence where S.Iterator.Element == Element>(with: S) -> Bool
Added Set.isEmpty
Added Set.isEmpty
Added Set.isStrictSubset<S : Sequence where S.Iterator.Element == Element>(of: S) -> Bool
Added Set.isStrictSuperset<S : Sequence where S.Iterator.Element == Element>(of: S) -> Bool
Added Set.isSubset<S : Sequence where S.Iterator.Element == Element>(of: S) -> Bool
Added Set.isSuperset<S : Sequence where S.Iterator.Element == Element>(of: S) -> Bool
Added Set.joined() -> FlattenSequence<Set<Element>>
Added Set.joined() -> FlattenCollection<Set<Element>>
Added Set.lazy
Added Set.lazy
Added Set.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Set.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Set.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Set.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Set.max() -> Element?
Added Set.min() -> Element?
Added Set.remove<ConcreteElement : Hashable>(_: ConcreteElement) -> ConcreteElement?
Added Set.remove(at: SetIndex<Element>) -> Element
Added Set.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added Set.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Set.subscript(_: Range<SetIndex<Element>>) -> Slice<Set<Element>>
Added Set.subscript(_: ClosedRange<SetIndex<Element>>) -> Slice<Set<Element>>
Added Set.subtract<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Set.subtracting<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>
Added Set.symmetricDifference<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>
Added Set.underestimatedCount
Added Set.underestimatedCount
Added Set.union<S : Sequence where S.Iterator.Element == Element>(_: S) -> Set<Element>
Added Set.update<ConcreteElement : Hashable>(with: ConcreteElement) -> ConcreteElement?
Added SetAlgebra
Added SetAlgebra.init()
Added SetAlgebra.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added SetAlgebra.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added SetAlgebra.isDisjoint(with: Self) -> Bool
Added SetAlgebra.isDisjoint(with: Self) -> Bool
Added SetAlgebra.isEmpty
Added SetAlgebra.isEmpty
Added SetAlgebra.isSubset(of: Self) -> Bool
Added SetAlgebra.isSubset(of: Self) -> Bool
Added SetAlgebra.isSuperset(of: Self) -> Bool
Added SetAlgebra.isSuperset(of: Self) -> Bool
Added SetAlgebra.subtract(_: Self)
Added SetAlgebra.subtract(_: Self)
Added SetAlgebra.subtracting(_: Self) -> Self
Added SetAlgebra.subtracting(_: Self) -> Self
Added SetIterator [struct]
Added SetIterator.customMirror
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.count
Added Slice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added Slice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added Slice.first
Added Slice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Slice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Slice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added Slice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added Slice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added Slice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added Slice.index(of: Base._Element) -> Base.Index?
Added Slice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added Slice.indices
Added Slice.isEmpty
Added Slice.joined() -> FlattenSequence<Slice<Base>>
Added Slice.joined() -> FlattenCollection<Slice<Base>>
Added Slice.lazy
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.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added Slice.map<T>(_: (Base._Element) throws -> T) rethrows -> [T]
Added Slice.reduce<Result>(_: Result, _: (Result, Base._Element) throws -> Result) rethrows -> Result
Added Slice.removeFirst(_: Int)
Added Slice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Slice<Base>]
Added Slice.split(separator: Base._Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Base._Element>]
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(_: ClosedRange<Base.Index>) -> Slice<Base>
Added Slice.subscript(_: CountableRange<Base.Index>) -> Slice<Base>
Added Slice.subscript(_: CountableClosedRange<Base.Index>) -> Slice<Base>
Added Slice.subscript(_: Range<Base.Index>) -> Slice<Slice<Base>>
Added Slice.underestimatedCount
Added Slice.underestimatedCount
Added StrideThrough.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added StrideThrough.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added StrideThrough.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added StrideThrough.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added StrideThrough.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added StrideThrough.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added StrideTo.customMirror
Added StrideTo.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added StrideTo.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added StrideTo.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added StrideTo.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added StrideTo.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added String.append(_: String)
Added String.customMirror
Added String.description
Added String.init<T : _SignedInteger>(_: T)
Added String.init(_: String)
Added String.init<T : UnsignedInteger>(_: T)
Added String.init<T : UnsignedInteger>(_: T, radix: Int, uppercase: Bool)
Added String.init<T : _SignedInteger>(_: T, radix: Int, uppercase: Bool)
Added String.insert(_: Character, at: String.Index)
Added String.insert<S : Collection where S.Iterator.Element == Character>(contentsOf: S, at: String.Index)
Added String.remove(at: String.Index) -> Character
Added String.removeSubrange(_: Range<String.Index>)
Added String.removeSubrange(_: ClosedRange<String.Index>)
Added String.replaceSubrange(_: Range<String.Index>, with: String)
Added String.replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_: ClosedRange<String.Index>, with: C)
Added String.replaceSubrange(_: ClosedRange<String.Index>, with: String)
Added String.subscript(_: ClosedRange<String.Index>) -> String
Added String.utf8CString
Added String.CharacterView.append<S : Sequence where S.Iterator.Element == Character>(contentsOf: S)
Added String.CharacterView.index(after: String.CharacterView.Index) -> String.CharacterView.Index
Added String.CharacterView.index(before: String.CharacterView.Index) -> String.CharacterView.Index
Added String.CharacterView.init<S : Sequence where S.Iterator.Element == Character>(_: S)
Added String.CharacterView.replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_: Range<String.CharacterView.Index>, with: C)
Added String.CharacterView.Index.customPlaygroundQuickLook
Added String.UnicodeScalarView.contains(_: UnicodeScalar) -> Bool
Added String.UnicodeScalarView.contains(where: (UnicodeScalar) throws -> Bool) rethrows -> Bool
Added String.UnicodeScalarView.distance(from: String.UnicodeScalarView.Index, to: String.UnicodeScalarView.Index) -> Int
Added String.UnicodeScalarView.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_: OtherSequence) -> Bool
Added String.UnicodeScalarView.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_: OtherSequence, by: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
Added String.UnicodeScalarView.filter(_: (UnicodeScalar) throws -> Bool) rethrows -> [UnicodeScalar]
Added String.UnicodeScalarView.first
Added String.UnicodeScalarView.first(where: (UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
Added String.UnicodeScalarView.flatMap<ElementOfResult>(_: (UnicodeScalar) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added String.UnicodeScalarView.flatMap<SegmentOfResult : Sequence>(_: (UnicodeScalar) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added String.UnicodeScalarView.forEach(_: (UnicodeScalar) throws -> Void) rethrows
Added String.UnicodeScalarView.formIndex(_: String.UnicodeScalarView.Index, offsetBy: Int)
Added String.UnicodeScalarView.formIndex(_: String.UnicodeScalarView.Index, offsetBy: Int, limitedBy: String.UnicodeScalarView.Index) -> Bool
Added String.UnicodeScalarView.formIndex(after: String.UnicodeScalarView.Index)
Added String.UnicodeScalarView.formIndex(before: String.UnicodeScalarView.Index)
Added String.UnicodeScalarView.index(_: String.UnicodeScalarView.Index, offsetBy: Int) -> String.UnicodeScalarView.Index
Added String.UnicodeScalarView.index(_: String.UnicodeScalarView.Index, offsetBy: Int, limitedBy: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index?
Added String.UnicodeScalarView.index(of: UnicodeScalar) -> String.UnicodeScalarView.Index?
Added String.UnicodeScalarView.index(where: (UnicodeScalar) throws -> Bool) rethrows -> String.UnicodeScalarView.Index?
Added String.UnicodeScalarView.indices
Added String.UnicodeScalarView.last
Added String.UnicodeScalarView.lazy
Added String.UnicodeScalarView.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_: OtherSequence) -> Bool
Added String.UnicodeScalarView.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_: OtherSequence, by: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool
Added String.UnicodeScalarView.map<T>(_: (UnicodeScalar) throws -> T) rethrows -> [T]
Added String.UnicodeScalarView.map<T>(_: (UnicodeScalar) throws -> T) rethrows -> [T]
Added String.UnicodeScalarView.max(by: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
Added String.UnicodeScalarView.min(by: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar?
Added String.UnicodeScalarView.popFirst() -> UnicodeScalar?
Added String.UnicodeScalarView.popLast() -> UnicodeScalar?
Added String.UnicodeScalarView.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.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(from: String.UnicodeScalarView.Index) -> String.UnicodeScalarView
Added String.UnicodeScalarView.underestimatedCount
Added String.UnicodeScalarView.underestimatedCount
Added String.UTF16View.count
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.first
Added String.UTF16View.flatMap<ElementOfResult>(_: (UInt16) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added String.UTF16View.flatMap<SegmentOfResult : Sequence>(_: (UInt16) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added String.UTF16View.formIndex(_: String.UTF16View.Index, offsetBy: Int)
Added String.UTF16View.formIndex(_: String.UTF16View.Index, offsetBy: Int, limitedBy: String.UTF16View.Index) -> Bool
Added String.UTF16View.formIndex(after: String.UTF16View.Index)
Added String.UTF16View.formIndex(before: String.UTF16View.Index)
Added String.UTF16View.index(of: UInt16) -> String.UTF16View.Index?
Added String.UTF16View.index(where: (UInt16) throws -> Bool) rethrows -> String.UTF16View.Index?
Added String.UTF16View.indices
Added String.UTF16View.isEmpty
Added String.UTF16View.last
Added String.UTF16View.lazy
Added String.UTF16View.lazy
Added String.UTF16View.lazy
Added String.UTF16View.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence) -> Bool
Added String.UTF16View.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added String.UTF16View.map<T>(_: (UInt16) throws -> T) rethrows -> [T]
Added String.UTF16View.map<T>(_: (UInt16) throws -> T) rethrows -> [T]
Added String.UTF16View.popFirst() -> UInt16?
Added String.UTF16View.popLast() -> UInt16?
Added String.UTF16View.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.split(separator: UInt16, maxSplits: Int, omittingEmptySubsequences: Bool) -> [String.UTF16View]
Added String.UTF16View.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with: PossiblePrefix) -> Bool
Added String.UTF16View.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with: PossiblePrefix, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added String.UTF16View.subscript(_: ClosedRange<String.UTF16View.Index>) -> String.UTF16View
Added String.UTF16View.underestimatedCount
Added String.UTF16View.underestimatedCount
Added String.UTF16View.Index.samePosition(in: String.UnicodeScalarView) -> String.UnicodeScalarIndex?
Added String.UTF16View.Index.samePosition(in: String.UTF8View) -> String.UTF8View.Index?
Added String.UTF16View.Index.samePosition(in: String) -> String.Index?
Added String.UTF8View.count
Added String.UTF8View.distance(from: String.UTF8View.Index, to: String.UTF8View.Index) -> Int
Added String.UTF8View.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence) -> Bool
Added String.UTF8View.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added String.UTF8View.first
Added String.UTF8View.flatMap<SegmentOfResult : Sequence>(_: (UInt8) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added String.UTF8View.flatMap<ElementOfResult>(_: (UInt8) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added String.UTF8View.formIndex(_: String.UTF8View.Index, offsetBy: Int)
Added String.UTF8View.formIndex(_: String.UTF8View.Index, offsetBy: Int, limitedBy: String.UTF8View.Index) -> Bool
Added String.UTF8View.formIndex(after: String.UTF8View.Index)
Added String.UTF8View.index(_: String.UTF8View.Index, offsetBy: Int) -> String.UTF8View.Index
Added String.UTF8View.index(_: String.UTF8View.Index, offsetBy: Int, limitedBy: String.UTF8View.Index) -> String.UTF8View.Index?
Added String.UTF8View.index(of: UInt8) -> String.UTF8View.Index?
Added String.UTF8View.index(where: (UInt8) throws -> Bool) rethrows -> String.UTF8View.Index?
Added String.UTF8View.indices
Added String.UTF8View.isEmpty
Added String.UTF8View.lazy
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.map<T>(_: (UInt8) throws -> T) rethrows -> [T]
Added String.UTF8View.map<T>(_: (UInt8) throws -> T) rethrows -> [T]
Added String.UTF8View.popFirst() -> UInt8?
Added String.UTF8View.reduce<Result>(_: Result, _: (Result, UInt8) throws -> Result) rethrows -> Result
Added String.UTF8View.removeFirst() -> UInt8
Added String.UTF8View.removeFirst(_: Int)
Added String.UTF8View.split(separator: UInt8, maxSplits: Int, omittingEmptySubsequences: Bool) -> [String.UTF8View]
Added String.UTF8View.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with: PossiblePrefix) -> Bool
Added String.UTF8View.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with: PossiblePrefix, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added String.UTF8View.subscript(_: ClosedRange<String.UTF8View.Index>) -> String.UTF8View
Added String.UTF8View.underestimatedCount
Added String.UTF8View.underestimatedCount
Added String.UTF8View.Index.samePosition(in: String.UnicodeScalarView) -> String.UnicodeScalarIndex?
Added String.UTF8View.Index.samePosition(in: String.UTF16View) -> String.UTF16View.Index?
Added String.UTF8View.Index.samePosition(in: String) -> String.Index?
Added TextOutputStream
Added TextOutputStreamable
Added UInt.customMirror
Added UInt.init(exactly: Int32)
Added UInt.init(exactly: UInt16)
Added UInt.init(exactly: Int64)
Added UInt.init(exactly: UInt32)
Added UInt.init(exactly: Int16)
Added UInt.init(exactly: Int)
Added UInt.init(exactly: UInt)
Added UInt.init(exactly: UInt8)
Added UInt.init(exactly: Int8)
Added UInt.init(exactly: UInt64)
Added UInt16.customMirror
Added UInt16.init(exactly: Int)
Added UInt16.init(exactly: Int32)
Added UInt16.init(exactly: UInt64)
Added UInt16.init(exactly: UInt32)
Added UInt16.init(exactly: UInt)
Added UInt16.init(exactly: UInt16)
Added UInt16.init(exactly: UInt8)
Added UInt16.init(exactly: Int8)
Added UInt16.init(exactly: Int16)
Added UInt16.init(exactly: Int64)
Added UInt32.customMirror
Added UInt32.init(exactly: Int16)
Added UInt32.init(exactly: UInt32)
Added UInt32.init(exactly: Int64)
Added UInt32.init(exactly: UInt16)
Added UInt32.init(exactly: Int8)
Added UInt32.init(exactly: Int32)
Added UInt32.init(exactly: UInt64)
Added UInt32.init(exactly: UInt8)
Added UInt32.init(exactly: Int)
Added UInt32.init(exactly: UInt)
Added UInt64.customMirror
Added UInt64.init(exactly: Int32)
Added UInt64.init(exactly: UInt)
Added UInt64.init(exactly: Int16)
Added UInt64.init(exactly: UInt32)
Added UInt64.init(exactly: UInt8)
Added UInt64.init(exactly: Int)
Added UInt64.init(exactly: Int8)
Added UInt64.init(exactly: Int64)
Added UInt64.init(exactly: UInt64)
Added UInt64.init(exactly: UInt16)
Added UInt8.customMirror
Added UInt8.init(exactly: UInt16)
Added UInt8.init(exactly: UInt)
Added UInt8.init(exactly: Int32)
Added UInt8.init(exactly: UInt8)
Added UInt8.init(exactly: Int8)
Added UInt8.init(exactly: Int)
Added UInt8.init(exactly: Int64)
Added UInt8.init(exactly: UInt32)
Added UInt8.init(exactly: Int16)
Added UInt8.init(exactly: UInt64)
Added UnfoldSequence [struct]
Added UnfoldSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnfoldSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnfoldSequence.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added UnfoldSequence.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added UnfoldSequence.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.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added UnfoldSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added UnfoldSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnicodeCodec
Added UnicodeCodec.decode<I : IteratorProtocol where I.Element == CodeUnit>(_: I) -> UnicodeDecodingResult
Added UnicodeCodec.encode(_: UnicodeScalar, into: (Self.CodeUnit) -> Swift.Void) [class]
Added UnicodeCodec.init()
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.UTF8View) -> String.UTF8View.Index
Added UnicodeScalarIndex.samePosition(in: String.UTF16View) -> String.UTF16View.Index
Added UnicodeScalarIndex.samePosition(in: String) -> String.Index?
Added UnsafeBufferPointer.count
Added UnsafeBufferPointer.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeBufferPointer.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointer.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added UnsafeBufferPointer.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added UnsafeBufferPointer.formIndex(_: Int, offsetBy: Int)
Added UnsafeBufferPointer.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added UnsafeBufferPointer.index(of: Element) -> Int?
Added UnsafeBufferPointer.index(where: (Element) throws -> Bool) rethrows -> Int?
Added UnsafeBufferPointer.joined() -> FlattenSequence<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.joined() -> FlattenCollection<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.joined() -> FlattenBidirectionalCollection<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.joined(separator: String) -> String
Added UnsafeBufferPointer.last
Added UnsafeBufferPointer.lazy
Added UnsafeBufferPointer.lazy
Added UnsafeBufferPointer.lazy
Added UnsafeBufferPointer.lazy
Added UnsafeBufferPointer.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeBufferPointer.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointer.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added UnsafeBufferPointer.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added UnsafeBufferPointer.reversed() -> ReversedRandomAccessCollection<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(_: Range<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.subscript(_: CountableRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.subscript(_: Range<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>>
Added UnsafeBufferPointer.underestimatedCount
Added UnsafeBufferPointer.underestimatedCount
Added UnsafeBufferPointerIterator [struct]
Added UnsafeBufferPointerIterator.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointerIterator.dropFirst() -> AnySequence<Element>
Added UnsafeBufferPointerIterator.dropFirst(_: Int) -> AnySequence<Element>
Added UnsafeBufferPointerIterator.dropLast() -> AnySequence<Element>
Added UnsafeBufferPointerIterator.dropLast(_: Int) -> AnySequence<Element>
Added UnsafeBufferPointerIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeBufferPointerIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointerIterator.enumerated() -> EnumeratedSequence<UnsafeBufferPointerIterator<Element>>
Added UnsafeBufferPointerIterator.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added UnsafeBufferPointerIterator.first(where: (Element) throws -> Bool) rethrows -> Element?
Added UnsafeBufferPointerIterator.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added UnsafeBufferPointerIterator.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added UnsafeBufferPointerIterator.forEach(_: (Element) throws -> Void) rethrows
Added UnsafeBufferPointerIterator.joined() -> FlattenSequence<UnsafeBufferPointerIterator<Element>>
Added UnsafeBufferPointerIterator.joined(separator: String) -> String
Added UnsafeBufferPointerIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<UnsafeBufferPointerIterator<Element>>
Added UnsafeBufferPointerIterator.lazy
Added UnsafeBufferPointerIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeBufferPointerIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointerIterator.makeIterator() -> UnsafeBufferPointerIterator<Element>
Added UnsafeBufferPointerIterator.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added UnsafeBufferPointerIterator.max() -> Element?
Added UnsafeBufferPointerIterator.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added UnsafeBufferPointerIterator.min() -> Element?
Added UnsafeBufferPointerIterator.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added UnsafeBufferPointerIterator.next() -> Element?
Added UnsafeBufferPointerIterator.prefix(_: Int) -> AnySequence<Element>
Added UnsafeBufferPointerIterator.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added UnsafeBufferPointerIterator.reversed() -> [Element]
Added UnsafeBufferPointerIterator.sorted() -> [Element]
Added UnsafeBufferPointerIterator.sorted(by: (Element, Element) -> Bool) -> [Element]
Added UnsafeBufferPointerIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>]
Added UnsafeBufferPointerIterator.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added UnsafeBufferPointerIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added UnsafeBufferPointerIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeBufferPointerIterator.suffix(_: Int) -> AnySequence<Element>
Added UnsafeBufferPointerIterator.underestimatedCount
Added UnsafeMutableBufferPointer.count
Added UnsafeMutableBufferPointer.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeMutableBufferPointer.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeMutableBufferPointer.enumerated() -> EnumeratedSequence<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added UnsafeMutableBufferPointer.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added UnsafeMutableBufferPointer.formIndex(_: Int, offsetBy: Int)
Added UnsafeMutableBufferPointer.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added UnsafeMutableBufferPointer.index(of: Element) -> Int?
Added UnsafeMutableBufferPointer.index(where: (Element) throws -> Bool) rethrows -> Int?
Added UnsafeMutableBufferPointer.joined() -> FlattenBidirectionalCollection<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.joined() -> FlattenCollection<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.joined() -> FlattenSequence<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.joined(separator: String) -> String
Added UnsafeMutableBufferPointer.lazy
Added UnsafeMutableBufferPointer.lazy
Added UnsafeMutableBufferPointer.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added UnsafeMutableBufferPointer.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeMutableBufferPointer.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added UnsafeMutableBufferPointer.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added UnsafeMutableBufferPointer.partition(by: (Element) throws -> Bool) rethrows -> Int
Added UnsafeMutableBufferPointer.partition(by: (Element) throws -> Bool) rethrows -> Int
Added UnsafeMutableBufferPointer.sorted() -> [Element]
Added UnsafeMutableBufferPointer.sorted() -> [Element]
Added UnsafeMutableBufferPointer.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>]
Added UnsafeMutableBufferPointer.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added UnsafeMutableBufferPointer.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added UnsafeMutableBufferPointer.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added UnsafeMutableBufferPointer.subscript(_: CountableRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: ClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: CountableRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: ClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: Range<Int>) -> MutableSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.subscript(_: Range<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>
Added UnsafeMutableBufferPointer.underestimatedCount
Added UnsafeMutableBufferPointer.underestimatedCount
Added UnsafeMutablePointer.initialize<C : Collection where C.Iterator.Element == Pointee>(from: C)
Added UnsafeMutableRawPointer.allocate(bytes: Int, alignedTo: Int) -> UnsafeMutableRawPointer [static]
Added UnsafeMutableRawPointer.initializeMemory<C : Collection>(as: C.Iterator.Element.Type, from: C) -> UnsafeMutablePointer<C.Iterator.Element>
Added UnsafePointer.pointee
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 : IteratorProtocol where I.Element == CodeUnit>(_: I) -> UnicodeDecodingResult
Added UTF16.encode(_: UnicodeScalar, into: (UTF16.CodeUnit) -> Swift.Void) [static]
Added UTF16.transcodedLength<Input, Encoding where Input : IteratorProtocol, Encoding : UnicodeCodec, Encoding.CodeUnit == Input.Element>(of: Input, decodedAs: Encoding.Type, repairingIllFormedSequences: Bool) -> (count: Int, isASCII: Bool)? [static]
Added UTF32.decode<I : IteratorProtocol where I.Element == CodeUnit>(_: I) -> UnicodeDecodingResult
Added UTF32.encode(_: UnicodeScalar, into: (UTF32.CodeUnit) -> Swift.Void) [static]
Added UTF8.decode<I : IteratorProtocol where I.Element == CodeUnit>(_: I) -> UnicodeDecodingResult
Added UTF8.encode(_: UnicodeScalar, into: (UTF8.CodeUnit) -> Swift.Void) [static]
Added Zip2Iterator [struct]
Added Zip2Iterator.next() -> (Iterator1.Element, Iterator2.Element)?
Added Zip2Sequence.contains(where: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> Bool
Added Zip2Sequence.dropFirst() -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>
Added Zip2Sequence.dropLast() -> 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.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.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.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 !(_: Bool) -> Bool
Added !=(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added !=(_: T, _: T) -> Bool
Added !=(_: T, _: T) -> Bool
Added !=(_: T, _: T) -> Bool
Added %(_: T, _: T) -> T
Added %=(_: T, _: T)
Added &*(_: T, _: T) -> T
Added &+(_: T, _: T) -> T
Added &-(_: T, _: T) -> T
Added &=(_: T, _: T)
Added *(_: T, _: T) -> T
Added *(_: T, _: T) -> T
Added *=(_: T, _: T)
Added *=(_: T, _: T)
Added +(_: T) -> T
Added +(_: T) -> T
Added +(_: T._DisallowMixedSignArithmetic, _: T) -> T
Added +(_: S, _: C) -> C
Added +(_: C, _: S) -> C
Added +(_: T, _: T._DisallowMixedSignArithmetic) -> T
Added +(_: T, _: T) -> T
Added +(_: RRC1, _: RRC2) -> RRC1
Added +(_: T, _: T) -> T
Added +=(_: T, _: T)
Added +=(_: _ContiguousArrayBuffer<Element>, _: C)
Added +=(_: T, _: T._DisallowMixedSignArithmetic)
Added +=(_: T, _: T)
Added +=(_: [C.Iterator.Element], _: C)
Added +=(_: ArraySlice<S.Iterator.Element>, _: S)
Added +=(_: [S.Iterator.Element], _: S)
Added +=(_: ContiguousArray<C.Iterator.Element>, _: C)
Added +=(_: ArraySlice<C.Iterator.Element>, _: C)
Added +=(_: ContiguousArray<S.Iterator.Element>, _: S)
Added +=(_: String, _: String)
Added -(_: T) -> T
Added -(_: T) -> T
Added -(_: T, _: T) -> T
Added -(_: T, _: T) -> T
Added -=(_: T, _: T)
Added -=(_: T, _: T._DisallowMixedSignArithmetic)
Added -=(_: T, _: T)
Added ...(_: Bound, _: Bound) -> CountableClosedRange<Bound>
Added ...(_: Bound, _: Bound) -> ClosedRange<Bound>
Added ..<(_: Bound, _: Bound) -> CountableRange<Bound>
Added ..<(_: Bound, _: Bound) -> Range<Bound>
Added /(_: T, _: T) -> T
Added /(_: T, _: T) -> T
Added /=(_: T, _: T)
Added /=(_: T, _: T)
Added <(_: FlattenCollectionIndex<BaseElements>, _: FlattenCollectionIndex<BaseElements>) -> Bool
Added <(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool
Added <(_: UnsafeRawPointer, _: UnsafeRawPointer) -> Bool
Added <(_: String.UTF8View.Index, _: String.UTF8View.Index) -> Bool
Added <(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool
Added <(_: UnicodeScalar, _: UnicodeScalar) -> Bool
Added <(_: ClosedRangeIndex<Bound>, _: ClosedRangeIndex<Bound>) -> Bool
Added <(_: String.Index, _: String.Index) -> Bool
Added <(_: T, _: T) -> Bool
Added <(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added <(_: T, _: T) -> Bool
Added <(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool
Added <(_: ReversedRandomAccessIndex<Base>, _: ReversedRandomAccessIndex<Base>) -> Bool
Added <(_: FlattenBidirectionalCollectionIndex<BaseElements>, _: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool
Added <(_: ReversedIndex<Base>, _: ReversedIndex<Base>) -> Bool
Added <(_: UnsafeMutableRawPointer, _: UnsafeMutableRawPointer) -> Bool
Added <(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool
Added <(_: T, _: T) -> Bool
Added <=(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added <=(_: T, _: T) -> Bool
Added <=(_: T, _: T) -> Bool
Added <=(_: T, _: T) -> Bool
Added ==(_: ReversedRandomAccessIndex<Base>, _: ReversedRandomAccessIndex<Base>) -> Bool
Added ==(_: DictionaryIndex<Key, Value>, _: DictionaryIndex<Key, Value>) -> Bool
Added ==(_: CountableClosedRange<Bound>, _: CountableClosedRange<Bound>) -> Bool
Added ==(_: UnicodeScalar, _: UnicodeScalar) -> Bool
Added ==(_: T, _: T) -> Bool
Added ==(_: ManagedBufferPointer<Header, Element>, _: ManagedBufferPointer<Header, Element>) -> Bool
Added ==(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added ==(_: SetIndex<Element>, _: SetIndex<Element>) -> Bool
Added ==(_: ClosedRangeIndex<Bound>, _: ClosedRangeIndex<Bound>) -> Bool
Added ==(_: String.UnicodeScalarView.Index, _: String.UnicodeScalarView.Index) -> Bool
Added ==(_: UnsafeRawPointer, _: UnsafeRawPointer) -> Bool
Added ==(_: ReversedIndex<Base>, _: ReversedIndex<Base>) -> Bool
Added ==(_: String.Index, _: String.Index) -> Bool
Added ==(_: UnsafeMutableRawPointer, _: UnsafeMutableRawPointer) -> Bool
Added ==(_: FlattenBidirectionalCollectionIndex<BaseElements>, _: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool
Added ==(_: String.UTF8View.Index, _: String.UTF8View.Index) -> Bool
Added ==(_: T, _: T) -> Bool
Added ==(_: FlattenCollectionIndex<BaseElements>, _: FlattenCollectionIndex<BaseElements>) -> Bool
Added ==(_: T, _: T) -> Bool
Added ==(_: CountableRange<Bound>, _: CountableRange<Bound>) -> Bool
Added ==(_: String.UTF16View.Index, _: String.UTF16View.Index) -> Bool
Added >(_: T, _: T) -> Bool
Added >(_: T, _: T) -> Bool
Added >(_: T, _: T) -> Bool
Added >(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added >=(_: LazyFilterIndex<Base>, _: LazyFilterIndex<Base>) -> Bool
Added >=(_: T, _: T) -> Bool
Added >=(_: T, _: T) -> Bool
Added >=(_: T, _: T) -> Bool
Added ^=(_: T, _: T)
Added abs<T : SignedNumber>(_: T) -> T
Added AnyBidirectionalCollection.IndexDistance
Added AnyCollection.Index
Added AnyCollection.IndexDistance
Added AnyRandomAccessCollection.IndexDistance
Added Array.Index
Added Array.Indices
Added Array.Iterator
Added ArrayLiteralConvertible
Added ArraySlice.Index
Added ArraySlice.Indices
Added ArraySlice.Iterator
Added BidirectionalSlice.Index
Added BidirectionalSlice.IndexDistance
Added BidirectionalSlice.SubSequence
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 DefaultRandomAccessIndices.Index
Added DefaultRandomAccessIndices.Indices
Added DefaultRandomAccessIndices.SubSequence
Added Double.Exponent
Added Double.RawSignificand
Added EmptyCollection.IndexDistance
Added EmptyCollection.Indices
Added ExpressibleByArrayLiteral.Element
Added FlattenBidirectionalCollection.IndexDistance
Added FlattenCollection.IndexDistance
Added Float.Exponent
Added Float.RawSignificand
Added FloatingPoint.Exponent
Added FloatLiteralConvertible
Added Indexable.IndexDistance
Added IndexableBase.Index
Added IndexableBase.SubSequence
Added IteratorProtocol.Element
Added LazyBidirectionalCollection.Elements
Added LazyBidirectionalCollection.Index
Added LazyFilterBidirectionalCollection.Index
Added LazyFilterBidirectionalCollection.IndexDistance
Added LazyFilterCollection.IndexDistance
Added LazyMapBidirectionalCollection.Index
Added LazyMapBidirectionalCollection.IndexDistance
Added LazyMapBidirectionalCollection.Indices
Added LazyMapCollection.IndexDistance
Added LazyMapRandomAccessCollection.Index
Added LazyMapRandomAccessCollection.IndexDistance
Added LazyMapRandomAccessCollection.Indices
Added LazyRandomAccessCollection.Elements
Added LazyRandomAccessCollection.Index
Added MutableBidirectionalSlice.Index
Added MutableBidirectionalSlice.IndexDistance
Added MutableBidirectionalSlice.SubSequence
Added MutableIndexable.SubSequence
Added MutableRandomAccessSlice.Index
Added MutableRandomAccessSlice.IndexDistance
Added MutableRandomAccessSlice.SubSequence
Added MutableRangeReplaceableBidirectionalSlice.Index
Added MutableRangeReplaceableBidirectionalSlice.IndexDistance
Added MutableRangeReplaceableBidirectionalSlice.SubSequence
Added MutableRangeReplaceableRandomAccessSlice.Index
Added MutableRangeReplaceableRandomAccessSlice.IndexDistance
Added MutableRangeReplaceableRandomAccessSlice.SubSequence
Added MutableRangeReplaceableSlice.Index
Added MutableRangeReplaceableSlice.IndexDistance
Added MutableRangeReplaceableSlice.SubSequence
Added MutableSlice.IndexDistance
Added MutableSlice.SubSequence
Added NilLiteralConvertible
Added numericCast<T : UnsignedInteger, U : UnsignedInteger>(_: T) -> U
Added numericCast<T : _SignedInteger, U : UnsignedInteger>(_: T) -> U
Added numericCast<T : _SignedInteger, U : _SignedInteger>(_: T) -> U
Added numericCast<T : UnsignedInteger, U : _SignedInteger>(_: T) -> U
Added OptionSet.Element
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 Repeated.Index
Added Repeated.Indices
Added ReversedCollection.Index
Added ReversedCollection.IndexDistance
Added ReversedCollection.Iterator
Added ReversedRandomAccessCollection.Index
Added ReversedRandomAccessCollection.IndexDistance
Added ReversedRandomAccessCollection.Iterator
Added Sequence.Iterator
Added Sequence.SubSequence
Added SetAlgebra.Element
Added Slice.IndexDistance
Added Slice.SubSequence
Added Streamable
Added String.CharacterView.IndexDistance
Added String.IndexDistance
Added String.UTF16View.IndexDistance
Added String.UTF16View.Indices.IndexDistance
Added String.UTF8View.IndexDistance
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 UnsafeBufferPointer.IndexDistance
Added UnsafeBufferPointer.Iterator
Added UnsafeMutableBufferPointer.IndexDistance
Added withUnsafePointer<T, Result>(to: T, _: (UnsafePointer<T>) throws -> Result) rethrows -> Result
Added Zip2Iterator.Element
Added Zip2Sequence.Iterator
Added |=(_: T, _: T)
Added ~=(_: CountableClosedRange<Bound>, _: Bound) -> Bool
Added ~=(_: CountableRange<Bound>, _: Bound) -> Bool
Added ~=(_: ClosedRange<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 |
Modified AnyBidirectionalCollection.endIndex
Declaration | |
---|---|
From | var endIndex: AnyBidirectionalIndex { get } |
To | var endIndex: AnyIndex { get } |
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 |
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 | |
---|---|
From | @warn_unused_result func dropFirst(_ n: Int) -> AnySequence<Element> |
To | func dropFirst(_ n: Int) -> AnySequence<Element> |
Declaration | |
---|---|
From | @warn_unused_result func prefix(_ maxLength: Int) -> AnySequence<Element> |
To | func prefix(_ maxLength: Int) -> AnySequence<Element> |
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 |
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 |
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 |
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 | |
---|---|
From | subscript (_ index: Int) -> Element |
To | subscript(_ index: Int) -> Element |
Modified ArraySlice.subscript(_: Range<Int>) -> ArraySlice<Element>
Declaration | |
---|---|
From | subscript (_ subRange: Range<Int>) -> ArraySlice<Element> |
To | subscript(_ bounds: Range<Int>) -> ArraySlice<Element> |
Modified ArraySlice.withUnsafeBufferPointer<R>(_: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
Declaration | |
---|---|
From | func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R |
To | func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R |
Modified ArraySlice.withUnsafeMutableBufferPointer<R>(_: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
Declaration | |
---|---|
From | mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R |
To | mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R |
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 | |
---|---|
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 |
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 |
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 |
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 | @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 |
Modified ContiguousArray.subscript(_: Range<Int>) -> ArraySlice<Element>
Declaration | |
---|---|
From | subscript (_ subRange: Range<Int>) -> ArraySlice<Element> |
To | subscript(_ bounds: Range<Int>) -> ArraySlice<Element> |
Declaration | |
---|---|
From | subscript (_ index: Int) -> Element |
To | subscript(_ index: Int) -> Element |
Modified ContiguousArray.withUnsafeBufferPointer<R>(_: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
Declaration | |
---|---|
From | func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R |
To | func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R |
Modified ContiguousArray.withUnsafeMutableBufferPointer<R>(_: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
Declaration | |
---|---|
From | mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R |
To | mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R |
Modified CustomPlaygroundQuickLookable
Declaration | |
---|---|
From | protocol CustomPlaygroundQuickLookable { @warn_unused_result func customPlaygroundQuickLook() -> PlaygroundQuickLook } |
To | 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 } } |
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 |
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 |
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 |
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 |
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 |
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 } |
Declaration | |
---|---|
From | subscript (_ position: Index) -> Element { get } |
To | subscript(_ position: EmptyCollection.Index) -> Element |
Modified Equatable
Declaration | |
---|---|
From | protocol Equatable { @warn_unused_result func ==(_ lhs: Self, _ rhs: Self) -> Bool } |
To | protocol Equatable { static func ==(_ lhs: Self, _ rhs: Self) -> Bool } |
Declaration | |
---|---|
From | @warn_unused_result func ==(_ lhs: Self, _ rhs: Self) -> Bool |
To | static func ==(_ lhs: Self, _ rhs: Self) -> Bool |
Modified FlattenBidirectionalCollection [struct]
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 |
To | struct FlattenBidirectionalCollection<Base where Base : BidirectionalCollection, Base.Iterator.Element : BidirectionalCollection> : BidirectionalCollection { typealias Index = FlattenBidirectionalCollectionIndex<Base> typealias IndexDistance = Base.IndexDistance init(_ base: Base) func makeIterator() -> FlattenIterator<Base.Iterator> var startIndex: FlattenBidirectionalCollectionIndex<Base> { get } var endIndex: FlattenBidirectionalCollectionIndex<Base> { get } func index(after i: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base> func index(before i: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base> subscript(_ position: FlattenBidirectionalCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element { get } subscript(_ bounds: Range<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> { get } var underestimatedCount: Int { get } func forEach(_ body: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows func underestimateCount() -> Int func dropLast(_ n: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> func suffix(_ maxLength: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> func map<T>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> func prefix(_ maxLength: Int) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> func prefix(upTo end: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> func suffix(from start: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> func prefix(through position: FlattenBidirectionalCollectionIndex<Base>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>] typealias Generator = FlattenIterator<Base.Iterator> func generate() -> FlattenIterator<Base.Iterator> func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>] var last: Base.Iterator.Element.Iterator.Element? { get } func index(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenBidirectionalCollectionIndex<Base>? func sorted(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element] subscript(_ bounds: ClosedRange<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> { get } func sort(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element] func indexOf(_ predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenBidirectionalCollectionIndex<Base>? var indices: DefaultBidirectionalIndices<FlattenBidirectionalCollection<Base>> { get } var lazy: LazySequence<FlattenBidirectionalCollection<Base>> { get } func reversed() -> ReversedCollection<FlattenBidirectionalCollection<Base>> func reverse() -> ReversedCollection<FlattenBidirectionalCollection<Base>> func map<T>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element] var underestimatedCount: Int { get } func first(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func dropFirst() -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> func dropLast() -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>] func enumerated() -> EnumeratedSequence<FlattenBidirectionalCollection<Base>> @warn_unqualified_access func min(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<FlattenBidirectionalCollection<Base>> func minElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func maxElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result } extension FlattenBidirectionalCollection { subscript(_ bounds: Range<FlattenBidirectionalCollectionIndex<Base>>) -> BidirectionalSlice<FlattenBidirectionalCollection<Base>> { get } } extension FlattenBidirectionalCollection { func formIndex(after i: inout FlattenBidirectionalCollectionIndex<Base>) func formIndex(_ i: inout FlattenBidirectionalCollectionIndex<Base>, offsetBy n: Base.IndexDistance) func formIndex(_ i: inout FlattenBidirectionalCollectionIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: FlattenBidirectionalCollectionIndex<Base>) -> Bool } extension FlattenBidirectionalCollection { var lazy: LazyBidirectionalCollection<FlattenBidirectionalCollection<Base>> { get } } extension FlattenBidirectionalCollection { var isEmpty: Bool { get } var first: Base.Iterator.Element.Iterator.Element? { get } var underestimatedCount: Int { get } var count: Base.IndexDistance { get } } extension FlattenBidirectionalCollection { var lazy: LazyCollection<FlattenBidirectionalCollection<Base>> { get } } extension FlattenBidirectionalCollection { func formIndex(before i: inout FlattenBidirectionalCollectionIndex<Base>) func index(_ i: FlattenBidirectionalCollectionIndex<Base>, offsetBy n: Base.IndexDistance) -> FlattenBidirectionalCollectionIndex<Base> func index(_ i: FlattenBidirectionalCollectionIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>? func distance(from start: FlattenBidirectionalCollectionIndex<Base>, to end: FlattenBidirectionalCollectionIndex<Base>) -> Base.IndexDistance } extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element : Equatable { func split(separator separator: Base.Iterator.Element.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>] func split(_ separator: Base.Iterator.Element.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>] func index(of element: Base.Iterator.Element.Iterator.Element) -> FlattenBidirectionalCollectionIndex<Base>? func split(separator separator: Base.Iterator.Element.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>] func split(_ separator: Base.Iterator.Element.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool } extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element : Comparable { func sorted() -> [Base.Iterator.Element.Iterator.Element] func sort() -> [Base.Iterator.Element.Iterator.Element] @warn_unqualified_access func min() -> Base.Iterator.Element.Iterator.Element? @warn_unqualified_access func max() -> Base.Iterator.Element.Iterator.Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool func minElement() -> Base.Iterator.Element.Iterator.Element? func maxElement() -> Base.Iterator.Element.Iterator.Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool } extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element : Sequence { func joined() -> FlattenSequence<FlattenBidirectionalCollection<Base>> func flatten() -> FlattenSequence<FlattenBidirectionalCollection<Base>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<FlattenBidirectionalCollection<Base>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<FlattenBidirectionalCollection<Base>> } extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element : BidirectionalCollection { func joined() -> FlattenBidirectionalCollection<FlattenBidirectionalCollection<Base>> func flatten() -> FlattenBidirectionalCollection<FlattenBidirectionalCollection<Base>> } extension FlattenBidirectionalCollection where Base.Iterator.Element.Iterator.Element : Collection { func joined() -> FlattenCollection<FlattenBidirectionalCollection<Base>> func flatten() -> FlattenCollection<FlattenBidirectionalCollection<Base>> } | BidirectionalCollection | Base : BidirectionalCollection, Base.Iterator.Element : BidirectionalCollection |
Modified FlattenBidirectionalCollectionIndex [struct]
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 |
To | struct FlattenBidirectionalCollectionIndex<BaseElements where BaseElements : BidirectionalCollection, BaseElements.Iterator.Element : BidirectionalCollection> { } extension FlattenBidirectionalCollectionIndex : Comparable { static func ==(_ lhs: FlattenBidirectionalCollectionIndex<BaseElements>, _ rhs: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool static func <(_ lhs: FlattenBidirectionalCollectionIndex<BaseElements>, _ rhs: FlattenBidirectionalCollectionIndex<BaseElements>) -> Bool } | Comparable | BaseElements : BidirectionalCollection, BaseElements.Iterator.Element : BidirectionalCollection |
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 |
To | struct FlattenCollection<Base where Base : Collection, Base.Iterator.Element : Collection> : Collection { typealias Index = FlattenCollectionIndex<Base> typealias IndexDistance = Base.IndexDistance init(_ base: Base) func makeIterator() -> FlattenIterator<Base.Iterator> var startIndex: FlattenCollectionIndex<Base> { get } var endIndex: FlattenCollectionIndex<Base> { get } func index(after i: FlattenCollectionIndex<Base>) -> FlattenCollectionIndex<Base> subscript(_ position: FlattenCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element { get } subscript(_ bounds: Range<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>> { get } var underestimatedCount: Int { get } func forEach(_ body: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows func underestimateCount() -> Int func map<T>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> Slice<FlattenCollection<Base>> func dropLast(_ n: Int) -> Slice<FlattenCollection<Base>> func prefix(_ maxLength: Int) -> Slice<FlattenCollection<Base>> func suffix(_ maxLength: Int) -> Slice<FlattenCollection<Base>> func prefix(upTo end: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>> func suffix(from start: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>> func prefix(through position: FlattenCollectionIndex<Base>) -> Slice<FlattenCollection<Base>> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Slice<FlattenCollection<Base>>] typealias Generator = FlattenIterator<Base.Iterator> func generate() -> FlattenIterator<Base.Iterator> func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Slice<FlattenCollection<Base>>] func index(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenCollectionIndex<Base>? func sorted(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element] subscript(_ bounds: ClosedRange<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>> { get } func sort(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element] func indexOf(_ predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> FlattenCollectionIndex<Base>? var indices: DefaultIndices<FlattenCollection<Base>> { get } var lazy: LazySequence<FlattenCollection<Base>> { get } func map<T>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element] var underestimatedCount: Int { get } func first(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func dropFirst() -> Slice<FlattenCollection<Base>> func dropLast() -> Slice<FlattenCollection<Base>> func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Slice<FlattenCollection<Base>>] func enumerated() -> EnumeratedSequence<FlattenCollection<Base>> @warn_unqualified_access func min(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result func reversed() -> [Base.Iterator.Element.Iterator.Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<FlattenCollection<Base>> func minElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func maxElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func reverse() -> [Base.Iterator.Element.Iterator.Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result } extension FlattenCollection { subscript(_ bounds: Range<FlattenCollectionIndex<Base>>) -> Slice<FlattenCollection<Base>> { get } } extension FlattenCollection { var isEmpty: Bool { get } var first: Base.Iterator.Element.Iterator.Element? { get } var underestimatedCount: Int { get } var count: Base.IndexDistance { get } } extension FlattenCollection { func formIndex(after i: inout FlattenCollectionIndex<Base>) func index(_ i: FlattenCollectionIndex<Base>, offsetBy n: Base.IndexDistance) -> FlattenCollectionIndex<Base> func index(_ i: FlattenCollectionIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: FlattenCollectionIndex<Base>) -> FlattenCollectionIndex<Base>? func formIndex(_ i: inout FlattenCollectionIndex<Base>, offsetBy n: Base.IndexDistance) func formIndex(_ i: inout FlattenCollectionIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: FlattenCollectionIndex<Base>) -> Bool func distance(from start: FlattenCollectionIndex<Base>, to end: FlattenCollectionIndex<Base>) -> Base.IndexDistance } extension FlattenCollection { var lazy: LazyCollection<FlattenCollection<Base>> { get } } extension FlattenCollection where Base.Iterator.Element.Iterator.Element : Collection { func joined() -> FlattenCollection<FlattenCollection<Base>> func flatten() -> FlattenCollection<FlattenCollection<Base>> } extension FlattenCollection where Base.Iterator.Element.Iterator.Element : Comparable { func sorted() -> [Base.Iterator.Element.Iterator.Element] func sort() -> [Base.Iterator.Element.Iterator.Element] @warn_unqualified_access func min() -> Base.Iterator.Element.Iterator.Element? @warn_unqualified_access func max() -> Base.Iterator.Element.Iterator.Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool func minElement() -> Base.Iterator.Element.Iterator.Element? func maxElement() -> Base.Iterator.Element.Iterator.Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool } extension FlattenCollection where Base.Iterator.Element.Iterator.Element : Sequence { func joined() -> FlattenSequence<FlattenCollection<Base>> func flatten() -> FlattenSequence<FlattenCollection<Base>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<FlattenCollection<Base>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<FlattenCollection<Base>> } extension FlattenCollection where Base.Iterator.Element.Iterator.Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } extension FlattenCollection where Base.Iterator.Element.Iterator.Element : Equatable { func split(separator separator: Base.Iterator.Element.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [Slice<FlattenCollection<Base>>] func split(_ separator: Base.Iterator.Element.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [Slice<FlattenCollection<Base>>] func index(of element: Base.Iterator.Element.Iterator.Element) -> FlattenCollectionIndex<Base>? func split(separator separator: Base.Iterator.Element.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>] func split(_ separator: Base.Iterator.Element.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool } | Collection | Base : Collection, Base.Iterator.Element : Collection |
Modified FlattenCollectionIndex [struct]
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 |
To | struct FlattenCollectionIndex<BaseElements where BaseElements : Collection, BaseElements.Iterator.Element : Collection> { } extension FlattenCollectionIndex : Comparable { static func ==(_ lhs: FlattenCollectionIndex<BaseElements>, _ rhs: FlattenCollectionIndex<BaseElements>) -> Bool static func <(_ lhs: FlattenCollectionIndex<BaseElements>, _ rhs: FlattenCollectionIndex<BaseElements>) -> Bool } | Comparable | BaseElements : Collection, BaseElements.Iterator.Element : Collection |
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 |
To | struct FlattenSequence<Base : Sequence where Base.Iterator.Element : Sequence> : Sequence { func makeIterator() -> FlattenIterator<Base.Iterator> func generate() -> FlattenIterator<Base.Iterator> func sorted(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element] func sort(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) -> Bool) -> [Base.Iterator.Element.Iterator.Element] var lazy: LazySequence<FlattenSequence<Base>> { get } func map<T>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element] func suffix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element.Iterator.Element>] var underestimatedCount: Int { get } func forEach(_ body: (Base.Iterator.Element.Iterator.Element) throws -> Void) rethrows func first(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func dropFirst(_ n: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element> func dropLast(_ n: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element> func prefix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element.Iterator.Element> func dropFirst() -> AnySequence<Base.Iterator.Element.Iterator.Element> func dropLast() -> AnySequence<Base.Iterator.Element.Iterator.Element> func underestimateCount() -> Int func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element.Iterator.Element>] func enumerated() -> EnumeratedSequence<FlattenSequence<Base>> @warn_unqualified_access func min(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result func reversed() -> [Base.Iterator.Element.Iterator.Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<FlattenSequence<Base>> func minElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func maxElement(_ isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element? func reverse() -> [Base.Iterator.Element.Iterator.Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result } extension FlattenSequence where Base.Iterator.Element.Iterator.Element : Comparable { func sorted() -> [Base.Iterator.Element.Iterator.Element] func sort() -> [Base.Iterator.Element.Iterator.Element] @warn_unqualified_access func min() -> Base.Iterator.Element.Iterator.Element? @warn_unqualified_access func max() -> Base.Iterator.Element.Iterator.Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool func minElement() -> Base.Iterator.Element.Iterator.Element? func maxElement() -> Base.Iterator.Element.Iterator.Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool } extension FlattenSequence where Base.Iterator.Element.Iterator.Element : Sequence { func joined() -> FlattenSequence<FlattenSequence<Base>> func flatten() -> FlattenSequence<FlattenSequence<Base>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<FlattenSequence<Base>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<FlattenSequence<Base>> } extension FlattenSequence where Base.Iterator.Element.Iterator.Element : Equatable { func split(separator separator: Base.Iterator.Element.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>] func split(_ separator: Base.Iterator.Element.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element.Iterator.Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element.Iterator.Element>(_ other: OtherSequence) -> Bool } extension FlattenSequence where Base.Iterator.Element.Iterator.Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } | Sequence | Base : Sequence, Base.Iterator.Element : Sequence |
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 |
To | struct Float { init() init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(_ v: Int64) init(_ v: UInt) init(_ v: Int) init(_ other: Float) init?(exactly other: Float) init(_ other: Double) init?(exactly other: Double) } extension Float { init(_ value: CGFloat) } extension Float { init(_ number: NSNumber) } extension Float : CustomStringConvertible { var description: String { get } } extension Float : CustomDebugStringConvertible { var debugDescription: String { get } } extension Float : BinaryFloatingPoint { typealias Exponent = Int typealias RawSignificand = UInt32 static var exponentBitCount: Int { get } static var significandBitCount: Int { get } var bitPattern: UInt32 { get } init(bitPattern bitPattern: UInt32) var sign: FloatingPointSign { get } var isSignMinus: Bool { get } var exponentBitPattern: UInt { get } var significandBitPattern: UInt32 { get } init(sign sign: FloatingPointSign, exponentBitPattern exponentBitPattern: UInt, significandBitPattern significandBitPattern: UInt32) var isCanonical: Bool { get } static var infinity: Float { get } static var nan: Float { get } static var signalingNaN: Float { get } static var quietNaN: Float { get } static var greatestFiniteMagnitude: Float { get } static var pi: Float { get } var ulp: Float { get } static var leastNormalMagnitude: Float { get } static var leastNonzeroMagnitude: Float { get } var exponent: Int { get } var significand: Float { get } init(sign sign: FloatingPointSign, exponent exponent: Int, significand significand: Float) init(nan payload: Float.RawSignificand, signaling signaling: Bool) var nextUp: Float { get } mutating func round(_ rule: FloatingPointRoundingRule) mutating func negate() mutating func add(_ other: Float) mutating func subtract(_ other: Float) mutating func multiply(by other: Float) mutating func divide(by other: Float) mutating func formRemainder(dividingBy other: Float) mutating func formTruncatingRemainder(dividingBy other: Float) mutating func formSquareRoot() mutating func addProduct(_ lhs: Float, _ rhs: Float) func isEqual(to other: Float) -> Bool func isLess(than other: Float) -> Bool func isLessThanOrEqualTo(_ other: Float) -> Bool var isNormal: Bool { get } var isFinite: Bool { get } var isZero: Bool { get } var isSubnormal: Bool { get } var isInfinite: Bool { get } var isNaN: Bool { get } var isSignalingNaN: Bool { get } var binade: Float { get } var significandWidth: Int { get } init(floatLiteral value: Float) } extension Float : ExpressibleByIntegerLiteral { init(integerLiteral value: Int64) } extension Float : LosslessStringConvertible { init?(_ text: String) } extension Float : Hashable { var hashValue: Int { get } } extension Float : AbsoluteValuable { static func abs(_ x: Float) -> Float } extension Float : Strideable { func distance(to other: Float) -> Float func advanced(by amount: Float) -> Float } extension Float : CustomReflectable { var customMirror: Mirror { get } } extension Float : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } | AbsoluteValuable, BinaryFloatingPoint, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, ExpressibleByIntegerLiteral, Hashable, LosslessStringConvertible, Strideable |
Modified Float.abs(_: Float) -> Float [static]
Declaration | |
---|---|
From | @warn_unused_result static func abs(_ x: Float) -> Float |
To | static func abs(_ x: Float) -> Float |
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 } |
To | enum FloatingPointClassification { case signalingNaN case quietNaN case negativeInfinity case negativeNormal case negativeSubnormal case negativeZero case positiveZero case positiveSubnormal case positiveNormal case positiveInfinity } |
Modified ImplicitlyUnwrappedOptional [enum]
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 |
To | enum ImplicitlyUnwrappedOptional<Wrapped> : ExpressibleByNilLiteral { case none case some(Wrapped) init(_ some: Wrapped) init(nilLiteral nilLiteral: ()) init() func map<U>(_ f: (Wrapped) throws -> U) rethrows -> U! func flatMap<U>(_ f: (Wrapped) throws -> U!) rethrows -> U! } extension ImplicitlyUnwrappedOptional : CustomStringConvertible { var description: String { get } } extension ImplicitlyUnwrappedOptional : CustomDebugStringConvertible { var debugDescription: String { get } } | CustomDebugStringConvertible, CustomStringConvertible, ExpressibleByNilLiteral |
Modified Index.init(_: String.UnicodeScalarIndex, within: String)
Declaration | |
---|---|
From | init?(_ unicodeScalarIndex: UnicodeScalarIndex, within characters: String) |
To | init?(_ unicodeScalarIndex: String.UnicodeScalarIndex, within other: String) |
Modified Index.init(_: String.UTF16Index, within: String)
Declaration | |
---|---|
From | init?(_ utf16Index: UTF16Index, within characters: String) |
To | init?(_ utf16Index: String.UTF16Index, within other: String) |
Modified Index.init(_: String.UTF8Index, within: String)
Declaration | |
---|---|
From | init?(_ utf8Index: UTF8Index, within characters: String) |
To | init?(_ utf8Index: String.UTF8Index, within other: String) |
Modified Indexable
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 } } | -- | -- |
To | protocol Indexable : IndexableBase { associatedtype IndexDistance : SignedInteger = Int func index(_ i: Self.Index, offsetBy n: Self.IndexDistance) -> Self.Index func index(_ i: Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Self.Index? func formIndex(_ i: inout Self.Index, offsetBy n: Self.IndexDistance) func formIndex(_ i: inout Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Bool func distance(from start: Self.Index, to end: Self.Index) -> Self.IndexDistance } | IndexableBase | iOS 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 |
To | struct Int : SignedInteger, Comparable, Equatable { init() init(bigEndian value: Int) init(littleEndian value: Int) init(integerLiteral value: Int) var bigEndian: Int { get } var littleEndian: Int { get } var byteSwapped: Int { get } static var max: Int { get } static var min: Int { get } init(bitPattern pointer: OpaquePointer?) static func addWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func subtractWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func divideWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func remainderWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) func toIntMax() -> IntMax init(_ value: UInt8) init?(exactly value: UInt8) init(_ value: Int8) init?(exactly value: Int8) init(_ value: UInt16) init?(exactly value: UInt16) init(_ value: Int16) init?(exactly value: Int16) init(_ value: UInt32) init?(exactly value: UInt32) init(_ value: Int32) init?(exactly value: Int32) init(_ value: UInt64) init?(exactly value: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ value: Int64) init?(exactly value: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ value: UInt) init?(exactly value: UInt) init(_ value: Int) init?(exactly value: Int) init(bitPattern bitPattern: UInt) init(_ other: Float) init(_ other: Double) init?(_ text: String, radix radix: Int = default) init(bitPattern objectID: ObjectIdentifier) init(_ objectID: ObjectIdentifier) init<U>(bitPattern bitPattern: UnsafeMutablePointer<U>?) init<U>(bitPattern bitPattern: UnsafePointer<U>?) init(bitPattern bitPattern: UnsafeMutableRawPointer?) init(bitPattern bitPattern: UnsafeRawPointer?) func distance(to other: Int) -> Int func advanced(by n: Int) -> Int } extension Int { init(_ value: CGFloat) } extension Int { init(_ number: NSNumber) } extension Int : Hashable { var hashValue: Int { get } } extension Int : CustomStringConvertible { var description: String { get } } extension Int : BitwiseOperations { static var allZeros: Int { get } } extension Int : CustomReflectable { var customMirror: Mirror { get } } extension Int : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension Int : CVarArg { } | BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, SignedInteger |
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 |
To | struct Int16 : SignedInteger, Comparable, Equatable { init() init(bigEndian value: Int16) init(littleEndian value: Int16) init(integerLiteral value: Int16) var bigEndian: Int16 { get } var littleEndian: Int16 { get } var byteSwapped: Int16 { get } static var max: Int16 { get } static var min: Int16 { get } static func addWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func subtractWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func divideWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func remainderWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) func toIntMax() -> IntMax init(_ value: UInt8) init?(exactly value: UInt8) init(_ value: Int8) init?(exactly value: Int8) init(_ value: UInt16) init?(exactly value: UInt16) init(_ value: Int16) init?(exactly value: Int16) init(_ value: UInt32) init?(exactly value: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ value: Int32) init?(exactly value: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ value: UInt64) init?(exactly value: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ value: Int64) init?(exactly value: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ value: UInt) init?(exactly value: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ value: Int) init?(exactly value: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: UInt16) init(_ other: Float) init(_ other: Double) init?(_ text: String, radix radix: Int = default) func distance(to other: Int16) -> Int func advanced(by n: Int) -> Int16 } extension Int16 { init(_ value: CGFloat) } extension Int16 : Hashable { var hashValue: Int { get } } extension Int16 : CustomStringConvertible { var description: String { get } } extension Int16 : BitwiseOperations { static var allZeros: Int16 { get } } extension Int16 : CustomReflectable { var customMirror: Mirror { get } } extension Int16 : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension Int16 : CVarArg { } | BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, SignedInteger |
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 |
To | struct Int32 : SignedInteger, Comparable, Equatable { init() init(bigEndian value: Int32) init(littleEndian value: Int32) init(integerLiteral value: Int32) var bigEndian: Int32 { get } var littleEndian: Int32 { get } var byteSwapped: Int32 { get } static var max: Int32 { get } static var min: Int32 { get } static func addWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func subtractWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func divideWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func remainderWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) func toIntMax() -> IntMax init(_ value: UInt8) init?(exactly value: UInt8) init(_ value: Int8) init?(exactly value: Int8) init(_ value: UInt16) init?(exactly value: UInt16) init(_ value: Int16) init?(exactly value: Int16) init(_ value: UInt32) init?(exactly value: UInt32) init(_ value: Int32) init?(exactly value: Int32) init(_ value: UInt64) init?(exactly value: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ value: Int64) init?(exactly value: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ value: UInt) init?(exactly value: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ value: Int) init?(exactly value: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: UInt32) init(_ other: Float) init(_ other: Double) init?(_ text: String, radix radix: Int = default) func distance(to other: Int32) -> Int func advanced(by n: Int) -> Int32 } extension Int32 { init(_ value: CGFloat) } extension Int32 : Hashable { var hashValue: Int { get } } extension Int32 : CustomStringConvertible { var description: String { get } } extension Int32 : BitwiseOperations { static var allZeros: Int32 { get } } extension Int32 : CustomReflectable { var customMirror: Mirror { get } } extension Int32 : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension Int32 : CVarArg { } | BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, SignedInteger |
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 |
To | struct Int64 : SignedInteger, Comparable, Equatable { init() init(bigEndian value: Int64) init(littleEndian value: Int64) init(integerLiteral value: Int64) var bigEndian: Int64 { get } var littleEndian: Int64 { get } var byteSwapped: Int64 { get } static var max: Int64 { get } static var min: Int64 { get } static func addWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func subtractWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func divideWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func remainderWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) func toIntMax() -> IntMax init(_ value: UInt8) init?(exactly value: UInt8) init(_ value: Int8) init?(exactly value: Int8) init(_ value: UInt16) init?(exactly value: UInt16) init(_ value: Int16) init?(exactly value: Int16) init(_ value: UInt32) init?(exactly value: UInt32) init(_ value: Int32) init?(exactly value: Int32) init(_ value: UInt64) init?(exactly value: UInt64) init(_ value: Int64) init?(exactly value: Int64) init(_ value: UInt) init?(exactly value: UInt) init(_ value: Int) init?(exactly value: Int) init(bitPattern bitPattern: UInt64) init(_ other: Float) init(_ other: Double) init?(_ text: String, radix radix: Int = default) func distance(to other: Int64) -> Int func advanced(by n: Int) -> Int64 } extension Int64 { init(_ value: CGFloat) } extension Int64 : Hashable { var hashValue: Int { get } } extension Int64 : CustomStringConvertible { var description: String { get } } extension Int64 : BitwiseOperations { static var allZeros: Int64 { get } } extension Int64 : CustomReflectable { var customMirror: Mirror { get } } extension Int64 : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension Int64 : CVarArg { } | BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, SignedInteger |
Modified Int8 [struct]
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 |
To | struct Int8 : SignedInteger, Comparable, Equatable { init() init(integerLiteral value: Int8) static var max: Int8 { get } static var min: Int8 { get } static func addWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func subtractWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func divideWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func remainderWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) func toIntMax() -> IntMax init(_ value: UInt8) init?(exactly value: UInt8) init(_ value: Int8) init?(exactly value: Int8) init(_ value: UInt16) init?(exactly value: UInt16) init(truncatingBitPattern truncatingBitPattern: UInt16) init(_ value: Int16) init?(exactly value: Int16) init(truncatingBitPattern truncatingBitPattern: Int16) init(_ value: UInt32) init?(exactly value: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ value: Int32) init?(exactly value: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ value: UInt64) init?(exactly value: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ value: Int64) init?(exactly value: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ value: UInt) init?(exactly value: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ value: Int) init?(exactly value: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: UInt8) init(_ other: Float) init(_ other: Double) init?(_ text: String, radix radix: Int = default) func distance(to other: Int8) -> Int func advanced(by n: Int) -> Int8 } extension Int8 { init(_ value: CGFloat) } extension Int8 : Hashable { var hashValue: Int { get } } extension Int8 : CustomStringConvertible { var description: String { get } } extension Int8 : BitwiseOperations { static var allZeros: Int8 { get } } extension Int8 : CustomReflectable { var customMirror: Mirror { get } } extension Int8 : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension Int8 : CVarArg { } | BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, SignedInteger |
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 |
To | struct LazyCollection<Base : Collection> : LazyCollectionProtocol { typealias Elements = Base var elements: Base { get } typealias Index = Base.Index func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> LazyCollection<Slice<Base>> func dropLast(_ n: Int) -> LazyCollection<Slice<Base>> func prefix(_ maxLength: Int) -> LazyCollection<Slice<Base>> func suffix(_ maxLength: Int) -> LazyCollection<Slice<Base>> func prefix(upTo end: Base.Index) -> LazyCollection<Slice<Base>> func suffix(from start: Base.Index) -> LazyCollection<Slice<Base>> func prefix(through position: Base.Index) -> LazyCollection<Slice<Base>> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyCollection<Slice<Base>>] typealias Generator = Base.Iterator func generate() -> Base.Iterator func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyCollection<Slice<Base>>] func index(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Index? func sorted(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element] subscript(_ bounds: ClosedRange<Base.Index>) -> LazyCollection<Slice<Base>> { get } func sort(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element] func indexOf(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Index? func filter(_ isIncluded: @escaping (Base.Iterator.Element) -> Bool) -> LazyFilterCollection<Base> func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>> func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult> func flatMap<SegmentOfResult : Collection>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<Base, SegmentOfResult>>> func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<Base, ElementOfResult?>>, ElementOfResult> var lazy: LazyCollection<Base> { get } var lazy: LazySequence<LazyCollection<Base>> { get } var array: [Base.Iterator.Element] { get } func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U> func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapCollection<Base, U> func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T] var underestimatedCount: Int { get } func forEach(_ body: (Base.Iterator.Element) throws -> Void) rethrows func first(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func dropFirst() -> LazyCollection<Slice<Base>> func dropLast() -> LazyCollection<Slice<Base>> func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [LazyCollection<Slice<Base>>] func enumerated() -> EnumeratedSequence<LazyCollection<Base>> @warn_unqualified_access func min(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result func reversed() -> [Base.Iterator.Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<LazyCollection<Base>> func minElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func maxElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func reverse() -> [Base.Iterator.Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result } extension LazyCollection { func formIndex(after i: inout Base.Index) func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance) func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Bool } extension LazyCollection { var lazy: LazyCollection<LazyCollection<Base>> { get } } extension LazyCollection { var isEmpty: Bool { get } var first: Base.Iterator.Element? { get } var underestimatedCount: Int { get } var count: Base.IndexDistance { get } } extension LazyCollection { var lazy: LazyCollection<Base> { get } } extension LazyCollection : Collection { var startIndex: Base.Index { get } var endIndex: Base.Index { get } var indices: Base.Indices { get } func index(after i: Base.Index) -> Base.Index subscript(_ position: Base.Index) -> Base.Iterator.Element { get } subscript(_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get } var isEmpty: Bool { get } var count: Base.IndexDistance { get } var first: Base.Iterator.Element? { get } func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index? func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance } extension LazyCollection : Sequence { func makeIterator() -> Base.Iterator var underestimatedCount: Int { get } } extension LazyCollection where Base.Iterator.Element : Equatable { func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [LazyCollection<Slice<Base>>] func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [LazyCollection<Slice<Base>>] func index(of element: Base.Iterator.Element) -> Base.Index? func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element>] func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool } extension LazyCollection where Base.Indices == DefaultIndices<Self> { var indices: DefaultIndices<LazyCollection<Base>> { get } } extension LazyCollection where Base == LazyCollection<Base> { var elements: LazyCollection<Base> { get } } extension LazyCollection where LazyCollection<Slice<Base>> == LazyCollection<Base> { mutating func popFirst() -> Base.Iterator.Element? mutating func removeFirst() -> Base.Iterator.Element mutating func removeFirst(_ n: Int) } extension LazyCollection where Base.Iterator.Element : Sequence { func joined() -> FlattenSequence<LazyCollection<Base>> func flatten() -> FlattenSequence<LazyCollection<Base>> func joined() -> LazySequence<FlattenSequence<Base>> func flatten() -> LazySequence<FlattenSequence<Base>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazyCollection<Base>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazyCollection<Base>> } extension LazyCollection where Base.Iterator.Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } extension LazyCollection where Base == LazyCollection<Base> { var elements: LazyCollection<Base> { get } } extension LazyCollection where Base.Iterator.Element : Collection { func joined() -> FlattenCollection<LazyCollection<Base>> func flatten() -> FlattenCollection<LazyCollection<Base>> func joined() -> LazyCollection<FlattenCollection<Base>> func flatten() -> LazyCollection<FlattenCollection<Base>> } extension LazyCollection where Base.Index : Strideable, Index.Stride : SignedInteger { subscript(_ bounds: CountableRange<Base.Index>) -> LazyCollection<Slice<Base>> { get } subscript(_ bounds: CountableClosedRange<Base.Index>) -> LazyCollection<Slice<Base>> { get } } extension LazyCollection where Base.Iterator.Element : Comparable { func sorted() -> [Base.Iterator.Element] func sort() -> [Base.Iterator.Element] @warn_unqualified_access func min() -> Base.Iterator.Element? @warn_unqualified_access func max() -> Base.Iterator.Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool func minElement() -> Base.Iterator.Element? func maxElement() -> Base.Iterator.Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool } | Collection, LazyCollectionProtocol, Sequence | Base : Collection |
Modified LazyCollection.first
Declaration | |
---|---|
From | var first: Base.Generator.Element? { get } |
To | var first: Base.Iterator.Element? { get } |
Declaration | |
---|---|
From | subscript (_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get } |
To | subscript(_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get } |
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 |
To | struct LazyFilterCollection<Base : Collection> : LazyCollectionProtocol, Collection { typealias Index = LazyFilterIndex<Base> typealias IndexDistance = Base.IndexDistance var startIndex: LazyFilterIndex<Base> { get } var endIndex: LazyFilterIndex<Base> { get } func index(after i: LazyFilterIndex<Base>) -> LazyFilterIndex<Base> func formIndex(after i: inout LazyFilterIndex<Base>) subscript(_ position: LazyFilterIndex<Base>) -> Base.Iterator.Element { get } subscript(_ bounds: Range<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>> { get } func makeIterator() -> LazyFilterIterator<Base.Iterator> init(_ base: Base, whereElementsSatisfy predicate: (Base.Iterator.Element) -> Bool) func generate() -> LazyFilterIterator<Base.Iterator> func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> Slice<LazyFilterCollection<Base>> func dropLast(_ n: Int) -> Slice<LazyFilterCollection<Base>> func prefix(_ maxLength: Int) -> Slice<LazyFilterCollection<Base>> func suffix(_ maxLength: Int) -> Slice<LazyFilterCollection<Base>> func prefix(upTo end: LazyFilterIndex<Base>) -> Slice<LazyFilterCollection<Base>> func suffix(from start: LazyFilterIndex<Base>) -> Slice<LazyFilterCollection<Base>> func prefix(through position: LazyFilterIndex<Base>) -> Slice<LazyFilterCollection<Base>> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [Slice<LazyFilterCollection<Base>>] typealias Generator = LazyFilterIterator<Base.Iterator> func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [Slice<LazyFilterCollection<Base>>] func index(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> LazyFilterIndex<Base>? func sorted(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element] subscript(_ bounds: ClosedRange<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>> { get } func sort(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element] func indexOf(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> LazyFilterIndex<Base>? func filter(_ isIncluded: @escaping (Base.Iterator.Element) -> Bool) -> LazyFilterCollection<LazyFilterCollection<Base>> func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyFilterCollection<Base>, SegmentOfResult>>> func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyFilterCollection<Base>, ElementOfResult?>>, ElementOfResult> func flatMap<SegmentOfResult : Collection>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyFilterCollection<Base>, SegmentOfResult>>> func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyFilterCollection<Base>, ElementOfResult?>>, ElementOfResult> var indices: DefaultIndices<LazyFilterCollection<Base>> { get } var lazy: LazyFilterCollection<Base> { get } var lazy: LazySequence<LazyFilterCollection<Base>> { get } var array: [Base.Iterator.Element] { get } func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterCollection<Base>, U> func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapCollection<LazyFilterCollection<Base>, U> func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T] var underestimatedCount: Int { get } func forEach(_ body: (Base.Iterator.Element) throws -> Void) rethrows func first(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func dropFirst() -> Slice<LazyFilterCollection<Base>> func dropLast() -> Slice<LazyFilterCollection<Base>> func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [Slice<LazyFilterCollection<Base>>] func enumerated() -> EnumeratedSequence<LazyFilterCollection<Base>> @warn_unqualified_access func min(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result func reversed() -> [Base.Iterator.Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<LazyFilterCollection<Base>> func minElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func maxElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func reverse() -> [Base.Iterator.Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result } extension LazyFilterCollection { subscript(_ bounds: Range<LazyFilterIndex<Base>>) -> Slice<LazyFilterCollection<Base>> { get } } extension LazyFilterCollection { var isEmpty: Bool { get } var first: Base.Iterator.Element? { get } var underestimatedCount: Int { get } var count: Base.IndexDistance { get } } extension LazyFilterCollection { var elements: LazyFilterCollection<Base> { get } } extension LazyFilterCollection { var elements: LazyFilterCollection<Base> { get } } extension LazyFilterCollection { var lazy: LazyCollection<LazyFilterCollection<Base>> { get } } extension LazyFilterCollection { var lazy: LazyFilterCollection<Base> { get } } extension LazyFilterCollection { func index(_ i: LazyFilterIndex<Base>, offsetBy n: Base.IndexDistance) -> LazyFilterIndex<Base> func index(_ i: LazyFilterIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: LazyFilterIndex<Base>) -> LazyFilterIndex<Base>? func formIndex(_ i: inout LazyFilterIndex<Base>, offsetBy n: Base.IndexDistance) func formIndex(_ i: inout LazyFilterIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: LazyFilterIndex<Base>) -> Bool func distance(from start: LazyFilterIndex<Base>, to end: LazyFilterIndex<Base>) -> Base.IndexDistance } extension LazyFilterCollection where Base.Iterator.Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } extension LazyFilterCollection where Base.Iterator.Element : Sequence { func joined() -> FlattenSequence<LazyFilterCollection<Base>> func flatten() -> FlattenSequence<LazyFilterCollection<Base>> func joined() -> LazySequence<FlattenSequence<LazyFilterCollection<Base>>> func flatten() -> LazySequence<FlattenSequence<LazyFilterCollection<Base>>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazyFilterCollection<Base>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazyFilterCollection<Base>> } extension LazyFilterCollection where Base.Iterator.Element : Collection { func joined() -> FlattenCollection<LazyFilterCollection<Base>> func flatten() -> FlattenCollection<LazyFilterCollection<Base>> func joined() -> LazyCollection<FlattenCollection<LazyFilterCollection<Base>>> func flatten() -> LazyCollection<FlattenCollection<LazyFilterCollection<Base>>> } extension LazyFilterCollection where Base.Iterator.Element : Equatable { func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [Slice<LazyFilterCollection<Base>>] func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [Slice<LazyFilterCollection<Base>>] func index(of element: Base.Iterator.Element) -> LazyFilterIndex<Base>? func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element>] func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool } extension LazyFilterCollection where Base.Iterator.Element : Comparable { func sorted() -> [Base.Iterator.Element] func sort() -> [Base.Iterator.Element] @warn_unqualified_access func min() -> Base.Iterator.Element? @warn_unqualified_access func max() -> Base.Iterator.Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool func minElement() -> Base.Iterator.Element? func maxElement() -> Base.Iterator.Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool } | Collection, LazyCollectionProtocol | Base : Collection |
Modified LazyFilterIndex [struct]
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 |
To | struct LazyFilterIndex<Base : Collection> { let base: Base.Index } extension LazyFilterIndex : Comparable { static func ==(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool static func !=(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool static func <(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool static func <=(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool static func >=(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool static func >(_ lhs: LazyFilterIndex<Base>, _ rhs: LazyFilterIndex<Base>) -> Bool } | Comparable | Base : Collection | Base |
Modified LazyFilterIndex.base
Declaration | |
---|---|
From | let base: BaseElements.Index |
To | let base: Base.Index |
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 |
To | struct LazyFilterSequence<Base : Sequence> : LazySequenceProtocol { func makeIterator() -> LazyFilterIterator<Base.Iterator> let base: Base init(_ base: Base, whereElementsSatisfy predicate: (Base.Iterator.Element) -> Bool) func generate() -> LazyFilterIterator<Base.Iterator> func sorted(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element] func sort(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element] func filter(_ isIncluded: @escaping (Base.Iterator.Element) -> Bool) -> LazyFilterSequence<LazyFilterSequence<Base>> func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyFilterSequence<Base>, SegmentOfResult>>> func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyFilterSequence<Base>, ElementOfResult?>>, ElementOfResult> var lazy: LazySequence<LazyFilterSequence<Base>> { get } var array: [Base.Iterator.Element] { get } func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapSequence<LazyFilterSequence<Base>, U> func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T] func suffix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>] var underestimatedCount: Int { get } func forEach(_ body: (Base.Iterator.Element) throws -> Void) rethrows func first(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func dropFirst(_ n: Int) -> AnySequence<Base.Iterator.Element> func dropLast(_ n: Int) -> AnySequence<Base.Iterator.Element> func prefix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element> func dropFirst() -> AnySequence<Base.Iterator.Element> func dropLast() -> AnySequence<Base.Iterator.Element> func underestimateCount() -> Int func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>] func enumerated() -> EnumeratedSequence<LazyFilterSequence<Base>> @warn_unqualified_access func min(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result func reversed() -> [Base.Iterator.Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<LazyFilterSequence<Base>> func minElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func maxElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func reverse() -> [Base.Iterator.Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result } extension LazyFilterSequence { var lazy: LazyFilterSequence<Base> { get } } extension LazyFilterSequence { var elements: LazyFilterSequence<Base> { get } } extension LazyFilterSequence where Base.Iterator.Element : Sequence { func joined() -> FlattenSequence<LazyFilterSequence<Base>> func flatten() -> FlattenSequence<LazyFilterSequence<Base>> func joined() -> LazySequence<FlattenSequence<LazyFilterSequence<Base>>> func flatten() -> LazySequence<FlattenSequence<LazyFilterSequence<Base>>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazyFilterSequence<Base>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazyFilterSequence<Base>> } extension LazyFilterSequence where Base.Iterator.Element : Comparable { func sorted() -> [Base.Iterator.Element] func sort() -> [Base.Iterator.Element] @warn_unqualified_access func min() -> Base.Iterator.Element? @warn_unqualified_access func max() -> Base.Iterator.Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool func minElement() -> Base.Iterator.Element? func maxElement() -> Base.Iterator.Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool } extension LazyFilterSequence where Base.Iterator.Element : Equatable { func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element>] func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool } extension LazyFilterSequence where Base.Iterator.Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } | LazySequenceProtocol | Base : Sequence |
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 |
To | struct LazyMapCollection<Base : Collection, Element> : LazyCollectionProtocol, Collection { typealias Index = Base.Index var startIndex: Base.Index { get } var endIndex: Base.Index { get } func index(after i: Base.Index) -> Base.Index func formIndex(after i: inout Base.Index) subscript(_ position: Base.Index) -> Element { get } subscript(_ bounds: Range<Base.Index>) -> Slice<LazyMapCollection<Base, Element>> { get } typealias IndexDistance = Base.IndexDistance typealias Indices = Base.Indices var indices: Base.Indices { get } var isEmpty: Bool { get } var count: Base.IndexDistance { get } var first: Element? { get } func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index? func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance func makeIterator() -> LazyMapIterator<Base.Iterator, Element> var underestimatedCount: Int { get } init(_ base: Base, transform transform: (Base.Iterator.Element) -> Element) func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> Slice<LazyMapCollection<Base, Element>> func dropLast(_ n: Int) -> Slice<LazyMapCollection<Base, Element>> func prefix(_ maxLength: Int) -> Slice<LazyMapCollection<Base, Element>> func suffix(_ maxLength: Int) -> Slice<LazyMapCollection<Base, Element>> func prefix(upTo end: Base.Index) -> Slice<LazyMapCollection<Base, Element>> func suffix(from start: Base.Index) -> Slice<LazyMapCollection<Base, Element>> func prefix(through position: Base.Index) -> Slice<LazyMapCollection<Base, Element>> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<LazyMapCollection<Base, Element>>] typealias Generator = LazyMapIterator<Base.Iterator, Element> func generate() -> LazyMapIterator<Base.Iterator, Element> func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<LazyMapCollection<Base, Element>>] func index(where predicate: (Element) throws -> Bool) rethrows -> Base.Index? func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element] subscript(_ bounds: ClosedRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>> { get } func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element] func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Base.Index? func filter(_ isIncluded: @escaping (Element) -> Bool) -> LazyFilterCollection<LazyMapCollection<Base, Element>> func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapCollection<Base, Element>, SegmentOfResult>>> func flatMap<ElementOfResult>(_ transform: @escaping (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapCollection<Base, Element>, ElementOfResult?>>, ElementOfResult> func flatMap<SegmentOfResult : Collection>(_ transform: @escaping (Element) -> SegmentOfResult) -> LazyCollection<FlattenCollection<LazyMapCollection<LazyMapCollection<Base, Element>, SegmentOfResult>>> func flatMap<ElementOfResult>(_ transform: @escaping (Element) -> ElementOfResult?) -> LazyMapCollection<LazyFilterCollection<LazyMapCollection<LazyMapCollection<Base, Element>, ElementOfResult?>>, ElementOfResult> var lazy: LazyMapCollection<Base, Element> { get } var lazy: LazySequence<LazyMapCollection<Base, Element>> { get } var array: [Element] { get } func map<U>(_ transform: @escaping (Element) -> U) -> LazyMapSequence<LazyMapCollection<Base, Element>, U> func map<U>(_ transform: @escaping (Element) -> U) -> LazyMapCollection<LazyMapCollection<Base, Element>, U> func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] var underestimatedCount: Int { get } func forEach(_ body: (Element) throws -> Void) rethrows func first(where predicate: (Element) throws -> Bool) rethrows -> Element? func dropFirst() -> Slice<LazyMapCollection<Base, Element>> func dropLast() -> Slice<LazyMapCollection<Base, Element>> func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<LazyMapCollection<Base, Element>>] func enumerated() -> EnumeratedSequence<LazyMapCollection<Base, Element>> @warn_unqualified_access func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result func reversed() -> [Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<LazyMapCollection<Base, Element>> func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func reverse() -> [Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result } extension LazyMapCollection { subscript(_ bounds: Range<Base.Index>) -> Slice<LazyMapCollection<Base, Element>> { get } } extension LazyMapCollection { var isEmpty: Bool { get } var first: Element? { get } var underestimatedCount: Int { get } var count: Base.IndexDistance { get } } extension LazyMapCollection { var elements: LazyMapCollection<Base, Element> { get } } extension LazyMapCollection { var elements: LazyMapCollection<Base, Element> { get } } extension LazyMapCollection { func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance) func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Bool } extension LazyMapCollection { var lazy: LazyCollection<LazyMapCollection<Base, Element>> { get } } extension LazyMapCollection { var lazy: LazyMapCollection<Base, Element> { get } } extension LazyMapCollection where Element : Sequence { func joined() -> FlattenSequence<LazyMapCollection<Base, Element>> func flatten() -> FlattenSequence<LazyMapCollection<Base, Element>> func joined() -> LazySequence<FlattenSequence<LazyMapCollection<Base, Element>>> func flatten() -> LazySequence<FlattenSequence<LazyMapCollection<Base, Element>>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazyMapCollection<Base, Element>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazyMapCollection<Base, Element>> } extension LazyMapCollection where Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } extension LazyMapCollection where Base.Indices == DefaultIndices<Self> { var indices: DefaultIndices<LazyMapCollection<Base, Element>> { get } } extension LazyMapCollection where Base.Index : Strideable, Index.Stride : SignedInteger { subscript(_ bounds: CountableRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>> { get } subscript(_ bounds: CountableClosedRange<Base.Index>) -> Slice<LazyMapCollection<Base, Element>> { get } } extension LazyMapCollection where Element : Collection { func joined() -> FlattenCollection<LazyMapCollection<Base, Element>> func flatten() -> FlattenCollection<LazyMapCollection<Base, Element>> func joined() -> LazyCollection<FlattenCollection<LazyMapCollection<Base, Element>>> func flatten() -> LazyCollection<FlattenCollection<LazyMapCollection<Base, Element>>> } extension LazyMapCollection where Element : Equatable { func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [Slice<LazyMapCollection<Base, Element>>] func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [Slice<LazyMapCollection<Base, Element>>] func index(of element: Element) -> Base.Index? func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>] func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } extension LazyMapCollection where Element : Comparable { func sorted() -> [Element] func sort() -> [Element] @warn_unqualified_access func min() -> Element? @warn_unqualified_access func max() -> Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool func minElement() -> Element? func maxElement() -> Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } | Collection, LazyCollectionProtocol | Base : Collection |
Declaration | |
---|---|
From | subscript (_ position: Base.Index) -> Element { get } |
To | subscript(_ position: Base.Index) -> Element { get } |
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 |
To | struct LazyMapSequence<Base : Sequence, Element> : LazySequenceProtocol { typealias Elements = LazyMapSequence<Base, Element> func makeIterator() -> LazyMapIterator<Base.Iterator, Element> var underestimatedCount: Int { get } init(_ base: Base, transform transform: (Base.Iterator.Element) -> Element) func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element] func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element] func filter(_ isIncluded: @escaping (Element) -> Bool) -> LazyFilterSequence<LazyMapSequence<Base, Element>> func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<LazyMapSequence<Base, Element>, SegmentOfResult>>> func flatMap<ElementOfResult>(_ transform: @escaping (Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<LazyMapSequence<Base, Element>, ElementOfResult?>>, ElementOfResult> var lazy: LazySequence<LazyMapSequence<Base, Element>> { get } var array: [Element] { get } func map<U>(_ transform: @escaping (Element) -> U) -> LazyMapSequence<LazyMapSequence<Base, Element>, U> func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] func suffix(_ maxLength: Int) -> AnySequence<Element> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>] var underestimatedCount: Int { get } func forEach(_ body: (Element) throws -> Void) rethrows func first(where predicate: (Element) throws -> Bool) rethrows -> Element? func dropFirst(_ n: Int) -> AnySequence<Element> func dropLast(_ n: Int) -> AnySequence<Element> func prefix(_ maxLength: Int) -> AnySequence<Element> func dropFirst() -> AnySequence<Element> func dropLast() -> AnySequence<Element> func generate() -> LazyMapIterator<Base.Iterator, Element> func underestimateCount() -> Int func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>] func enumerated() -> EnumeratedSequence<LazyMapSequence<Base, Element>> @warn_unqualified_access func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result func reversed() -> [Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<LazyMapSequence<Base, Element>> func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func reverse() -> [Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result } extension LazyMapSequence { var lazy: LazyMapSequence<Base, Element> { get } } extension LazyMapSequence { var elements: LazyMapSequence<Base, Element> { get } } extension LazyMapSequence where Element : Sequence { func joined() -> FlattenSequence<LazyMapSequence<Base, Element>> func flatten() -> FlattenSequence<LazyMapSequence<Base, Element>> func joined() -> LazySequence<FlattenSequence<LazyMapSequence<Base, Element>>> func flatten() -> LazySequence<FlattenSequence<LazyMapSequence<Base, Element>>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazyMapSequence<Base, Element>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazyMapSequence<Base, Element>> } extension LazyMapSequence where Element : Comparable { func sorted() -> [Element] func sort() -> [Element] @warn_unqualified_access func min() -> Element? @warn_unqualified_access func max() -> Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool func minElement() -> Element? func maxElement() -> Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } extension LazyMapSequence where Element : Equatable { func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>] func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } extension LazyMapSequence where Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } | LazySequenceProtocol | Base : Sequence |
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 |
To | struct LazySequence<Base : Sequence> : LazySequenceProtocol, _SequenceWrapper { var elements: Base { get } func sorted(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element] func sort(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) -> Bool) -> [Base.Iterator.Element] func filter(_ isIncluded: @escaping (Base.Iterator.Element) -> Bool) -> LazyFilterSequence<Base> func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Base.Iterator.Element) -> SegmentOfResult) -> LazySequence<FlattenSequence<LazyMapSequence<Base, SegmentOfResult>>> func flatMap<ElementOfResult>(_ transform: @escaping (Base.Iterator.Element) -> ElementOfResult?) -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Base, ElementOfResult?>>, ElementOfResult> var lazy: LazySequence<LazySequence<Base>> { get } var array: [Base.Iterator.Element] { get } func map<U>(_ transform: @escaping (Base.Iterator.Element) -> U) -> LazyMapSequence<Base, U> func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T] func suffix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>] var underestimatedCount: Int { get } func forEach(_ body: (Base.Iterator.Element) throws -> Void) rethrows func first(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func dropFirst(_ n: Int) -> AnySequence<Base.Iterator.Element> func dropLast(_ n: Int) -> AnySequence<Base.Iterator.Element> func prefix(_ maxLength: Int) -> AnySequence<Base.Iterator.Element> func dropFirst() -> AnySequence<Base.Iterator.Element> func dropLast() -> AnySequence<Base.Iterator.Element> func generate() -> Base.Iterator func underestimateCount() -> Int func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<Base.Iterator.Element>] func enumerated() -> EnumeratedSequence<LazySequence<Base>> @warn_unqualified_access func min(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result func reversed() -> [Base.Iterator.Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<LazySequence<Base>> func minElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func maxElement(_ isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element? func reverse() -> [Base.Iterator.Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base.Iterator.Element, Base.Iterator.Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Base.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Base.Iterator.Element) throws -> Result) rethrows -> Result var underestimatedCount: Int { get } func makeIterator() -> Base.Iterator func map<T>(_ transform: (Base.Iterator.Element) throws -> T) rethrows -> [T] } extension LazySequence { var lazy: LazySequence<Base> { get } } extension LazySequence where Base == LazySequence<Base> { var elements: LazySequence<Base> { get } } extension LazySequence where Base.Iterator.Element : Sequence { func joined() -> FlattenSequence<LazySequence<Base>> func flatten() -> FlattenSequence<LazySequence<Base>> func joined() -> LazySequence<FlattenSequence<Base>> func flatten() -> LazySequence<FlattenSequence<Base>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<LazySequence<Base>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<LazySequence<Base>> } extension LazySequence where Base.Iterator.Element : Comparable { func sorted() -> [Base.Iterator.Element] func sort() -> [Base.Iterator.Element] @warn_unqualified_access func min() -> Base.Iterator.Element? @warn_unqualified_access func max() -> Base.Iterator.Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool func minElement() -> Base.Iterator.Element? func maxElement() -> Base.Iterator.Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool } extension LazySequence where Base.Iterator.Element : Equatable { func split(separator separator: Base.Iterator.Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base.Iterator.Element>] func split(_ separator: Base.Iterator.Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base.Iterator.Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base.Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base.Iterator.Element>(_ other: OtherSequence) -> Bool } extension LazySequence where Base.Iterator.Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } | LazySequenceProtocol | Base : Sequence |
Modified ManagedBuffer
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 |
To | class ManagedBuffer<Header, Element> { final class func create(minimumCapacity minimumCapacity: Int, makingHeaderWith factory: (ManagedBuffer<Header, Element>) throws -> Header) rethrows -> ManagedBuffer<Header, Element> final var capacity: Int { get } final func withUnsafeMutablePointerToHeader<R>(_ body: (UnsafeMutablePointer<Header>) throws -> R) rethrows -> R final func withUnsafeMutablePointerToElements<R>(_ body: (UnsafeMutablePointer<Element>) throws -> R) rethrows -> R final func withUnsafeMutablePointers<R>(_ body: (UnsafeMutablePointer<Header>, UnsafeMutablePointer<Element>) throws -> R) rethrows -> R final var header: Header final class func create(_ minimumCapacity: Int, initialValue initialValue: (ManagedBuffer<Header, Element>) -> Header) -> ManagedBuffer<Header, Element> } | -- | Header, Element |
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 |
To | struct ManagedBufferPointer<Header, Element> : Equatable { init(bufferClass bufferClass: Swift.AnyClass, minimumCapacity minimumCapacity: Int, makingHeaderWith factory: (AnyObject, (AnyObject) -> Int) throws -> Header) rethrows init(unsafeBufferObject buffer: AnyObject) var header: Header var buffer: AnyObject { get } var capacity: Int { get } func withUnsafeMutablePointerToHeader<R>(_ body: (UnsafeMutablePointer<Header>) throws -> R) rethrows -> R func withUnsafeMutablePointerToElements<R>(_ body: (UnsafeMutablePointer<Element>) throws -> R) rethrows -> R func withUnsafeMutablePointers<R>(_ body: (UnsafeMutablePointer<Header>, UnsafeMutablePointer<Element>) throws -> R) rethrows -> R mutating func isUniqueReference() -> Bool init(bufferClass bufferClass: Swift.AnyClass, minimumCapacity minimumCapacity: Int, initialValue initialValue: (AnyObject, (AnyObject) -> Int) -> Header) var allocatedElementCount: Int { get } mutating func holdsUniqueReference() -> Bool mutating func holdsUniqueOrPinnedReference() -> Bool } | Header, Element |
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 } |
To | struct Mirror { enum AncestorRepresentation { case generated case customized(() -> Mirror) case suppressed } init(reflecting subject: Any) typealias Child = (label: String?, value: Any) typealias Children = AnyCollection<Mirror.Child> enum DisplayStyle { case `struct` case `class` case `enum` case tuple case optional case collection case dictionary case set } init<Subject, C : Collection where C.Iterator.Element == Child, C.SubSequence : Collection, C.SubSequence.Iterator.Element == Child, C.SubSequence.Index == C.Index, C.SubSequence.Indices : Collection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : Collection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ subject: Subject, children children: C, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default) init<Subject, C : Collection where C.SubSequence : Collection, C.SubSequence.SubSequence == C.SubSequence, C.Indices : Collection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ subject: Subject, unlabeledChildren unlabeledChildren: C, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default) init<Subject>(_ subject: Subject, children children: DictionaryLiteral<String, Any>, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default) let subjectType: Any.Type let children: Mirror.Children let displayStyle: Mirror.DisplayStyle? var superclassMirror: Mirror? { get } func descendant(_ first: MirrorPath, _ rest: MirrorPath...) -> Any? } extension Mirror : CustomStringConvertible { var description: String { get } } extension Mirror : CustomReflectable { var customMirror: Mirror { get } } |
Modified Mirror.children
Declaration | |
---|---|
From | let children: Children |
To | let children: Mirror.Children |
Declaration | Generics[Parameters] | |
---|---|---|
From | init<T>(_ subject: T, children children: DictionaryLiteral<String, Any>, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default) | T |
To | init<Subject>(_ subject: Subject, children children: DictionaryLiteral<String, Any>, displayStyle displayStyle: Mirror.DisplayStyle? = default, ancestorRepresentation ancestorRepresentation: Mirror.AncestorRepresentation = default) | Subject |
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 } |
To | 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 } } | -- | -- |
To | protocol MutableIndexable : Indexable { associatedtype Index : Comparable var startIndex: Self.Index { get } var endIndex: Self.Index { get } subscript(_ position: Self.Index) -> Self._Element { get set } associatedtype SubSequence subscript(_ bounds: Range<Self.Index>) -> Self.SubSequence { get set } func index(after i: Self.Index) -> Self.Index func formIndex(after i: inout Self.Index) } | Indexable | iOS 10.0 |
Modified MutableIndexable.endIndex
Deprecation | |
---|---|
From | -- |
To | iOS 10.0 |
Modified MutableIndexable.startIndex
Deprecation | |
---|---|
From | -- |
To | iOS 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 } | iOS 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 |
To | struct MutableSlice<Base : MutableIndexable> : Collection, MutableCollection { typealias Index = Base.Index typealias IndexDistance = Base.IndexDistance var startIndex: Base.Index { get } var endIndex: Base.Index { get } subscript(_ index: Base.Index) -> Base._Element typealias SubSequence = MutableSlice<Base> subscript(_ bounds: Range<Base.Index>) -> MutableSlice<Base> func index(after i: Base.Index) -> Base.Index func formIndex(after i: inout Base.Index) func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index? func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance init(base base: Base, bounds bounds: Range<Base.Index>) var base: Base { get } mutating func popFirst() -> Base._Element? func map<T>(_ transform: (Base._Element) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> MutableSlice<Base> func dropLast(_ n: Int) -> MutableSlice<Base> func prefix(_ maxLength: Int) -> MutableSlice<Base> func suffix(_ maxLength: Int) -> MutableSlice<Base> func prefix(upTo end: Base.Index) -> MutableSlice<Base> func suffix(from start: Base.Index) -> MutableSlice<Base> func prefix(through position: Base.Index) -> MutableSlice<Base> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableSlice<Base>] mutating func removeFirst() -> Base._Element mutating func removeFirst(_ n: Int) typealias Generator = IndexingIterator<MutableSlice<Base>> func generate() -> IndexingIterator<MutableSlice<Base>> func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableSlice<Base>] func index(where predicate: (Base._Element) throws -> Bool) rethrows -> Base.Index? mutating func partition(by belongsInSecondPartition: (Base._Element) throws -> Bool) rethrows -> Base.Index func sorted(by areInIncreasingOrder: (Base._Element, Base._Element) -> Bool) -> [Base._Element] subscript(_ bounds: ClosedRange<Base.Index>) -> MutableSlice<Base> { get } subscript(_ bounds: ClosedRange<Base.Index>) -> MutableSlice<Base> func sort(_ isOrderedBefore: (Base._Element, Base._Element) -> Bool) -> [Base._Element] func indexOf(_ predicate: (Base._Element) throws -> Bool) rethrows -> Base.Index? var indices: DefaultIndices<MutableSlice<Base>> { get } var lazy: LazySequence<MutableSlice<Base>> { get } subscript(_ bounds: Range<Base.Index>) -> MutableSlice<MutableSlice<Base>> func map<T>(_ transform: (Base._Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Base._Element) throws -> Bool) rethrows -> [Base._Element] var underestimatedCount: Int { get } func forEach(_ body: (Base._Element) throws -> Void) rethrows func first(where predicate: (Base._Element) throws -> Bool) rethrows -> Base._Element? func dropFirst() -> MutableSlice<Base> func dropLast() -> MutableSlice<Base> func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [MutableSlice<Base>] func enumerated() -> EnumeratedSequence<MutableSlice<Base>> @warn_unqualified_access func min(by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, by areEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Base._Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base._Element) throws -> Result) rethrows -> Result func reversed() -> [Base._Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<MutableSlice<Base>> func minElement(_ isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element? func maxElement(_ isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element? func reverse() -> [Base._Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Base._Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Base._Element) throws -> Result) rethrows -> Result } extension MutableSlice { func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance) func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Bool } extension MutableSlice { func makeIterator() -> IndexingIterator<MutableSlice<Base>> } extension MutableSlice { var isEmpty: Bool { get } var first: Base._Element? { get } var underestimatedCount: Int { get } var count: Base.IndexDistance { get } } extension MutableSlice { var lazy: LazyCollection<MutableSlice<Base>> { get } } extension MutableSlice where Base._Element : Collection { func joined() -> FlattenCollection<MutableSlice<Base>> func flatten() -> FlattenCollection<MutableSlice<Base>> } extension MutableSlice where Base._Element : Equatable { func split(separator separator: Base._Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [MutableSlice<Base>] func split(_ separator: Base._Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [MutableSlice<Base>] func index(of element: Base._Element) -> Base.Index? func split(separator separator: Base._Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base._Element>] func split(_ separator: Base._Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base._Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool } extension MutableSlice where Base._Element : Sequence { func joined() -> FlattenSequence<MutableSlice<Base>> func flatten() -> FlattenSequence<MutableSlice<Base>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<MutableSlice<Base>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<MutableSlice<Base>> } extension MutableSlice where Base._Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } extension MutableSlice where Base._Element : Comparable { func sorted() -> [Base._Element] func sorted() -> [Base._Element] func sort() -> [Base._Element] @warn_unqualified_access func min() -> Base._Element? @warn_unqualified_access func max() -> Base._Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool func minElement() -> Base._Element? func maxElement() -> Base._Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool } extension MutableSlice where Base.Index : Strideable, Index.Stride : SignedInteger { subscript(_ bounds: CountableRange<Base.Index>) -> MutableSlice<Base> { get } subscript(_ bounds: CountableClosedRange<Base.Index>) -> MutableSlice<Base> { get } subscript(_ bounds: CountableRange<Base.Index>) -> MutableSlice<Base> subscript(_ bounds: CountableClosedRange<Base.Index>) -> MutableSlice<Base> } | Collection, MutableCollection |
Modified MutableSlice.init(base: Base, bounds: Range<Base.Index>)
Deprecation | |
---|---|
From | iOS 9.3 |
To | -- |
Modified MutableSlice.subscript(_: Base.Index) -> Base._Element
Declaration | |
---|---|
From | subscript (_ index: Base.Index) -> Base._Element |
To | subscript(_ index: Base.Index) -> Base._Element |
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 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 |
To | struct ObjectIdentifier : Hashable { var hashValue: Int { get } init(_ x: AnyObject) init(_ x: Any.Type) var uintValue: UInt { get } } extension ObjectIdentifier : CustomDebugStringConvertible { var debugDescription: String { get } } extension ObjectIdentifier : Comparable { static func <(_ lhs: ObjectIdentifier, _ rhs: ObjectIdentifier) -> Bool static func ==(_ x: ObjectIdentifier, _ y: ObjectIdentifier) -> Bool } | Comparable, CustomDebugStringConvertible, Hashable |
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 |
To | enum Optional<Wrapped> : ExpressibleByNilLiteral { case none case some(Wrapped) init(_ some: Wrapped) func map<U>(_ transform: (Wrapped) throws -> U) rethrows -> U? func flatMap<U>(_ transform: (Wrapped) throws -> U?) rethrows -> U? init(nilLiteral nilLiteral: ()) var unsafelyUnwrapped: Wrapped { get } static var None: Wrapped? { get } static func Some(_ x: Wrapped) -> Wrapped? } extension Optional : CustomDebugStringConvertible { var debugDescription: String { get } } extension Optional : CustomReflectable { var customMirror: Mirror { get } } | CustomDebugStringConvertible, CustomReflectable, ExpressibleByNilLiteral |
Declaration | |
---|---|
From | @warn_unused_result func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U? |
To | func flatMap<U>(_ transform: (Wrapped) throws -> U?) rethrows -> U? |
Declaration | |
---|---|
From | @warn_unused_result func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U? |
To | func map<U>(_ transform: (Wrapped) throws -> U) rethrows -> U? |
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) } |
To | enum PlaygroundQuickLook { case text(String) case int(Int64) case uInt(UInt64) case float(Float32) case double(Float64) case image(Any) case sound(Any) case color(Any) case bezierPath(Any) case attributedString(Any) case rectangle(Float64, Float64, Float64, Float64) case point(Float64, Float64) case size(Float64, Float64) case bool(Bool) case range(Int64, Int64) case view(Any) case sprite(Any) case url(String) case _raw([UInt8], String) init(reflecting subject: Any) } |
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 |
To | struct Range<Bound : Comparable> { init(uncheckedBounds bounds: (lower: Bound, upper: Bound)) let lowerBound: Bound let upperBound: Bound func contains(_ element: Bound) -> Bool var isEmpty: Bool { get } init(_ other: Range<Bound>) func overlaps(_ other: Range<Bound>) -> Bool func overlaps(_ other: ClosedRange<Bound>) -> Bool func clamped(to limits: Range<Bound>) -> Range<Bound> var startIndex: Bound { get } var endIndex: Bound { get } } extension Range : CustomStringConvertible { var description: String { get } } extension Range : CustomDebugStringConvertible { var debugDescription: String { get } } extension Range : CustomReflectable { var customMirror: Mirror { get } } extension Range : Equatable { static func ==(_ lhs: Range<Bound>, _ rhs: Range<Bound>) -> Bool static func ~=(_ pattern: Range<Bound>, _ value: Bound) -> Bool } | CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, Equatable | Bound : Comparable | Bound |
Modified Range.init(_: Range<Bound>)
Declaration | |
---|---|
From | init(_ x: Range<Element>) |
To | init(_ other: Range<Bound>) |
Modified Set [struct]
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 |
To | struct Set<Element : Hashable> : SetAlgebra, Hashable, Collection, ExpressibleByArrayLiteral { typealias Index = SetIndex<Element> init(minimumCapacity minimumCapacity: Int) var startIndex: SetIndex<Element> { get } var endIndex: SetIndex<Element> { get } func index(after i: SetIndex<Element>) -> SetIndex<Element> func contains(_ member: Element) -> Bool func index(of member: Element) -> SetIndex<Element>? mutating func insert(_ newMember: Element) -> (inserted: Bool, memberAfterInsert: Element) mutating func update(with newMember: Element) -> Element? mutating func remove(_ member: Element) -> Element? mutating func remove(at position: SetIndex<Element>) -> Element mutating func removeAll(keepingCapacity keepCapacity: Bool = default) mutating func removeFirst() -> Element var count: Int { get } subscript(_ position: SetIndex<Element>) -> Element { get } func makeIterator() -> SetIterator<Element> init(arrayLiteral elements: Element...) init() init<Source : Sequence where Source.Iterator.Element == Element>(_ sequence: Source) func isSubset<S : Sequence where S.Iterator.Element == Element>(of possibleSuperset: S) -> Bool func isStrictSubset<S : Sequence where S.Iterator.Element == Element>(of possibleStrictSuperset: S) -> Bool func isSuperset<S : Sequence where S.Iterator.Element == Element>(of possibleSubset: S) -> Bool func isStrictSuperset<S : Sequence where S.Iterator.Element == Element>(of possibleStrictSubset: S) -> Bool func isDisjoint<S : Sequence where S.Iterator.Element == Element>(with other: S) -> Bool func union<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Set<Element> mutating func formUnion<S : Sequence where S.Iterator.Element == Element>(_ other: S) func subtracting<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Set<Element> mutating func subtract<S : Sequence where S.Iterator.Element == Element>(_ other: S) func intersection<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Set<Element> mutating func formIntersection<S : Sequence where S.Iterator.Element == Element>(_ other: S) func symmetricDifference<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Set<Element> mutating func formSymmetricDifference<S : Sequence where S.Iterator.Element == Element>(_ other: S) var hashValue: Int { get } var isEmpty: Bool { get } var first: Element? { get } static func ==(_ lhs: Set<Element>, _ rhs: Set<Element>) -> Bool mutating func popFirst() -> Element? mutating func subtract(_ other: Set<Element>) func isSubset(of other: Set<Element>) -> Bool func isSuperset(of other: Set<Element>) -> Bool func isDisjoint(with other: Set<Element>) -> Bool func subtracting(_ other: Set<Element>) -> Set<Element> func isStrictSuperset(of other: Set<Element>) -> Bool func isStrictSubset(of other: Set<Element>) -> Bool func intersection(_ other: Set<Element>) -> Set<Element> mutating func formSymmetricDifference(_ other: Set<Element>) mutating func removeAtIndex(_ index: SetIndex<Element>) -> Element func generate() -> SetIterator<Element> func indexOf(_ member: Element) -> SetIndex<Element>? func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> Slice<Set<Element>> func dropLast(_ n: Int) -> Slice<Set<Element>> func prefix(_ maxLength: Int) -> Slice<Set<Element>> func suffix(_ maxLength: Int) -> Slice<Set<Element>> func prefix(upTo end: SetIndex<Element>) -> Slice<Set<Element>> func suffix(from start: SetIndex<Element>) -> Slice<Set<Element>> func prefix(through position: SetIndex<Element>) -> Slice<Set<Element>> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<Set<Element>>] func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [Slice<Set<Element>>] typealias Generator = SetIterator<Element> func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<Set<Element>>] func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [Slice<Set<Element>>] func index(where predicate: (Element) throws -> Bool) rethrows -> SetIndex<Element>? func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element] subscript(_ bounds: ClosedRange<SetIndex<Element>>) -> Slice<Set<Element>> { get } func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element] var indices: DefaultIndices<Set<Element>> { get } var lazy: LazySequence<Set<Element>> { get } func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element] var underestimatedCount: Int { get } func forEach(_ body: (Element) throws -> Void) rethrows func first(where predicate: (Element) throws -> Bool) rethrows -> Element? func dropFirst() -> Slice<Set<Element>> func dropLast() -> Slice<Set<Element>> func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [Slice<Set<Element>>] func enumerated() -> EnumeratedSequence<Set<Element>> @warn_unqualified_access func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result func reversed() -> [Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<Set<Element>> func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func reverse() -> [Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result func intersect(_ other: Set<Element>) -> Set<Element> func exclusiveOr(_ other: Set<Element>) -> Set<Element> mutating func unionInPlace(_ other: Set<Element>) mutating func intersectInPlace(_ other: Set<Element>) mutating func exclusiveOrInPlace(_ other: Set<Element>) func isSubsetOf(_ other: Set<Element>) -> Bool func isDisjointWith(_ other: Set<Element>) -> Bool func isSupersetOf(_ other: Set<Element>) -> Bool mutating func subtractInPlace(_ other: Set<Element>) func isStrictSupersetOf(_ other: Set<Element>) -> Bool func isStrictSubsetOf(_ other: Set<Element>) -> Bool } extension Set { } extension Set : CVarArg { } extension Set { subscript(_ bounds: Range<SetIndex<Element>>) -> Slice<Set<Element>> { get } } extension Set { var isEmpty: Bool { get } var first: Element? { get } var underestimatedCount: Int { get } var count: Int { get } } extension Set { func formIndex(after i: inout SetIndex<Element>) func index(_ i: SetIndex<Element>, offsetBy n: Int) -> SetIndex<Element> func index(_ i: SetIndex<Element>, offsetBy n: Int, limitedBy limit: SetIndex<Element>) -> SetIndex<Element>? func formIndex(_ i: inout SetIndex<Element>, offsetBy n: Int) func formIndex(_ i: inout SetIndex<Element>, offsetBy n: Int, limitedBy limit: SetIndex<Element>) -> Bool func distance(from start: SetIndex<Element>, to end: SetIndex<Element>) -> Int } extension Set { var lazy: LazyCollection<Set<Element>> { get } } extension Set { convenience init<S : Sequence where S.Iterator.Element == Element>(_ sequence: S) convenience init(arrayLiteral arrayLiteral: Element...) mutating func subtract(_ other: Set<Element>) var isEmpty: Bool { get } } extension Set : CustomReflectable { var customMirror: Mirror { get } } extension Set : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension Set where Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } extension Set where Element : Sequence { func joined() -> FlattenSequence<Set<Element>> func flatten() -> FlattenSequence<Set<Element>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<Set<Element>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<Set<Element>> } extension Set where Element : Comparable { func sorted() -> [Element] func sort() -> [Element] @warn_unqualified_access func min() -> Element? @warn_unqualified_access func max() -> Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool func minElement() -> Element? func maxElement() -> Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } extension Set where Element : Collection { func joined() -> FlattenCollection<Set<Element>> func flatten() -> FlattenCollection<Set<Element>> } extension Set where Element : _AnyHashableProtocol { mutating func insert<ConcreteElement : Hashable>(_ newMember: ConcreteElement) -> (inserted: Bool, memberAfterInsert: ConcreteElement) mutating func update<ConcreteElement : Hashable>(with newMember: ConcreteElement) -> ConcreteElement? mutating func remove<ConcreteElement : Hashable>(_ member: ConcreteElement) -> ConcreteElement? } | CVarArg, Collection, CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, ExpressibleByArrayLiteral, Hashable, SetAlgebra |
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 |
To | struct SetIndex<Element : Hashable> : Comparable { static func ==(_ lhs: SetIndex<Element>, _ rhs: SetIndex<Element>) -> Bool static func <(_ lhs: SetIndex<Element>, _ rhs: SetIndex<Element>) -> Bool } | Comparable |
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 |
To | struct Slice<Base : Indexable> : Collection { typealias Index = Base.Index typealias IndexDistance = Base.IndexDistance var startIndex: Base.Index { get } var endIndex: Base.Index { get } subscript(_ index: Base.Index) -> Base._Element { get } typealias SubSequence = Slice<Base> subscript(_ bounds: Range<Base.Index>) -> Slice<Base> { get } func index(after i: Base.Index) -> Base.Index func formIndex(after i: inout Base.Index) func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index? func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance init(base base: Base, bounds bounds: Range<Base.Index>) var base: Base { get } mutating func popFirst() -> Base._Element? func map<T>(_ transform: (Base._Element) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> Slice<Base> func dropLast(_ n: Int) -> Slice<Base> func prefix(_ maxLength: Int) -> Slice<Base> func suffix(_ maxLength: Int) -> Slice<Base> func prefix(upTo end: Base.Index) -> Slice<Base> func suffix(from start: Base.Index) -> Slice<Base> func prefix(through position: Base.Index) -> Slice<Base> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [Slice<Base>] mutating func removeFirst() -> Base._Element mutating func removeFirst(_ n: Int) typealias Generator = IndexingIterator<Slice<Base>> func generate() -> IndexingIterator<Slice<Base>> func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [Slice<Base>] func index(where predicate: (Base._Element) throws -> Bool) rethrows -> Base.Index? func sorted(by areInIncreasingOrder: (Base._Element, Base._Element) -> Bool) -> [Base._Element] subscript(_ bounds: ClosedRange<Base.Index>) -> Slice<Base> { get } func sort(_ isOrderedBefore: (Base._Element, Base._Element) -> Bool) -> [Base._Element] func indexOf(_ predicate: (Base._Element) throws -> Bool) rethrows -> Base.Index? var indices: DefaultIndices<Slice<Base>> { get } var lazy: LazySequence<Slice<Base>> { get } func map<T>(_ transform: (Base._Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Base._Element) throws -> Bool) rethrows -> [Base._Element] var underestimatedCount: Int { get } func forEach(_ body: (Base._Element) throws -> Void) rethrows func first(where predicate: (Base._Element) throws -> Bool) rethrows -> Base._Element? func dropFirst() -> Slice<Base> func dropLast() -> Slice<Base> func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Base._Element) throws -> Bool) rethrows -> [Slice<Base>] func enumerated() -> EnumeratedSequence<Slice<Base>> @warn_unqualified_access func min(by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, by areEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, by areInIncreasingOrder: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Base._Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Base._Element) throws -> Result) rethrows -> Result func reversed() -> [Base._Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<Slice<Base>> func minElement(_ isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element? func maxElement(_ isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Base._Element? func reverse() -> [Base._Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Base._Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Base._Element) throws -> Result) rethrows -> Result } extension Slice { func makeIterator() -> IndexingIterator<Slice<Base>> } extension Slice { func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance) func formIndex(_ i: inout Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Bool } extension Slice { var isEmpty: Bool { get } var first: Base._Element? { get } var underestimatedCount: Int { get } var count: Base.IndexDistance { get } } extension Slice { var lazy: LazyCollection<Slice<Base>> { get } } extension Slice where Base._Element : Collection { func joined() -> FlattenCollection<Slice<Base>> func flatten() -> FlattenCollection<Slice<Base>> } extension Slice where Base._Element : Equatable { func split(separator separator: Base._Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [Slice<Base>] func split(_ separator: Base._Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [Slice<Base>] func index(of element: Base._Element) -> Base.Index? func split(separator separator: Base._Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Base._Element>] func split(_ separator: Base._Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Base._Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool } extension Slice where Base._Element : Comparable { func sorted() -> [Base._Element] func sort() -> [Base._Element] @warn_unqualified_access func min() -> Base._Element? @warn_unqualified_access func max() -> Base._Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool func minElement() -> Base._Element? func maxElement() -> Base._Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Base._Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_ other: OtherSequence) -> Bool } extension Slice where Base._Element : Sequence { func joined() -> FlattenSequence<Slice<Base>> func flatten() -> FlattenSequence<Slice<Base>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<Slice<Base>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<Slice<Base>> } extension Slice where Base._Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } extension Slice where Slice<Base> == Slice<Self> { subscript(_ bounds: Range<Base.Index>) -> Slice<Slice<Base>> { get } } extension Slice where Base.Index : Strideable, Index.Stride : SignedInteger { subscript(_ bounds: CountableRange<Base.Index>) -> Slice<Base> { get } subscript(_ bounds: CountableClosedRange<Base.Index>) -> Slice<Base> { get } } | Collection |
Modified Slice.endIndex
Declaration | Readonly | |
---|---|---|
From | let endIndex: Base.Index | -- |
To | var endIndex: Base.Index { get } | yes |
Deprecation | |
---|---|
From | iOS 9.3 |
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 |
To | struct StaticString : ExpressibleByUnicodeScalarLiteral, ExpressibleByExtendedGraphemeClusterLiteral, ExpressibleByStringLiteral, CustomStringConvertible, CustomDebugStringConvertible, CustomReflectable { var utf8Start: UnsafePointer<UInt8> { get } var unicodeScalar: UnicodeScalar { get } var utf8CodeUnitCount: Int { get } var hasPointerRepresentation: Bool { get } var isASCII: Bool { get } func withUTF8Buffer<R>(_ body: (UnsafeBufferPointer<UInt8>) -> R) -> R init() init(unicodeScalarLiteral value: StaticString) init(extendedGraphemeClusterLiteral value: StaticString) init(stringLiteral value: StaticString) var description: String { get } var debugDescription: String { get } var customMirror: Mirror { get } var byteSize: Int { get } var stringValue: String { get } } | CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, ExpressibleByExtendedGraphemeClusterLiteral, ExpressibleByStringLiteral, ExpressibleByUnicodeScalarLiteral |
Declaration | |
---|---|
From | func withUTF8Buffer<R>(@noescape _ body: (UnsafeBufferPointer<UInt8>) -> R) -> R |
To | func withUTF8Buffer<R>(_ body: (UnsafeBufferPointer<UInt8>) -> R) -> R |
Modified Strideable
Declaration | |
---|---|
From | protocol Strideable : Comparable { associatedtype Stride : SignedNumberType @warn_unused_result func distanceTo(_ other: Self) -> Self.Stride @warn_unused_result func advancedBy(_ n: Self.Stride) -> Self } |
To | protocol Strideable : Comparable { associatedtype Stride : SignedNumber func distance(to other: Self) -> Self.Stride func advanced(by n: Self.Stride) -> Self } |
Modified StrideThrough [struct]
Declaration | Protocols | |
---|---|---|
From | struct StrideThrough<Element : Strideable> : SequenceType { typealias T = Element func generate() -> StrideThroughGenerator<Element> } extension StrideThrough : _Reflectable { } | SequenceType |
To | struct StrideThrough<Element : Strideable> : Sequence, CustomReflectable { func makeIterator() -> StrideThroughIterator<Element> var customMirror: Mirror { get } func sorted() -> [Element] func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element] func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element] func sort() -> [Element] var lazy: LazySequence<StrideThrough<Element>> { get } func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element] func suffix(_ maxLength: Int) -> AnySequence<Element> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>] var underestimatedCount: Int { get } func forEach(_ body: (Element) throws -> Void) rethrows func first(where predicate: (Element) throws -> Bool) rethrows -> Element? func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>] func dropFirst(_ n: Int) -> AnySequence<Element> func dropLast(_ n: Int) -> AnySequence<Element> func prefix(_ maxLength: Int) -> AnySequence<Element> func dropFirst() -> AnySequence<Element> func dropLast() -> AnySequence<Element> func generate() -> StrideThroughIterator<Element> func underestimateCount() -> Int func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>] func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>] func enumerated() -> EnumeratedSequence<StrideThrough<Element>> @warn_unqualified_access func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? @warn_unqualified_access func min() -> Element? @warn_unqualified_access func max() -> Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool func contains(_ element: Element) -> Bool func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result func reversed() -> [Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<StrideThrough<Element>> func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func reverse() -> [Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result func minElement() -> Element? func maxElement() -> Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } extension StrideThrough where Element : Sequence { func joined() -> FlattenSequence<StrideThrough<Element>> func flatten() -> FlattenSequence<StrideThrough<Element>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<StrideThrough<Element>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<StrideThrough<Element>> } extension StrideThrough where Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } | CustomReflectable, Sequence |
Modified StrideTo [struct]
Declaration | Protocols | |
---|---|---|
From | struct StrideTo<Element : Strideable> : SequenceType { typealias T = Element func generate() -> StrideToGenerator<Element> } extension StrideTo : _Reflectable { } | SequenceType |
To | struct StrideTo<Element : Strideable> : Sequence, CustomReflectable { func makeIterator() -> StrideToIterator<Element> var customMirror: Mirror { get } func sorted() -> [Element] func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element] func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element] func sort() -> [Element] var lazy: LazySequence<StrideTo<Element>> { get } func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element] func suffix(_ maxLength: Int) -> AnySequence<Element> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>] var underestimatedCount: Int { get } func forEach(_ body: (Element) throws -> Void) rethrows func first(where predicate: (Element) throws -> Bool) rethrows -> Element? func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>] func dropFirst(_ n: Int) -> AnySequence<Element> func dropLast(_ n: Int) -> AnySequence<Element> func prefix(_ maxLength: Int) -> AnySequence<Element> func dropFirst() -> AnySequence<Element> func dropLast() -> AnySequence<Element> func generate() -> StrideToIterator<Element> func underestimateCount() -> Int func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [AnySequence<Element>] func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>] func enumerated() -> EnumeratedSequence<StrideTo<Element>> @warn_unqualified_access func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? @warn_unqualified_access func min() -> Element? @warn_unqualified_access func max() -> Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool func contains(_ element: Element) -> Bool func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result func reversed() -> [Element] func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<StrideTo<Element>> func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func reverse() -> [Element] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result func minElement() -> Element? func maxElement() -> Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } extension StrideTo where Element : Sequence { func joined() -> FlattenSequence<StrideTo<Element>> func flatten() -> FlattenSequence<StrideTo<Element>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<StrideTo<Element>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<StrideTo<Element>> } extension StrideTo where Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } | CustomReflectable, Sequence |
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 |
To | struct String { init() init(cString cString: UnsafePointer<CChar>) init(cString cString: UnsafePointer<UInt8>) init?(validatingUTF8 cString: UnsafePointer<CChar>) static func decodeCString<Encoding : UnicodeCodec>(_ cString: UnsafePointer<Encoding.CodeUnit>?, as encoding: Encoding.Type, repairingInvalidCodeUnits isRepairing: Bool = default) -> (result: String, repairsMade: Bool)? static func fromCString(_ cs: UnsafePointer<CChar>) -> String? static func fromCStringRepairingIllFormedUTF8(_ cs: UnsafePointer<CChar>) -> (String?, hadError: Bool) init(_ c: Character) func withCString<Result>(_ body: (UnsafePointer<Int8>) throws -> Result) rethrows -> Result init<Subject>(describing instance: Subject) init<Subject>(reflecting subject: Subject) mutating func append(_ other: String) mutating func append(_ x: UnicodeScalar) static func +(_ lhs: String, _ rhs: String) -> String static func +=(_ lhs: inout String, _ rhs: String) func lowercased() -> String func uppercased() -> String init<T : LosslessStringConvertible>(_ value: T) mutating func appendContentsOf(_ other: String) mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Character>(_ newElements: S) mutating func insertContentsOf<S : Collection where S.Iterator.Element == Character>(_ newElements: S, at i: String.Index) mutating func replaceRange<C : Collection where C.Iterator.Element == Character>(_ subRange: Range<String.Index>, with newElements: C) mutating func replaceRange(_ subRange: Range<String.Index>, with newElements: String) mutating func removeAtIndex(_ i: String.Index) -> Character mutating func removeRange(_ subRange: Range<String.Index>) var lowercaseString: String { get } var uppercaseString: String { get } init<T>(_ _: T) struct CharacterView { init(_ text: String) } var characters: String.CharacterView mutating func withMutableCharacters<R>(_ body: (inout String.CharacterView) -> R) -> R init(_ characters: String.CharacterView) init(repeating repeatedValue: Character, count count: Int) init(repeating repeatedValue: UnicodeScalar, count count: Int) init(repeating repeatedValue: String, count count: Int) var isEmpty: Bool { get } func hasPrefix(_ prefix: String) -> Bool func hasSuffix(_ suffix: String) -> Bool init<T : _SignedInteger>(_ v: T) init<T : UnsignedInteger>(_ v: T) init<T : _SignedInteger>(_ value: T, radix radix: Int, uppercase uppercase: Bool = default) init<T : UnsignedInteger>(_ value: T, radix radix: Int, uppercase uppercase: Bool = default) init(count count: Int, repeatedValue c: Character) init(count count: Int, repeatedValue c: UnicodeScalar) typealias Index = String.CharacterView.Index typealias IndexDistance = String.CharacterView.IndexDistance var startIndex: String.Index { get } var endIndex: String.Index { get } func index(after i: String.Index) -> String.Index func index(before i: String.Index) -> String.Index func index(_ i: String.Index, offsetBy n: String.IndexDistance) -> String.Index func index(_ i: String.Index, offsetBy n: String.IndexDistance, limitedBy limit: String.Index) -> String.Index? func distance(from start: String.Index, to end: String.Index) -> String.IndexDistance subscript(_ i: String.Index) -> Character { get } subscript(_ bounds: Range<String.Index>) -> String { get } subscript(_ bounds: ClosedRange<String.Index>) -> String { get } init<S : Sequence where S.Iterator.Element == Character>(_ characters: S) mutating func reserveCapacity(_ n: Int) mutating func append(_ c: Character) mutating func append<S : Sequence where S.Iterator.Element == Character>(contentsOf newElements: S) mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Range<String.Index>, with newElements: C) mutating func replaceSubrange(_ bounds: Range<String.Index>, with newElements: String) mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: ClosedRange<String.Index>, with newElements: C) mutating func replaceSubrange(_ bounds: ClosedRange<String.Index>, with newElements: String) mutating func insert(_ newElement: Character, at i: String.Index) mutating func insert<S : Collection where S.Iterator.Element == Character>(contentsOf newElements: S, at i: String.Index) mutating func remove(at i: String.Index) -> Character mutating func removeSubrange(_ bounds: Range<String.Index>) mutating func removeSubrange(_ bounds: ClosedRange<String.Index>) mutating func removeAll(keepingCapacity keepCapacity: Bool = default) struct UTF16View : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible { struct Index { } typealias IndexDistance = Int var startIndex: String.UTF16View.Index { get } var endIndex: String.UTF16View.Index { get } struct Indices { } var indices: String.UTF16View.Indices { get } func index(after i: String.UTF16View.Index) -> String.UTF16View.Index func index(before i: String.UTF16View.Index) -> String.UTF16View.Index func index(_ i: String.UTF16View.Index, offsetBy n: String.UTF16View.IndexDistance) -> String.UTF16View.Index func index(_ i: String.UTF16View.Index, offsetBy n: String.UTF16View.IndexDistance, limitedBy limit: String.UTF16View.Index) -> String.UTF16View.Index? func distance(from start: String.UTF16View.Index, to end: String.UTF16View.Index) -> String.UTF16View.IndexDistance subscript(_ i: String.UTF16View.Index) -> UTF16.CodeUnit { get } subscript(_ i: Int) -> UTF16.CodeUnit { get } subscript(_ bounds: Range<Int>) -> String.UTF16View { get } subscript(_ bounds: Range<String.UTF16View.Index>) -> String.UTF16View { get } var description: String { get } var debugDescription: String { get } } var utf16: String.UTF16View init?(_ utf16: String.UTF16View) typealias UTF16Index = String.UTF16View.Index struct UTF8View : Collection, CustomStringConvertible, CustomDebugStringConvertible { struct Index { } typealias IndexDistance = Int var startIndex: String.UTF8View.Index { get } var endIndex: String.UTF8View.Index { get } func index(after i: String.UTF8View.Index) -> String.UTF8View.Index subscript(_ position: String.UTF8View.Index) -> UTF8.CodeUnit { get } subscript(_ bounds: Range<String.UTF8View.Index>) -> String.UTF8View { get } var description: String { get } var debugDescription: String { get } } var utf8: String.UTF8View var utf8CString: ContiguousArray<CChar> { get } init?(_ utf8: String.UTF8View) typealias UTF8Index = String.UTF8View.Index var nulTerminatedUTF8: ContiguousArray<UTF8.CodeUnit> { get } struct UnicodeScalarView : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible { struct Index { } var startIndex: String.UnicodeScalarView.Index { get } var endIndex: String.UnicodeScalarView.Index { get } func index(after i: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index func index(before i: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index subscript(_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get } subscript(_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get } struct Iterator : IteratorProtocol { mutating func next() -> UnicodeScalar? } func makeIterator() -> String.UnicodeScalarView.Iterator var description: String { get } var debugDescription: String { get } } init(_ unicodeScalars: String.UnicodeScalarView) typealias UnicodeScalarIndex = String.UnicodeScalarView.Index var unicodeScalars: String.UnicodeScalarView subscript(_ i: Int) -> Character { get } subscript(_ bounds: Range<Int>) -> String { get } subscript(_ bounds: ClosedRange<Int>) -> String { get } subscript(_ bounds: CountableRange<Int>) -> String { get } subscript(_ bounds: CountableClosedRange<Int>) -> String { get } var count: Int { get } } extension String { init(_ cocoaString: NSString) } extension String { } extension String : CVarArg { } extension String { static var availableStringEncodings: [String.Encoding] { get } static var defaultCStringEncoding: String.Encoding { get } static func localizedName(of encoding: String.Encoding) -> String static func localizedStringWithFormat(_ format: String, _ arguments: CVarArg...) -> String static func path(withComponents components: [String]) -> String init?(utf8String bytes: UnsafePointer<CChar>) func canBeConverted(to encoding: String.Encoding) -> Bool var capitalized: String { get } var localizedCapitalized: String { get } func capitalized(with locale: Locale?) -> String func caseInsensitiveCompare(_ aString: String) -> ComparisonResult func commonPrefix(with aString: String, options options: String.CompareOptions = default) -> String func compare(_ aString: String, options mask: String.CompareOptions = default, range range: Range<String.Index>? = default, locale locale: Locale? = default) -> ComparisonResult func completePath(into outputName: UnsafeMutablePointer<String>? = default, caseSensitive caseSensitive: Bool, matchesInto outputArray: UnsafeMutablePointer<[String]>? = default, filterTypes filterTypes: [String]? = default) -> Int func components(separatedBy separator: CharacterSet) -> [String] func components(separatedBy separator: String) -> [String] func cString(using encoding: String.Encoding) -> [CChar]? func data(using encoding: String.Encoding, allowLossyConversion allowLossyConversion: Bool = default) -> Data? var decomposedStringWithCanonicalMapping: String { get } var decomposedStringWithCompatibilityMapping: String { get } func enumerateLines(invoking body: @escaping (String, inout Bool) -> ()) func enumerateLinguisticTags(in range: Range<String.Index>, scheme tagScheme: String, options opts: NSLinguisticTagger.Options = default, orthography orthography: NSOrthography? = default, invoking body: (String, Range<String.Index>, Range<String.Index>, inout Bool) -> ()) func enumerateSubstrings(in range: Range<String.Index>, options opts: String.EnumerationOptions = default, _ body: @escaping (String?, Range<String.Index>, Range<String.Index>, inout Bool) -> ()) var fastestEncoding: String.Encoding { get } var fileSystemRepresentation: [CChar] { get } func getBytes(_ buffer: inout [UInt8], maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding encoding: String.Encoding, options options: String.EncodingConversionOptions = default, range range: Range<String.Index>, remaining leftover: UnsafeMutablePointer<Range<String.Index>>) -> Bool func getCString(_ buffer: inout [CChar], maxLength maxLength: Int, encoding encoding: String.Encoding) -> Bool func getFileSystemRepresentation(_ buffer: inout [CChar], maxLength maxLength: Int) -> Bool func getLineStart(_ start: UnsafeMutablePointer<String.Index>, end end: UnsafeMutablePointer<String.Index>, contentsEnd contentsEnd: UnsafeMutablePointer<String.Index>, for range: Range<String.Index>) func getParagraphStart(_ start: UnsafeMutablePointer<String.Index>, end end: UnsafeMutablePointer<String.Index>, contentsEnd contentsEnd: UnsafeMutablePointer<String.Index>, for range: Range<String.Index>) var hash: Int { get } init?<S : Sequence where S.Iterator.Element == UInt8>(bytes bytes: S, encoding encoding: String.Encoding) init?(bytesNoCopy bytes: UnsafeMutableRawPointer, length length: Int, encoding encoding: String.Encoding, freeWhenDone flag: Bool) init(utf16CodeUnits utf16CodeUnits: UnsafePointer<unichar>, count count: Int) init(utf16CodeUnitsNoCopy utf16CodeUnitsNoCopy: UnsafePointer<unichar>, count count: Int, freeWhenDone flag: Bool) init(contentsOfFile path: String, encoding enc: String.Encoding) throws init(contentsOfFile path: String, usedEncoding usedEncoding: inout String.Encoding) throws init(contentsOfFile path: String) throws init(contentsOf url: URL, encoding enc: String.Encoding) throws init(contentsOf url: URL, usedEncoding usedEncoding: inout String.Encoding) throws init(contentsOf url: URL) throws init?(cString cString: UnsafePointer<CChar>, encoding enc: String.Encoding) init?(data data: Data, encoding encoding: String.Encoding) init(format format: String, _ arguments: CVarArg...) init(format format: String, arguments arguments: [CVarArg]) init(format format: String, locale locale: Locale?, _ args: CVarArg...) init(format format: String, locale locale: Locale?, arguments arguments: [CVarArg]) var lastPathComponent: String { get } var utf16Count: Int { get } func lengthOfBytes(using encoding: String.Encoding) -> Int func lineRange(for aRange: Range<String.Index>) -> Range<String.Index> func linguisticTags(in range: Range<String.Index>, scheme tagScheme: String, options opts: NSLinguisticTagger.Options = default, orthography orthography: NSOrthography? = default, tokenRanges tokenRanges: UnsafeMutablePointer<[Range<String.Index>]>? = default) -> [String] func localizedCaseInsensitiveCompare(_ aString: String) -> ComparisonResult func localizedCompare(_ aString: String) -> ComparisonResult func localizedStandardCompare(_ string: String) -> ComparisonResult var localizedLowercase: String { get } func lowercased(with locale: Locale?) -> String func maximumLengthOfBytes(using encoding: String.Encoding) -> Int func paragraphRange(for aRange: Range<String.Index>) -> Range<String.Index> var pathComponents: [String] { get } var pathExtension: String { get } var precomposedStringWithCanonicalMapping: String { get } var precomposedStringWithCompatibilityMapping: String { get } func propertyList() -> Any func propertyListFromStringsFileFormat() -> [String : String] func rangeOfCharacter(from aSet: CharacterSet, options mask: String.CompareOptions = default, range aRange: Range<String.Index>? = default) -> Range<String.Index>? func rangeOfComposedCharacterSequence(at anIndex: String.Index) -> Range<String.Index> func rangeOfComposedCharacterSequences(for range: Range<String.Index>) -> Range<String.Index> func range(of aString: String, options mask: String.CompareOptions = default, range searchRange: Range<String.Index>? = default, locale locale: Locale? = default) -> Range<String.Index>? func localizedStandardContains(_ string: String) -> Bool func localizedStandardRange(of string: String) -> Range<String.Index>? var smallestEncoding: String.Encoding { get } var abbreviatingWithTildeInPath: String { get } func addingPercentEncoding(withAllowedCharacters allowedCharacters: CharacterSet) -> String? func addingPercentEscapes(using encoding: String.Encoding) -> String? func appendingFormat(_ format: String, _ arguments: CVarArg...) -> String func appendingPathComponent(_ aString: String) -> String func appendingPathExtension(_ ext: String) -> String? func appending(_ aString: String) -> String var deletingLastPathComponent: String { get } var deletingPathExtension: String { get } var expandingTildeInPath: String { get } func folding(_ options: String.CompareOptions = default, locale locale: Locale?) -> String func folding(options options: String.CompareOptions = default, locale locale: Locale?) -> String func padding(toLength newLength: Int, withPad padString: String, startingAt padIndex: Int) -> String var removingPercentEncoding: String? { get } func replacingCharacters(in range: Range<String.Index>, with replacement: String) -> String func replacingOccurrences(of target: String, with replacement: String, options options: String.CompareOptions = default, range searchRange: Range<String.Index>? = default) -> String func replacingPercentEscapes(using encoding: String.Encoding) -> String? var resolvingSymlinksInPath: String { get } var standardizingPath: String { get } func trimmingCharacters(in set: CharacterSet) -> String func strings(byAppendingPaths paths: [String]) -> [String] func substring(from index: String.Index) -> String func substring(to index: String.Index) -> String func substring(with aRange: Range<String.Index>) -> String var localizedUppercase: String { get } func uppercased(with locale: Locale?) -> String func write(toFile path: String, atomically useAuxiliaryFile: Bool, encoding enc: String.Encoding) throws func write(to url: URL, atomically useAuxiliaryFile: Bool, encoding enc: String.Encoding) throws func applyingTransform(_ transform: StringTransform, reverse reverse: Bool) -> String? func contains(_ other: String) -> Bool func localizedCaseInsensitiveContains(_ other: String) -> Bool } extension String { static func localizedNameOfStringEncoding(_ encoding: String.Encoding) -> String static func pathWithComponents(_ components: [String]) -> String func canBeConvertedToEncoding(_ encoding: String.Encoding) -> Bool func capitalizedStringWith(_ locale: Locale?) -> String func commonPrefixWith(_ aString: String, options options: String.CompareOptions) -> String func completePathInto(_ outputName: UnsafeMutablePointer<String>? = default, caseSensitive caseSensitive: Bool, matchesInto matchesIntoArray: UnsafeMutablePointer<[String]>? = default, filterTypes filterTypes: [String]? = default) -> Int func componentsSeparatedByCharactersIn(_ separator: CharacterSet) -> [String] func componentsSeparatedBy(_ separator: String) -> [String] func cStringUsingEncoding(_ encoding: String.Encoding) -> [CChar]? func dataUsingEncoding(_ encoding: String.Encoding, allowLossyConversion allowLossyConversion: Bool = default) -> Data? func enumerateLinguisticTagsIn(_ range: Range<String.Index>, scheme tagScheme: String, options opts: NSLinguisticTagger.Options, orthography orthography: NSOrthography?, _ body: (String, Range<String.Index>, Range<String.Index>, inout Bool) -> ()) func enumerateSubstringsIn(_ range: Range<String.Index>, options opts: String.EnumerationOptions = default, _ body: (String?, Range<String.Index>, Range<String.Index>, inout Bool) -> ()) func getBytes(_ buffer: inout [UInt8], maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding encoding: String.Encoding, options options: String.EncodingConversionOptions = default, range range: Range<String.Index>, remainingRange leftover: UnsafeMutablePointer<Range<String.Index>>) -> Bool func getLineStart(_ start: UnsafeMutablePointer<String.Index>, end end: UnsafeMutablePointer<String.Index>, contentsEnd contentsEnd: UnsafeMutablePointer<String.Index>, forRange forRange: Range<String.Index>) func getParagraphStart(_ start: UnsafeMutablePointer<String.Index>, end end: UnsafeMutablePointer<String.Index>, contentsEnd contentsEnd: UnsafeMutablePointer<String.Index>, forRange forRange: Range<String.Index>) func lengthOfBytesUsingEncoding(_ encoding: String.Encoding) -> Int func lineRangeFor(_ aRange: Range<String.Index>) -> Range<String.Index> func linguisticTagsIn(_ range: Range<String.Index>, scheme tagScheme: String, options opts: NSLinguisticTagger.Options = default, orthography orthography: NSOrthography? = default, tokenRanges tokenRanges: UnsafeMutablePointer<[Range<String.Index>]>? = default) -> [String] func lowercaseStringWith(_ locale: Locale?) -> String func maximumLengthOfBytesUsingEncoding(_ encoding: String.Encoding) -> Int func paragraphRangeFor(_ aRange: Range<String.Index>) -> Range<String.Index> func rangeOfCharacterFrom(_ aSet: CharacterSet, options mask: String.CompareOptions = default, range aRange: Range<String.Index>? = default) -> Range<String.Index>? func rangeOfComposedCharacterSequenceAt(_ anIndex: String.Index) -> Range<String.Index> func rangeOfComposedCharacterSequencesFor(_ range: Range<String.Index>) -> Range<String.Index> func rangeOf(_ aString: String, options mask: String.CompareOptions = default, range searchRange: Range<String.Index>? = default, locale locale: Locale? = default) -> Range<String.Index>? func localizedStandardRangeOf(_ string: String) -> Range<String.Index>? func addingPercentEncodingWithAllowedCharacters(_ allowedCharacters: CharacterSet) -> String? func addingPercentEscapesUsingEncoding(_ encoding: String.Encoding) -> String? func stringByAppendingFormat(_ format: String, _ arguments: CVarArg...) -> String func byPaddingToLength(_ newLength: Int, withString padString: String, startingAt padIndex: Int) -> String func replacingCharactersIn(_ range: Range<String.Index>, withString replacement: String) -> String func replacingOccurrencesOf(_ target: String, withString replacement: String, options options: String.CompareOptions = default, range searchRange: Range<String.Index>? = default) -> String func replacingPercentEscapesUsingEncoding(_ encoding: String.Encoding) -> String? func byTrimmingCharactersIn(_ set: CharacterSet) -> String func stringsByAppendingPaths(_ paths: [String]) -> [String] func substringFrom(_ index: String.Index) -> String func substringTo(_ index: String.Index) -> String func substringWith(_ aRange: Range<String.Index>) -> String func uppercaseStringWith(_ locale: Locale?) -> String func writeToFile(_ path: String, atomically useAuxiliaryFile: Bool, encoding enc: String.Encoding) throws func writeToURL(_ url: URL, atomically useAuxiliaryFile: Bool, encoding enc: String.Encoding) throws } extension String { struct Encoding : RawRepresentable { var rawValue: UInt init(rawValue rawValue: UInt) static let ascii: String.Encoding static let nextstep: String.Encoding static let japaneseEUC: String.Encoding static let utf8: String.Encoding static let isoLatin1: String.Encoding static let symbol: String.Encoding static let nonLossyASCII: String.Encoding static let shiftJIS: String.Encoding static let isoLatin2: String.Encoding static let unicode: String.Encoding static let windowsCP1251: String.Encoding static let windowsCP1252: String.Encoding static let windowsCP1253: String.Encoding static let windowsCP1254: String.Encoding static let windowsCP1250: String.Encoding static let iso2022JP: String.Encoding static let macOSRoman: String.Encoding static let utf16: String.Encoding static let utf16BigEndian: String.Encoding static let utf16LittleEndian: String.Encoding static let utf32: String.Encoding static let utf32BigEndian: String.Encoding static let utf32LittleEndian: String.Encoding } typealias EncodingConversionOptions = NSString.EncodingConversionOptions typealias EnumerationOptions = NSString.EnumerationOptions typealias CompareOptions = NSString.CompareOptions } extension String : CustomReflectable { var customMirror: Mirror { get } } extension String : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension String : TextOutputStream { mutating func write(_ other: String) } extension String : TextOutputStreamable { func write<Target : TextOutputStream>(to target: inout Target) } extension String : ExpressibleByUnicodeScalarLiteral { init(unicodeScalarLiteral value: String) } extension String : ExpressibleByExtendedGraphemeClusterLiteral { init(extendedGraphemeClusterLiteral value: String) } extension String : ExpressibleByStringLiteral { init(stringLiteral value: String) } extension String : CustomDebugStringConvertible { var debugDescription: String { get } } extension String : Equatable { static func ==(_ lhs: String, _ rhs: String) -> Bool } extension String : Comparable { static func <(_ lhs: String, _ rhs: String) -> Bool } extension String : Hashable { var hashValue: Int { get } } extension String : CustomStringConvertible { var description: String { get } } extension String : LosslessStringConvertible { init?(_ description: String) } extension String : ExpressibleByStringInterpolation { init(stringInterpolation strings: String...) init<T>(stringInterpolationSegment expr: T) init(stringInterpolationSegment expr: String) init(stringInterpolationSegment expr: Character) init(stringInterpolationSegment expr: UnicodeScalar) init(stringInterpolationSegment expr: Bool) init(stringInterpolationSegment expr: Float32) init(stringInterpolationSegment expr: Float64) init(stringInterpolationSegment expr: UInt8) init(stringInterpolationSegment expr: Int8) init(stringInterpolationSegment expr: UInt16) init(stringInterpolationSegment expr: Int16) init(stringInterpolationSegment expr: UInt32) init(stringInterpolationSegment expr: Int32) init(stringInterpolationSegment expr: UInt64) init(stringInterpolationSegment expr: Int64) init(stringInterpolationSegment expr: UInt) init(stringInterpolationSegment expr: Int) } | CVarArg, Comparable, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, ExpressibleByExtendedGraphemeClusterLiteral, ExpressibleByStringInterpolation, ExpressibleByStringLiteral, ExpressibleByUnicodeScalarLiteral, Hashable, LosslessStringConvertible, TextOutputStream, TextOutputStreamable |
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 } |
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(_: Range<String.Index>) -> String
Declaration | |
---|---|
From | subscript (_ subRange: Range<Index>) -> String { get } |
To | subscript(_ bounds: Range<String.Index>) -> String { get } |
Declaration | |
---|---|
From | subscript (_ i: Index) -> Character { get } |
To | subscript(_ i: String.Index) -> Character { 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 | -- |
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 |
To | struct CharacterView { init(_ text: String) } extension String.CharacterView { subscript(_ bounds: Range<String.CharacterView.Index>) -> String.CharacterView { get } mutating func replaceRange<C where C : Collection, C.Iterator.Element == Character>(_ subRange: Range<String.CharacterView.Index>, with newElements: C) mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Character>(_ newElements: S) } extension String.CharacterView : BidirectionalCollection { struct Index : Comparable, CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } typealias IndexDistance = Int var startIndex: String.CharacterView.Index { get } var endIndex: String.CharacterView.Index { get } func index(after i: String.CharacterView.Index) -> String.CharacterView.Index func index(before i: String.CharacterView.Index) -> String.CharacterView.Index subscript(_ i: String.CharacterView.Index) -> Character { get } } extension String.CharacterView : RangeReplaceableCollection { init() mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Range<String.CharacterView.Index>, with newElements: C) mutating func reserveCapacity(_ n: Int) mutating func append(_ c: Character) mutating func append<S : Sequence where S.Iterator.Element == Character>(contentsOf newElements: S) init<S : Sequence where S.Iterator.Element == Character>(_ characters: S) } | BidirectionalCollection, RangeReplaceableCollection |
Modified String.CharacterView.subscript(_: 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.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.Index [struct]
Declaration | Protocols | |
---|---|---|
From | struct Index : BidirectionalIndexType, Comparable, _Reflectable { func successor() -> String.CharacterView.Index func predecessor() -> String.CharacterView.Index } | BidirectionalIndexType, Comparable |
To | struct Index : Comparable, CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } | Comparable, CustomPlaygroundQuickLookable |
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 |
To | struct UnicodeScalarView : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible { struct Index { } var startIndex: String.UnicodeScalarView.Index { get } var endIndex: String.UnicodeScalarView.Index { get } func index(after i: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index func index(before i: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index subscript(_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get } subscript(_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get } struct Iterator : IteratorProtocol { mutating func next() -> UnicodeScalar? } func makeIterator() -> String.UnicodeScalarView.Iterator var description: String { get } var debugDescription: String { get } } extension String.UnicodeScalarView { mutating func popLast() -> UnicodeScalar? mutating func removeLast() -> UnicodeScalar mutating func removeLast(_ n: Int) func dropLast(_ n: Int) -> String.UnicodeScalarView func suffix(_ maxLength: Int) -> String.UnicodeScalarView mutating func popFirst() -> UnicodeScalar? func map<T>(_ transform: (UnicodeScalar) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> String.UnicodeScalarView func prefix(_ maxLength: Int) -> String.UnicodeScalarView func prefix(upTo end: String.UnicodeScalarView.Index) -> String.UnicodeScalarView func suffix(from start: String.UnicodeScalarView.Index) -> String.UnicodeScalarView func prefix(through position: String.UnicodeScalarView.Index) -> String.UnicodeScalarView func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (UnicodeScalar) throws -> Bool) rethrows -> [String.UnicodeScalarView] func split(separator separator: UnicodeScalar, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [String.UnicodeScalarView] mutating func removeFirst() -> UnicodeScalar mutating func removeFirst(_ n: Int) typealias Generator = String.UnicodeScalarView.Iterator func generate() -> String.UnicodeScalarView.Iterator func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (UnicodeScalar) throws -> Bool) rethrows -> [String.UnicodeScalarView] func split(_ separator: UnicodeScalar, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [String.UnicodeScalarView] var last: UnicodeScalar? { get } func index(of element: UnicodeScalar) -> String.UnicodeScalarView.Index? func index(where predicate: (UnicodeScalar) throws -> Bool) rethrows -> String.UnicodeScalarView.Index? func sorted() -> [UnicodeScalar] func sorted(by areInIncreasingOrder: (UnicodeScalar, UnicodeScalar) -> Bool) -> [UnicodeScalar] subscript(_ bounds: ClosedRange<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get } func sort(_ isOrderedBefore: (UnicodeScalar, UnicodeScalar) -> Bool) -> [UnicodeScalar] func sort() -> [UnicodeScalar] func indexOf(_ element: UnicodeScalar) -> String.UnicodeScalarView.Index? var indices: DefaultBidirectionalIndices<String.UnicodeScalarView> { get } var lazy: LazySequence<String.UnicodeScalarView> { get } func reversed() -> ReversedCollection<String.UnicodeScalarView> func reverse() -> ReversedCollection<String.UnicodeScalarView> func map<T>(_ transform: (UnicodeScalar) throws -> T) rethrows -> [T] func filter(_ isIncluded: (UnicodeScalar) throws -> Bool) rethrows -> [UnicodeScalar] var underestimatedCount: Int { get } func forEach(_ body: (UnicodeScalar) throws -> Void) rethrows func first(where predicate: (UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar? func dropFirst() -> String.UnicodeScalarView func dropLast() -> String.UnicodeScalarView func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (UnicodeScalar) throws -> Bool) rethrows -> [String.UnicodeScalarView] func enumerated() -> EnumeratedSequence<String.UnicodeScalarView> @warn_unqualified_access func min(by areInIncreasingOrder: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar? @warn_unqualified_access func max(by areInIncreasingOrder: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar? @warn_unqualified_access func min() -> UnicodeScalar? @warn_unqualified_access func max() -> UnicodeScalar? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UnicodeScalar>(with possiblePrefix: PossiblePrefix, by areEquivalent: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UnicodeScalar>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence, by areEquivalent: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence) -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence, by areInIncreasingOrder: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence) -> Bool func contains(_ element: UnicodeScalar) -> Bool func contains(where predicate: (UnicodeScalar) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, UnicodeScalar) throws -> Result) rethrows -> Result func flatMap<SegmentOfResult : Sequence>(_ transform: (UnicodeScalar) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (UnicodeScalar) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<String.UnicodeScalarView> func minElement(_ isOrderedBefore: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar? func maxElement(_ isOrderedBefore: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> UnicodeScalar? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UnicodeScalar>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence, isEquivalent isEquivalent: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (UnicodeScalar, UnicodeScalar) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, UnicodeScalar) throws -> Result) rethrows -> Result func minElement() -> UnicodeScalar? func maxElement() -> UnicodeScalar? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UnicodeScalar>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UnicodeScalar>(_ other: OtherSequence) -> Bool } extension String.UnicodeScalarView { var lazy: LazyBidirectionalCollection<String.UnicodeScalarView> { get } } extension String.UnicodeScalarView { var isEmpty: Bool { get } var first: UnicodeScalar? { get } var underestimatedCount: Int { get } var count: Int { get } } extension String.UnicodeScalarView { var lazy: LazyCollection<String.UnicodeScalarView> { get } } extension String.UnicodeScalarView { func formIndex(after i: inout String.UnicodeScalarView.Index) func formIndex(_ i: inout String.UnicodeScalarView.Index, offsetBy n: Int) func formIndex(_ i: inout String.UnicodeScalarView.Index, offsetBy n: Int, limitedBy limit: String.UnicodeScalarView.Index) -> Bool } extension String.UnicodeScalarView { func formIndex(before i: inout String.UnicodeScalarView.Index) func index(_ i: String.UnicodeScalarView.Index, offsetBy n: Int) -> String.UnicodeScalarView.Index func index(_ i: String.UnicodeScalarView.Index, offsetBy n: Int, limitedBy limit: String.UnicodeScalarView.Index) -> String.UnicodeScalarView.Index? func distance(from start: String.UnicodeScalarView.Index, to end: String.UnicodeScalarView.Index) -> Int } extension String.UnicodeScalarView : RangeReplaceableCollection { init() mutating func reserveCapacity(_ n: Int) mutating func append(_ x: UnicodeScalar) mutating func append<S : Sequence where S.Iterator.Element == UnicodeScalar>(contentsOf newElements: S) mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == UnicodeScalar>(_ bounds: Range<String.UnicodeScalarView.Index>, with newElements: C) } extension String.UnicodeScalarView : CustomReflectable { var customMirror: Mirror { get } } extension String.UnicodeScalarView : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } | BidirectionalCollection, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, RangeReplaceableCollection |
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 } |
Declaration | |
---|---|
From | subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get } |
To | subscript(_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { 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 |
To | struct Index { } extension String.UnicodeScalarView.Index : Comparable { static func ==(_ lhs: String.UnicodeScalarView.Index, _ rhs: String.UnicodeScalarView.Index) -> Bool static func <(_ lhs: String.UnicodeScalarView.Index, _ rhs: String.UnicodeScalarView.Index) -> Bool } | Comparable |
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 |
To | struct UTF16View : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible { struct Index { } typealias IndexDistance = Int var startIndex: String.UTF16View.Index { get } var endIndex: String.UTF16View.Index { get } struct Indices { } var indices: String.UTF16View.Indices { get } func index(after i: String.UTF16View.Index) -> String.UTF16View.Index func index(before i: String.UTF16View.Index) -> String.UTF16View.Index func index(_ i: String.UTF16View.Index, offsetBy n: String.UTF16View.IndexDistance) -> String.UTF16View.Index func index(_ i: String.UTF16View.Index, offsetBy n: String.UTF16View.IndexDistance, limitedBy limit: String.UTF16View.Index) -> String.UTF16View.Index? func distance(from start: String.UTF16View.Index, to end: String.UTF16View.Index) -> String.UTF16View.IndexDistance subscript(_ i: String.UTF16View.Index) -> UTF16.CodeUnit { get } subscript(_ i: Int) -> UTF16.CodeUnit { get } subscript(_ bounds: Range<Int>) -> String.UTF16View { get } subscript(_ bounds: Range<String.UTF16View.Index>) -> String.UTF16View { get } var description: String { get } var debugDescription: String { get } } extension String.UTF16View : RandomAccessCollection { } extension String.UTF16View { mutating func popLast() -> UInt16? mutating func removeLast() -> UInt16 mutating func removeLast(_ n: Int) func dropLast(_ n: Int) -> String.UTF16View func suffix(_ maxLength: Int) -> String.UTF16View mutating func popFirst() -> UInt16? func map<T>(_ transform: (UInt16) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> String.UTF16View func prefix(_ maxLength: Int) -> String.UTF16View func prefix(upTo end: String.UTF16View.Index) -> String.UTF16View func suffix(from start: String.UTF16View.Index) -> String.UTF16View func prefix(through position: String.UTF16View.Index) -> String.UTF16View func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (UInt16) throws -> Bool) rethrows -> [String.UTF16View] func split(separator separator: UInt16, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [String.UTF16View] mutating func removeFirst() -> UInt16 mutating func removeFirst(_ n: Int) typealias Generator = IndexingIterator<String.UTF16View> func generate() -> IndexingIterator<String.UTF16View> func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (UInt16) throws -> Bool) rethrows -> [String.UTF16View] func split(_ separator: UInt16, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [String.UTF16View] var last: UInt16? { get } func index(of element: UInt16) -> String.UTF16View.Index? func index(where predicate: (UInt16) throws -> Bool) rethrows -> String.UTF16View.Index? func sorted() -> [UInt16] func sorted(by areInIncreasingOrder: (UInt16, UInt16) -> Bool) -> [UInt16] subscript(_ bounds: ClosedRange<String.UTF16View.Index>) -> String.UTF16View { get } func sort(_ isOrderedBefore: (UInt16, UInt16) -> Bool) -> [UInt16] func sort() -> [UInt16] func indexOf(_ element: UInt16) -> String.UTF16View.Index? var lazy: LazySequence<String.UTF16View> { get } func reversed() -> ReversedCollection<String.UTF16View> func reverse() -> ReversedCollection<String.UTF16View> func map<T>(_ transform: (UInt16) throws -> T) rethrows -> [T] func filter(_ isIncluded: (UInt16) throws -> Bool) rethrows -> [UInt16] var underestimatedCount: Int { get } func forEach(_ body: (UInt16) throws -> Void) rethrows func first(where predicate: (UInt16) throws -> Bool) rethrows -> UInt16? func dropFirst() -> String.UTF16View func dropLast() -> String.UTF16View func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (UInt16) throws -> Bool) rethrows -> [String.UTF16View] func enumerated() -> EnumeratedSequence<String.UTF16View> @warn_unqualified_access func min(by areInIncreasingOrder: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16? @warn_unqualified_access func max(by areInIncreasingOrder: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16? @warn_unqualified_access func min() -> UInt16? @warn_unqualified_access func max() -> UInt16? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with possiblePrefix: PossiblePrefix, by areEquivalent: (UInt16, UInt16) throws -> Bool) rethrows -> Bool func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence, by areEquivalent: (UInt16, UInt16) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence) -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence, by areInIncreasingOrder: (UInt16, UInt16) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence) -> Bool func contains(_ element: UInt16) -> Bool func contains(where predicate: (UInt16) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, UInt16) throws -> Result) rethrows -> Result func flatMap<SegmentOfResult : Sequence>(_ transform: (UInt16) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (UInt16) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<String.UTF16View> func minElement(_ isOrderedBefore: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16? func maxElement(_ isOrderedBefore: (UInt16, UInt16) throws -> Bool) rethrows -> UInt16? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (UInt16, UInt16) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence, isEquivalent isEquivalent: (UInt16, UInt16) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (UInt16, UInt16) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, UInt16) throws -> Result) rethrows -> Result func minElement() -> UInt16? func maxElement() -> UInt16? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt16>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_ other: OtherSequence) -> Bool } extension String.UTF16View { var lazy: LazyBidirectionalCollection<String.UTF16View> { get } } extension String.UTF16View { func makeIterator() -> IndexingIterator<String.UTF16View> } extension String.UTF16View { var isEmpty: Bool { get } var first: UInt16? { get } var underestimatedCount: Int { get } var count: Int { get } } extension String.UTF16View { var lazy: LazyCollection<String.UTF16View> { get } } extension String.UTF16View { func formIndex(after i: inout String.UTF16View.Index) func formIndex(_ i: inout String.UTF16View.Index, offsetBy n: Int) func formIndex(_ i: inout String.UTF16View.Index, offsetBy n: Int, limitedBy limit: String.UTF16View.Index) -> Bool } extension String.UTF16View { func formIndex(before i: inout String.UTF16View.Index) } extension String.UTF16View : CustomReflectable { var customMirror: Mirror { get } } extension String.UTF16View : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } | BidirectionalCollection, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, RandomAccessCollection |
Declaration | |
---|---|
From | subscript (_ i: String.UTF16View.Index) -> CodeUnit { get } |
To | subscript(_ i: String.UTF16View.Index) -> UTF16.CodeUnit { get } |
Declaration | |
---|---|
From | subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get } |
To | subscript(_ bounds: Range<String.UTF16View.Index>) -> String.UTF16View { get } |
Modified String.UTF16View.Index [struct]
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 |
To | struct Index { } extension String.UTF16View.Index : Strideable { init(_ offset: Int) func distance(to other: String.UTF16View.Index) -> Int func advanced(by n: Int) -> String.UTF16View.Index } extension String.UTF16View.Index { init?(_ utf8Index: String.UTF8Index, within utf16: String.UTF16View) init(_ unicodeScalarIndex: String.UnicodeScalarIndex, within utf16: String.UTF16View) init(_ characterIndex: String.Index, within utf16: String.UTF16View) func samePosition(in utf8: String.UTF8View) -> String.UTF8View.Index? func samePosition(in unicodeScalars: String.UnicodeScalarView) -> String.UnicodeScalarIndex? func samePosition(in characters: String) -> String.Index? func successor() -> String.UTF16View.Index func predecessor() -> String.UTF16View.Index func advancedBy(_ n: String.UTF16View.IndexDistance) -> String.UTF16View.Index func advancedBy(_ n: String.UTF16View.IndexDistance, limit limit: String.UTF16View.Index) -> String.UTF16View.Index func distanceTo(_ end: String.UTF16View.Index) -> String.UTF16View.IndexDistance } extension String.UTF16View.Index : Comparable { static func ==(_ lhs: String.UTF16View.Index, _ rhs: String.UTF16View.Index) -> Bool static func <(_ lhs: String.UTF16View.Index, _ rhs: String.UTF16View.Index) -> Bool } | Comparable, Strideable |
Modified String.UTF16View.Index.init(_: String.Index, within: String.UTF16View)
Declaration | |
---|---|
From | init(_ characterIndex: Index, within utf16: String.UTF16View) |
To | init(_ characterIndex: String.Index, within utf16: String.UTF16View) |
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.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 |
To | struct UTF8View : Collection, CustomStringConvertible, CustomDebugStringConvertible { struct Index { } typealias IndexDistance = Int var startIndex: String.UTF8View.Index { get } var endIndex: String.UTF8View.Index { get } func index(after i: String.UTF8View.Index) -> String.UTF8View.Index subscript(_ position: String.UTF8View.Index) -> UTF8.CodeUnit { get } subscript(_ bounds: Range<String.UTF8View.Index>) -> String.UTF8View { get } var description: String { get } var debugDescription: String { get } } extension String.UTF8View { func makeIterator() -> IndexingIterator<String.UTF8View> } extension String.UTF8View { mutating func popFirst() -> UInt8? func map<T>(_ transform: (UInt8) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> String.UTF8View func dropLast(_ n: Int) -> String.UTF8View func prefix(_ maxLength: Int) -> String.UTF8View func suffix(_ maxLength: Int) -> String.UTF8View func prefix(upTo end: String.UTF8View.Index) -> String.UTF8View func suffix(from start: String.UTF8View.Index) -> String.UTF8View func prefix(through position: String.UTF8View.Index) -> String.UTF8View func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (UInt8) throws -> Bool) rethrows -> [String.UTF8View] func split(separator separator: UInt8, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [String.UTF8View] mutating func removeFirst() -> UInt8 mutating func removeFirst(_ n: Int) typealias Generator = IndexingIterator<String.UTF8View> func generate() -> IndexingIterator<String.UTF8View> func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (UInt8) throws -> Bool) rethrows -> [String.UTF8View] func split(_ separator: UInt8, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [String.UTF8View] func index(of element: UInt8) -> String.UTF8View.Index? func index(where predicate: (UInt8) throws -> Bool) rethrows -> String.UTF8View.Index? func sorted() -> [UInt8] func sorted(by areInIncreasingOrder: (UInt8, UInt8) -> Bool) -> [UInt8] subscript(_ bounds: ClosedRange<String.UTF8View.Index>) -> String.UTF8View { get } func sort(_ isOrderedBefore: (UInt8, UInt8) -> Bool) -> [UInt8] func sort() -> [UInt8] func indexOf(_ element: UInt8) -> String.UTF8View.Index? var indices: DefaultIndices<String.UTF8View> { get } var lazy: LazySequence<String.UTF8View> { get } func map<T>(_ transform: (UInt8) throws -> T) rethrows -> [T] func filter(_ isIncluded: (UInt8) throws -> Bool) rethrows -> [UInt8] var underestimatedCount: Int { get } func forEach(_ body: (UInt8) throws -> Void) rethrows func first(where predicate: (UInt8) throws -> Bool) rethrows -> UInt8? func dropFirst() -> String.UTF8View func dropLast() -> String.UTF8View func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (UInt8) throws -> Bool) rethrows -> [String.UTF8View] func enumerated() -> EnumeratedSequence<String.UTF8View> @warn_unqualified_access func min(by areInIncreasingOrder: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8? @warn_unqualified_access func max(by areInIncreasingOrder: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8? @warn_unqualified_access func min() -> UInt8? @warn_unqualified_access func max() -> UInt8? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with possiblePrefix: PossiblePrefix, by areEquivalent: (UInt8, UInt8) throws -> Bool) rethrows -> Bool func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence, by areEquivalent: (UInt8, UInt8) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence) -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence, by areInIncreasingOrder: (UInt8, UInt8) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence) -> Bool func contains(_ element: UInt8) -> Bool func contains(where predicate: (UInt8) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, UInt8) throws -> Result) rethrows -> Result func reversed() -> [UInt8] func flatMap<SegmentOfResult : Sequence>(_ transform: (UInt8) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (UInt8) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<String.UTF8View> func minElement(_ isOrderedBefore: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8? func maxElement(_ isOrderedBefore: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8? func reverse() -> [UInt8] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (UInt8, UInt8) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence, isEquivalent isEquivalent: (UInt8, UInt8) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (UInt8, UInt8) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, UInt8) throws -> Result) rethrows -> Result func minElement() -> UInt8? func maxElement() -> UInt8? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_ other: OtherSequence) -> Bool } extension String.UTF8View { var isEmpty: Bool { get } var first: UInt8? { get } var underestimatedCount: Int { get } var count: Int { get } } extension String.UTF8View { var lazy: LazyCollection<String.UTF8View> { get } } extension String.UTF8View { func formIndex(after i: inout String.UTF8View.Index) func index(_ i: String.UTF8View.Index, offsetBy n: Int) -> String.UTF8View.Index func index(_ i: String.UTF8View.Index, offsetBy n: Int, limitedBy limit: String.UTF8View.Index) -> String.UTF8View.Index? func formIndex(_ i: inout String.UTF8View.Index, offsetBy n: Int) func formIndex(_ i: inout String.UTF8View.Index, offsetBy n: Int, limitedBy limit: String.UTF8View.Index) -> Bool func distance(from start: String.UTF8View.Index, to end: String.UTF8View.Index) -> Int } extension String.UTF8View : CustomReflectable { var customMirror: Mirror { get } } extension String.UTF8View : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } | Collection, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible |
Modified String.UTF8View.subscript(_: Range<String.UTF8View.Index>) -> String.UTF8View
Declaration | |
---|---|
From | subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get } |
To | subscript(_ bounds: Range<String.UTF8View.Index>) -> String.UTF8View { get } |
Declaration | |
---|---|
From | subscript (_ position: String.UTF8View.Index) -> CodeUnit { get } |
To | subscript(_ position: String.UTF8View.Index) -> UTF8.CodeUnit { get } |
Modified String.UTF8View.Index [struct]
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 |
To | struct Index { } extension String.UTF8View.Index { init?(_ utf16Index: String.UTF16Index, within utf8: String.UTF8View) init(_ unicodeScalarIndex: String.UnicodeScalarIndex, within utf8: String.UTF8View) init(_ characterIndex: String.Index, within utf8: String.UTF8View) func samePosition(in utf16: String.UTF16View) -> String.UTF16View.Index? func samePosition(in unicodeScalars: String.UnicodeScalarView) -> String.UnicodeScalarIndex? func samePosition(in characters: String) -> String.Index? func successor() -> String.UTF8View.Index func advancedBy(_ n: String.UTF8View.IndexDistance) -> String.UTF8View.Index func advancedBy(_ n: String.UTF8View.IndexDistance, limit limit: String.UTF8View.Index) -> String.UTF8View.Index func distanceTo(_ end: String.UTF8View.Index) -> String.UTF8View.IndexDistance } extension String.UTF8View.Index : Comparable { static func ==(_ lhs: String.UTF8View.Index, _ rhs: String.UTF8View.Index) -> Bool static func <(_ lhs: String.UTF8View.Index, _ rhs: String.UTF8View.Index) -> Bool } | Comparable |
Modified String.UTF8View.Index.init(_: String.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 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 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 |
To | struct UInt : UnsignedInteger, Comparable, Equatable { init() init(bigEndian value: UInt) init(littleEndian value: UInt) init(integerLiteral value: UInt) var bigEndian: UInt { get } var littleEndian: UInt { get } var byteSwapped: UInt { get } static var max: UInt { get } static var min: UInt { get } init(bitPattern pointer: OpaquePointer?) static func addWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func divideWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax init(_ value: UInt8) init?(exactly value: UInt8) init(_ value: Int8) init?(exactly value: Int8) init(_ value: UInt16) init?(exactly value: UInt16) init(_ value: Int16) init?(exactly value: Int16) init(_ value: UInt32) init?(exactly value: UInt32) init(_ value: Int32) init?(exactly value: Int32) init(_ value: UInt64) init?(exactly value: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ value: Int64) init?(exactly value: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ value: UInt) init?(exactly value: UInt) init(_ value: Int) init?(exactly value: Int) init(bitPattern bitPattern: Int) init(_ other: Float) init(_ other: Double) init?(_ text: String, radix radix: Int = default) init(bitPattern objectID: ObjectIdentifier) init(_ objectID: ObjectIdentifier) init<U>(bitPattern bitPattern: UnsafeMutablePointer<U>?) init<U>(bitPattern bitPattern: UnsafePointer<U>?) init(bitPattern bitPattern: UnsafeMutableRawPointer?) init(bitPattern bitPattern: UnsafeRawPointer?) func distance(to other: UInt) -> Int func advanced(by n: Int) -> UInt } extension UInt { init(_ value: CGFloat) } extension UInt { init(_ number: NSNumber) } extension UInt : Hashable { var hashValue: Int { get } } extension UInt : CustomStringConvertible { var description: String { get } } extension UInt : BitwiseOperations { static var allZeros: UInt { get } } extension UInt : CustomReflectable { var customMirror: Mirror { get } } extension UInt : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension UInt : CVarArg { } | BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, UnsignedInteger |
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 |
To | struct UInt16 : UnsignedInteger, Comparable, Equatable { init() init(bigEndian value: UInt16) init(littleEndian value: UInt16) init(integerLiteral value: UInt16) var bigEndian: UInt16 { get } var littleEndian: UInt16 { get } var byteSwapped: UInt16 { get } static var max: UInt16 { get } static var min: UInt16 { get } static func addWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func divideWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax init(_ value: UInt8) init?(exactly value: UInt8) init(_ value: Int8) init?(exactly value: Int8) init(_ value: UInt16) init?(exactly value: UInt16) init(_ value: Int16) init?(exactly value: Int16) init(_ value: UInt32) init?(exactly value: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ value: Int32) init?(exactly value: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ value: UInt64) init?(exactly value: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ value: Int64) init?(exactly value: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ value: UInt) init?(exactly value: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ value: Int) init?(exactly value: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: Int16) init(_ other: Float) init(_ other: Double) init?(_ text: String, radix radix: Int = default) func distance(to other: UInt16) -> Int func advanced(by n: Int) -> UInt16 } extension UInt16 { init(_ value: CGFloat) } extension UInt16 : Hashable { var hashValue: Int { get } } extension UInt16 : CustomStringConvertible { var description: String { get } } extension UInt16 : BitwiseOperations { static var allZeros: UInt16 { get } } extension UInt16 : CustomReflectable { var customMirror: Mirror { get } } extension UInt16 : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension UInt16 : CVarArg { } | BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, UnsignedInteger |
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 |
To | struct UInt32 : UnsignedInteger, Comparable, Equatable { init() init(bigEndian value: UInt32) init(littleEndian value: UInt32) init(integerLiteral value: UInt32) var bigEndian: UInt32 { get } var littleEndian: UInt32 { get } var byteSwapped: UInt32 { get } static var max: UInt32 { get } static var min: UInt32 { get } static func addWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func divideWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax init(_ value: UInt8) init?(exactly value: UInt8) init(_ value: Int8) init?(exactly value: Int8) init(_ value: UInt16) init?(exactly value: UInt16) init(_ value: Int16) init?(exactly value: Int16) init(_ value: UInt32) init?(exactly value: UInt32) init(_ value: Int32) init?(exactly value: Int32) init(_ value: UInt64) init?(exactly value: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ value: Int64) init?(exactly value: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ value: UInt) init?(exactly value: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ value: Int) init?(exactly value: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: Int32) init(_ other: Float) init(_ other: Double) init?(_ text: String, radix radix: Int = default) init(_ v: UnicodeScalar) func distance(to other: UInt32) -> Int func advanced(by n: Int) -> UInt32 } extension UInt32 { init(_ value: CGFloat) } extension UInt32 : Hashable { var hashValue: Int { get } } extension UInt32 : CustomStringConvertible { var description: String { get } } extension UInt32 : BitwiseOperations { static var allZeros: UInt32 { get } } extension UInt32 : CustomReflectable { var customMirror: Mirror { get } } extension UInt32 : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension UInt32 : CVarArg { } | BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, UnsignedInteger |
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 |
To | struct UInt64 : UnsignedInteger, Comparable, Equatable { init() init(bigEndian value: UInt64) init(littleEndian value: UInt64) init(integerLiteral value: UInt64) var bigEndian: UInt64 { get } var littleEndian: UInt64 { get } var byteSwapped: UInt64 { get } static var max: UInt64 { get } static var min: UInt64 { get } static func addWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func divideWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax init(_ value: UInt8) init?(exactly value: UInt8) init(_ value: Int8) init?(exactly value: Int8) init(_ value: UInt16) init?(exactly value: UInt16) init(_ value: Int16) init?(exactly value: Int16) init(_ value: UInt32) init?(exactly value: UInt32) init(_ value: Int32) init?(exactly value: Int32) init(_ value: UInt64) init?(exactly value: UInt64) init(_ value: Int64) init?(exactly value: Int64) init(_ value: UInt) init?(exactly value: UInt) init(_ value: Int) init?(exactly value: Int) init(bitPattern bitPattern: Int64) init(_ other: Float) init(_ other: Double) init?(_ text: String, radix radix: Int = default) init(_ v: UnicodeScalar) func distance(to other: UInt64) -> Int func advanced(by n: Int) -> UInt64 } extension UInt64 { init(_ value: CGFloat) } extension UInt64 : Hashable { var hashValue: Int { get } } extension UInt64 : CustomStringConvertible { var description: String { get } } extension UInt64 : BitwiseOperations { static var allZeros: UInt64 { get } } extension UInt64 : CustomReflectable { var customMirror: Mirror { get } } extension UInt64 : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension UInt64 : CVarArg { } | BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, UnsignedInteger |
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 |
To | struct UInt8 : UnsignedInteger, Comparable, Equatable { init() init(integerLiteral value: UInt8) static var max: UInt8 { get } static var min: UInt8 { get } static func addWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func divideWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax init(_ value: UInt8) init?(exactly value: UInt8) init(_ value: Int8) init?(exactly value: Int8) init(_ value: UInt16) init?(exactly value: UInt16) init(truncatingBitPattern truncatingBitPattern: UInt16) init(_ value: Int16) init?(exactly value: Int16) init(truncatingBitPattern truncatingBitPattern: Int16) init(_ value: UInt32) init?(exactly value: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ value: Int32) init?(exactly value: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ value: UInt64) init?(exactly value: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ value: Int64) init?(exactly value: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ value: UInt) init?(exactly value: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ value: Int) init?(exactly value: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: Int8) init(_ other: Float) init(_ other: Double) init?(_ text: String, radix radix: Int = default) init(ascii v: UnicodeScalar) func distance(to other: UInt8) -> Int func advanced(by n: Int) -> UInt8 } extension UInt8 { init(_ value: CGFloat) } extension UInt8 : Hashable { var hashValue: Int { get } } extension UInt8 : CustomStringConvertible { var description: String { get } } extension UInt8 : BitwiseOperations { static var allZeros: UInt8 { get } } extension UInt8 : CustomReflectable { var customMirror: Mirror { get } } extension UInt8 : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension UInt8 : CVarArg { } | BitwiseOperations, CVarArg, Comparable, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, Hashable, UnsignedInteger |
Modified UnicodeDecodingResult [enum]
Declaration | Protocols | |
---|---|---|
From | enum UnicodeDecodingResult { case Result(UnicodeScalar) case EmptyInput case Error @warn_unused_result func isEmptyInput() -> Bool } | -- |
To | enum UnicodeDecodingResult : Equatable { case scalarValue(UnicodeScalar) case emptyInput case error static func ==(_ lhs: UnicodeDecodingResult, _ rhs: UnicodeDecodingResult) -> Bool } | Equatable |
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 |
To | struct UnicodeScalar : ExpressibleByUnicodeScalarLiteral { var value: UInt32 { get } init(unicodeScalarLiteral value: UnicodeScalar) init?(_ v: UInt32) init?(_ v: UInt16) init(_ v: UInt8) init(_ v: UnicodeScalar) func escaped(asASCII forceASCII: Bool) -> String var isASCII: Bool { get } init?(_ v: Int) init() func escape(asASCII forceASCII: Bool) -> String } extension UnicodeScalar : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension UnicodeScalar : TextOutputStreamable { func write<Target : TextOutputStream>(to target: inout Target) } extension UnicodeScalar : Comparable { static func <(_ lhs: UnicodeScalar, _ rhs: UnicodeScalar) -> Bool } extension UnicodeScalar : LosslessStringConvertible { init?(_ description: String) } extension UnicodeScalar : Hashable { var hashValue: Int { get } } extension UnicodeScalar : CustomReflectable { var customMirror: Mirror { get } } extension UnicodeScalar : Equatable { static func ==(_ lhs: UnicodeScalar, _ rhs: UnicodeScalar) -> Bool } extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } | Comparable, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, CustomStringConvertible, Equatable, ExpressibleByUnicodeScalarLiteral, Hashable, LosslessStringConvertible, TextOutputStreamable |
Modified UnicodeScalar.init(_: UInt32)
Declaration | |
---|---|
From | init(_ v: UInt32) |
To | init?(_ v: UInt32) |
Modified UnicodeScalar.init(_: Int)
Declaration | |
---|---|
From | init(_ v: Int) |
To | init?(_ v: Int) |
Modified UnicodeScalar.init(_: UInt16)
Declaration | |
---|---|
From | init(_ v: UInt16) |
To | init?(_ v: UInt16) |
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 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.Index, within: String.UnicodeScalarView)
Declaration | |
---|---|
From | init(_ characterIndex: Index, within unicodeScalars: String.UnicodeScalarView) |
To | init(_ characterIndex: String.Index, 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> } |
To | struct Unmanaged<Instance : AnyObject> { static func fromOpaque(_ value: UnsafeRawPointer) -> Unmanaged<Instance> func toOpaque() -> UnsafeMutableRawPointer static func passRetained(_ value: Instance) -> Unmanaged<Instance> static func passUnretained(_ value: Instance) -> Unmanaged<Instance> func takeUnretainedValue() -> Instance func takeRetainedValue() -> Instance func retain() -> Unmanaged<Instance> func release() func autorelease() -> Unmanaged<Instance> static func fromOpaque(_ value: OpaquePointer) -> Unmanaged<Instance> func toOpaque() -> OpaquePointer } |
Deprecation | |
---|---|
From | iOS 9.3 |
To | -- |
Declaration | |
---|---|
From | @warn_unused_result static func passRetained(_ value: Instance) -> Unmanaged<Instance> |
To | static func passRetained(_ value: Instance) -> Unmanaged<Instance> |
Declaration | |
---|---|
From | @warn_unused_result static func passUnretained(_ value: Instance) -> Unmanaged<Instance> |
To | static func passUnretained(_ value: Instance) -> Unmanaged<Instance> |
Deprecation | |
---|---|
From | iOS 9.3 |
To | -- |
Declaration | |
---|---|
From | @warn_unused_result func takeRetainedValue() -> Instance |
To | func takeRetainedValue() -> Instance |
Declaration | |
---|---|
From | @warn_unused_result func takeUnretainedValue() -> Instance |
To | func takeUnretainedValue() -> Instance |
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 |
To | struct UnsafeBufferPointer<Element> : Indexable, Collection, RandomAccessCollection { typealias Index = Int typealias IndexDistance = Int typealias Iterator = IndexingIterator<UnsafeBufferPointer<Element>> var startIndex: Int { get } var endIndex: Int { get } func index(after i: Int) -> Int func formIndex(after i: inout Int) func index(before i: Int) -> Int func formIndex(before i: inout Int) func index(_ i: Int, offsetBy n: Int) -> Int func index(_ i: Int, offsetBy n: Int, limitedBy limit: Int) -> Int? func distance(from start: Int, to end: Int) -> Int typealias Indices = CountableRange<Int> var indices: UnsafeBufferPointer.Indices { get } subscript(_ i: Int) -> Element { get } subscript(_ bounds: Range<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>> { get } init(start start: UnsafePointer<Element>?, count count: Int) func makeIterator() -> UnsafeBufferPointerIterator<Element> var baseAddress: UnsafePointer<Element>? { get } var count: Int { get } func dropLast(_ n: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>> func suffix(_ maxLength: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>> func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>> func prefix(_ maxLength: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>> func prefix(upTo end: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>> func suffix(from start: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>> func prefix(through position: Int) -> RandomAccessSlice<UnsafeBufferPointer<Element>> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [RandomAccessSlice<UnsafeBufferPointer<Element>>] typealias Generator = IndexingIterator<UnsafeBufferPointer<Element>> func generate() -> IndexingIterator<UnsafeBufferPointer<Element>> func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [RandomAccessSlice<UnsafeBufferPointer<Element>>] var last: Element? { get } func index(where predicate: (Element) throws -> Bool) rethrows -> Int? func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element] subscript(_ bounds: ClosedRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>> { get } subscript(_ bounds: CountableRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>> { get } subscript(_ bounds: CountableClosedRange<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>> { get } func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element] func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Int? var lazy: LazySequence<UnsafeBufferPointer<Element>> { get } var indices: CountableRange<Int> { get } func reversed() -> ReversedRandomAccessCollection<UnsafeBufferPointer<Element>> func reverse() -> ReversedRandomAccessCollection<UnsafeBufferPointer<Element>> func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element] var underestimatedCount: Int { get } func forEach(_ body: (Element) throws -> Void) rethrows func first(where predicate: (Element) throws -> Bool) rethrows -> Element? func dropFirst() -> RandomAccessSlice<UnsafeBufferPointer<Element>> func dropLast() -> RandomAccessSlice<UnsafeBufferPointer<Element>> func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [RandomAccessSlice<UnsafeBufferPointer<Element>>] func enumerated() -> EnumeratedSequence<UnsafeBufferPointer<Element>> @warn_unqualified_access func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<UnsafeBufferPointer<Element>> func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result } extension UnsafeBufferPointer { init(_ audioBuffer: AudioBuffer) } extension UnsafeBufferPointer { var lazy: LazyRandomAccessCollection<UnsafeBufferPointer<Element>> { get } } extension UnsafeBufferPointer { subscript(_ bounds: Range<Int>) -> RandomAccessSlice<UnsafeBufferPointer<Element>> { get } } extension UnsafeBufferPointer { var lazy: LazyBidirectionalCollection<UnsafeBufferPointer<Element>> { get } } extension UnsafeBufferPointer { var isEmpty: Bool { get } var first: Element? { get } var underestimatedCount: Int { get } var count: Int { get } } extension UnsafeBufferPointer { func formIndex(_ i: inout Int, offsetBy n: Int) func formIndex(_ i: inout Int, offsetBy n: Int, limitedBy limit: Int) -> Bool } extension UnsafeBufferPointer { var lazy: LazyCollection<UnsafeBufferPointer<Element>> { get } } extension UnsafeBufferPointer : CustomDebugStringConvertible { var debugDescription: String { get } } extension UnsafeBufferPointer where Element : Sequence { func joined() -> FlattenSequence<UnsafeBufferPointer<Element>> func flatten() -> FlattenSequence<UnsafeBufferPointer<Element>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<UnsafeBufferPointer<Element>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<UnsafeBufferPointer<Element>> } extension UnsafeBufferPointer where Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } extension UnsafeBufferPointer where Element : Comparable { func sorted() -> [Element] func sort() -> [Element] @warn_unqualified_access func min() -> Element? @warn_unqualified_access func max() -> Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool func minElement() -> Element? func maxElement() -> Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } extension UnsafeBufferPointer where Element : Equatable { func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [RandomAccessSlice<UnsafeBufferPointer<Element>>] func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [RandomAccessSlice<UnsafeBufferPointer<Element>>] func index(of element: Element) -> Int? func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>] func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } extension UnsafeBufferPointer where Element : BidirectionalCollection { func joined() -> FlattenBidirectionalCollection<UnsafeBufferPointer<Element>> func flatten() -> FlattenBidirectionalCollection<UnsafeBufferPointer<Element>> } extension UnsafeBufferPointer where Element : Collection { func joined() -> FlattenCollection<UnsafeBufferPointer<Element>> func flatten() -> FlattenCollection<UnsafeBufferPointer<Element>> } | Collection, CustomDebugStringConvertible, Indexable, RandomAccessCollection |
Modified UnsafeBufferPointer.baseAddress
Declaration | |
---|---|
From | var baseAddress: UnsafePointer<Element> { get } |
To | var baseAddress: UnsafePointer<Element>? { get } |
Declaration | |
---|---|
From | subscript (_ i: Int) -> Element { get } |
To | subscript(_ i: Int) -> Element { get } |
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 |
To | struct UnsafeMutableBufferPointer<Element> : MutableIndexable, MutableCollection, RandomAccessCollection { typealias Index = Int typealias IndexDistance = Int typealias Iterator = IndexingIterator<UnsafeMutableBufferPointer<Element>> var startIndex: Int { get } var endIndex: Int { get } func index(after i: Int) -> Int func formIndex(after i: inout Int) func index(before i: Int) -> Int func formIndex(before i: inout Int) func index(_ i: Int, offsetBy n: Int) -> Int func index(_ i: Int, offsetBy n: Int, limitedBy limit: Int) -> Int? func distance(from start: Int, to end: Int) -> Int typealias Indices = CountableRange<Int> var indices: UnsafeMutableBufferPointer.Indices { get } subscript(_ i: Int) -> Element { get nonmutating set } subscript(_ bounds: Range<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> init(start start: UnsafeMutablePointer<Element>?, count count: Int) func makeIterator() -> UnsafeBufferPointerIterator<Element> var baseAddress: UnsafeMutablePointer<Element>? { get } var count: Int { get } func dropLast(_ n: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> func suffix(_ maxLength: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] func dropFirst(_ n: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> func prefix(_ maxLength: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> func prefix(upTo end: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> func suffix(from start: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> func prefix(through position: Int) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>] typealias Generator = IndexingIterator<UnsafeMutableBufferPointer<Element>> func generate() -> IndexingIterator<UnsafeMutableBufferPointer<Element>> func underestimateCount() -> Int func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, whereSeparator isSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>] var last: Element? { get } func index(where predicate: (Element) throws -> Bool) rethrows -> Int? mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int mutating func partition(by belongsInSecondPartition: (Element) throws -> Bool) rethrows -> Int func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element] mutating func sort(by areInIncreasingOrder: (Element, Element) -> Bool) subscript(_ bounds: ClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> { get } subscript(_ bounds: CountableRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> { get } subscript(_ bounds: CountableClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> { get } subscript(_ bounds: ClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> subscript(_ bounds: CountableRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> subscript(_ bounds: CountableClosedRange<Int>) -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> mutating func partition(isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int mutating func partition(_ range: Range<Int>, isOrderedBefore isOrderedBefore: (Element, Element) -> Bool) -> Int func sort(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element] mutating func sortInPlace(_ isOrderedBefore: (Element, Element) -> Bool) func indexOf(_ predicate: (Element) throws -> Bool) rethrows -> Int? var lazy: LazySequence<UnsafeMutableBufferPointer<Element>> { get } subscript(_ bounds: Range<Int>) -> MutableSlice<UnsafeMutableBufferPointer<Element>> var indices: CountableRange<Int> { get } func reversed() -> ReversedRandomAccessCollection<UnsafeMutableBufferPointer<Element>> func reverse() -> ReversedRandomAccessCollection<UnsafeMutableBufferPointer<Element>> func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element] var underestimatedCount: Int { get } func forEach(_ body: (Element) throws -> Void) rethrows func first(where predicate: (Element) throws -> Bool) rethrows -> Element? func dropFirst() -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> func dropLast() -> MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>> func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Element) throws -> Bool) rethrows -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>] func enumerated() -> EnumeratedSequence<UnsafeMutableBufferPointer<Element>> @warn_unqualified_access func min(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? @warn_unqualified_access func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Bool func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<UnsafeMutableBufferPointer<Element>> func minElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func maxElement(_ isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isEquivalent isEquivalent: (Element, Element) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: (Element, Element) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, Element) throws -> Result) rethrows -> Result } extension UnsafeMutableBufferPointer { init(_ audioBuffer: AudioBuffer) } extension UnsafeMutableBufferPointer { var lazy: LazyRandomAccessCollection<UnsafeMutableBufferPointer<Element>> { get } } extension UnsafeMutableBufferPointer { var lazy: LazyBidirectionalCollection<UnsafeMutableBufferPointer<Element>> { get } } extension UnsafeMutableBufferPointer { var isEmpty: Bool { get } var first: Element? { get } var underestimatedCount: Int { get } var count: Int { get } } extension UnsafeMutableBufferPointer { func formIndex(_ i: inout Int, offsetBy n: Int) func formIndex(_ i: inout Int, offsetBy n: Int, limitedBy limit: Int) -> Bool } extension UnsafeMutableBufferPointer { var lazy: LazyCollection<UnsafeMutableBufferPointer<Element>> { get } } extension UnsafeMutableBufferPointer : CustomDebugStringConvertible { var debugDescription: String { get } } extension UnsafeMutableBufferPointer where Element : Sequence { func joined() -> FlattenSequence<UnsafeMutableBufferPointer<Element>> func flatten() -> FlattenSequence<UnsafeMutableBufferPointer<Element>> func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator separator: Separator) -> JoinedSequence<UnsafeMutableBufferPointer<Element>> func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> JoinedSequence<UnsafeMutableBufferPointer<Element>> } extension UnsafeMutableBufferPointer where Element == String { func joined(separator separator: String = default) -> String func joinWithSeparator(_ separator: String) -> String } extension UnsafeMutableBufferPointer where Element : Comparable { func sorted() -> [Element] func sorted() -> [Element] mutating func sort() mutating func partition() -> Int mutating func partition(_ range: Range<Int>) -> Int func sort() -> [Element] mutating func sortInPlace() @warn_unqualified_access func min() -> Element? @warn_unqualified_access func max() -> Element? func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool func minElement() -> Element? func maxElement() -> Element? func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(_ possiblePrefix: PossiblePrefix) -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } extension UnsafeMutableBufferPointer where Element : Equatable { func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>] func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [MutableRandomAccessSlice<UnsafeMutableBufferPointer<Element>>] func index(of element: Element) -> Int? func split(separator separator: Element, maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default) -> [AnySequence<Element>] func split(_ separator: Element, maxSplit maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default) -> [AnySequence<Element>] func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with possiblePrefix: PossiblePrefix) -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_ other: OtherSequence) -> Bool } extension UnsafeMutableBufferPointer where Element : BidirectionalCollection { func joined() -> FlattenBidirectionalCollection<UnsafeMutableBufferPointer<Element>> func flatten() -> FlattenBidirectionalCollection<UnsafeMutableBufferPointer<Element>> } extension UnsafeMutableBufferPointer where Element : Collection { func joined() -> FlattenCollection<UnsafeMutableBufferPointer<Element>> func flatten() -> FlattenCollection<UnsafeMutableBufferPointer<Element>> } | CustomDebugStringConvertible, MutableCollection, MutableIndexable, RandomAccessCollection |
Declaration | |
---|---|
From | var baseAddress: UnsafeMutablePointer<Element> { get } |
To | var baseAddress: UnsafeMutablePointer<Element>? { get } |
Declaration | |
---|---|
From | subscript (_ i: Int) -> Element { get nonmutating set } |
To | subscript(_ i: Int) -> Element { get nonmutating set } |
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 |
To | struct UnsafeMutablePointer<Pointee> : Strideable, Hashable { typealias Distance = Int init(_ from: OpaquePointer) init?(_ from: OpaquePointer?) init?(bitPattern bitPattern: Int) init?(bitPattern bitPattern: UInt) init(_ other: UnsafeMutablePointer<Pointee>) init?(_ other: UnsafeMutablePointer<Pointee>?) init(mutating other: UnsafePointer<Pointee>) init?(mutating other: UnsafePointer<Pointee>?) static func allocate(capacity count: Int) -> UnsafeMutablePointer<Pointee> func deallocate(capacity capacity: Int) var pointee: Pointee { get nonmutating set } func initialize(to newValue: Pointee, count count: Int = default) func move() -> Pointee func assign(from source: UnsafePointer<Pointee>, count count: Int) func moveInitialize(from source: UnsafeMutablePointer<Pointee>, count count: Int) func initialize(from source: UnsafePointer<Pointee>, count count: Int) func initialize<C : Collection where C.Iterator.Element == Pointee>(from source: C) func moveAssign(from source: UnsafeMutablePointer<Pointee>, count count: Int) func deinitialize(count count: Int = default) -> UnsafeMutableRawPointer func withMemoryRebound<T, Result>(to to: T.Type, capacity count: Int, _ body: (UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result subscript(_ i: Int) -> Pointee { get nonmutating set } var hashValue: Int { get } func successor() -> UnsafeMutablePointer<Pointee> func predecessor() -> UnsafeMutablePointer<Pointee> func distance(to x: UnsafeMutablePointer<Pointee>) -> Int func advanced(by n: Int) -> UnsafeMutablePointer<Pointee> init<U>(_ from: UnsafeMutablePointer<U>) init?<U>(_ from: UnsafeMutablePointer<U>?) init<U>(_ from: UnsafePointer<U>) init?<U>(_ from: UnsafePointer<U>?) init(_ from: UnsafePointer<Pointee>) init?(_ from: UnsafePointer<Pointee>?) typealias Memory = Pointee init() static func alloc(_ num: Int) -> UnsafeMutablePointer<Pointee> init(allocatingCapacity allocatingCapacity: Int) func dealloc(_ num: Int) func deallocateCapacity(_ num: Int) var memory: Pointee func initialize(_ newvalue: Pointee) func initialize(with newvalue: Pointee, count count: Int = default) func destroy() func destroy(_ count: Int) func initializeFrom(_ source: UnsafePointer<Pointee>, count count: Int) func assignFrom(_ source: UnsafePointer<Pointee>, count count: Int) func assignBackwardFrom(_ source: UnsafePointer<Pointee>, count count: Int) func moveInitializeFrom(_ source: UnsafePointer<Pointee>, count count: Int) func moveInitializeBackwardFrom(_ source: UnsafePointer<Pointee>, count count: Int) func moveAssignFrom(_ source: UnsafePointer<Pointee>, count count: Int) func stride(to end: UnsafeMutablePointer<Pointee>, by stride: Int) -> StrideTo<UnsafeMutablePointer<Pointee>> @warn_unqualified_access func stride(through end: UnsafeMutablePointer<Pointee>, by stride: Int) -> StrideThrough<UnsafeMutablePointer<Pointee>> } extension UnsafeMutablePointer : CustomDebugStringConvertible { var debugDescription: String { get } } extension UnsafeMutablePointer : CustomReflectable { var customMirror: Mirror { get } } extension UnsafeMutablePointer : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension UnsafeMutablePointer : CVarArg { } | CVarArg, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, Hashable, Strideable | Pointee |
Declaration | |
---|---|
From | init(bitPattern bitPattern: UInt) |
To | init?(bitPattern bitPattern: UInt) |
Declaration | |
---|---|
From | init(bitPattern bitPattern: Int) |
To | init?(bitPattern bitPattern: Int) |
Declaration | |
---|---|
From | @warn_unused_result func move() -> Memory |
To | func move() -> Pointee |
Declaration | |
---|---|
From | func predecessor() -> UnsafeMutablePointer<Memory> |
To | func predecessor() -> UnsafeMutablePointer<Pointee> |
Declaration | |
---|---|
From | subscript (_ i: Int) -> Memory { get nonmutating set } |
To | subscript(_ i: Int) -> Pointee { get nonmutating set } |
Declaration | |
---|---|
From | func successor() -> UnsafeMutablePointer<Memory> |
To | func successor() -> UnsafeMutablePointer<Pointee> |
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 |
To | struct UnsafePointer<Pointee> : Strideable, Hashable { typealias Distance = Int init(_ from: OpaquePointer) init?(_ from: OpaquePointer?) init?(bitPattern bitPattern: Int) init?(bitPattern bitPattern: UInt) init(_ other: UnsafePointer<Pointee>) init?(_ other: UnsafePointer<Pointee>?) init(_ other: UnsafeMutablePointer<Pointee>) init?(_ other: UnsafeMutablePointer<Pointee>?) var pointee: Pointee { get } func withMemoryRebound<T, Result>(to to: T.Type, capacity count: Int, _ body: (UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result subscript(_ i: Int) -> Pointee { get } var hashValue: Int { get } func successor() -> UnsafePointer<Pointee> func predecessor() -> UnsafePointer<Pointee> func distance(to x: UnsafePointer<Pointee>) -> Int func advanced(by n: Int) -> UnsafePointer<Pointee> init<U>(_ from: UnsafeMutablePointer<U>) init?<U>(_ from: UnsafeMutablePointer<U>?) init<U>(_ from: UnsafePointer<U>) init?<U>(_ from: UnsafePointer<U>?) typealias Memory = Pointee init() var memory: Pointee { get } func stride(to end: UnsafePointer<Pointee>, by stride: Int) -> StrideTo<UnsafePointer<Pointee>> @warn_unqualified_access func stride(through end: UnsafePointer<Pointee>, by stride: Int) -> StrideThrough<UnsafePointer<Pointee>> } extension UnsafePointer : CustomDebugStringConvertible { var debugDescription: String { get } } extension UnsafePointer : CustomReflectable { var customMirror: Mirror { get } } extension UnsafePointer : CustomPlaygroundQuickLookable { var customPlaygroundQuickLook: PlaygroundQuickLook { get } } extension UnsafePointer : CVarArg { } | CVarArg, CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, Hashable, 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) |
Declaration | |
---|---|
From | func predecessor() -> UnsafePointer<Memory> |
To | func predecessor() -> UnsafePointer<Pointee> |
Declaration | |
---|---|
From | subscript (_ i: Int) -> Memory { get } |
To | subscript(_ i: Int) -> Pointee { get } |
Declaration | |
---|---|
From | func successor() -> UnsafePointer<Memory> |
To | func successor() -> UnsafePointer<Pointee> |
Modified UTF16 [struct]
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 |
To | struct UTF16 : UnicodeCodec { typealias CodeUnit = UInt16 init() mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> UnicodeDecodingResult static func encode(_ input: UnicodeScalar, into processCodeUnit: (UTF16.CodeUnit) -> Swift.Void) static func width(_ x: UnicodeScalar) -> Int static func leadSurrogate(_ x: UnicodeScalar) -> UTF16.CodeUnit static func trailSurrogate(_ x: UnicodeScalar) -> UTF16.CodeUnit static func isLeadSurrogate(_ x: UTF16.CodeUnit) -> Bool static func isTrailSurrogate(_ x: UTF16.CodeUnit) -> Bool static func transcodedLength<Input, Encoding where Input : IteratorProtocol, Encoding : UnicodeCodec, Encoding.CodeUnit == Input.Element>(of input: Input, decodedAs sourceEncoding: Encoding.Type, repairingIllFormedSequences repairingIllFormedSequences: Bool) -> (count: Int, isASCII: Bool)? static func measure<Encoding, Input where Encoding : UnicodeCodec, Input : IteratorProtocol, Encoding.CodeUnit == Input.Element>(_ _: Encoding.Type, input input: Input, repairIllFormedSequences repairIllFormedSequences: Bool) -> (Int, Bool)? static func encode(_ input: UnicodeScalar, output put: (UInt16) -> Void) } | UnicodeCodec |
Modified UTF16.isLeadSurrogate(_: UTF16.CodeUnit) -> Bool [static]
Declaration | |
---|---|
From | @warn_unused_result static func isLeadSurrogate(_ x: CodeUnit) -> Bool |
To | static func isLeadSurrogate(_ x: UTF16.CodeUnit) -> Bool |
Modified UTF16.isTrailSurrogate(_: UTF16.CodeUnit) -> Bool [static]
Declaration | |
---|---|
From | @warn_unused_result static func isTrailSurrogate(_ x: CodeUnit) -> Bool |
To | static func isTrailSurrogate(_ x: UTF16.CodeUnit) -> Bool |
Modified UTF16.leadSurrogate(_: UnicodeScalar) -> UTF16.CodeUnit [static]
Declaration | |
---|---|
From | @warn_unused_result static func leadSurrogate(_ x: UnicodeScalar) -> CodeUnit |
To | static func leadSurrogate(_ x: UnicodeScalar) -> UTF16.CodeUnit |
Modified UTF16.trailSurrogate(_: UnicodeScalar) -> UTF16.CodeUnit [static]
Declaration | |
---|---|
From | @warn_unused_result static func trailSurrogate(_ x: UnicodeScalar) -> CodeUnit |
To | static func trailSurrogate(_ x: UnicodeScalar) -> UTF16.CodeUnit |
Modified UTF16.width(_: UnicodeScalar) -> Int [static]
Declaration | |
---|---|
From | @warn_unused_result static func width(_ x: UnicodeScalar) -> Int |
To | static func width(_ x: UnicodeScalar) -> Int |
Modified UTF32 [struct]
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 |
To | struct UTF32 : UnicodeCodec { typealias CodeUnit = UInt32 init() mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> UnicodeDecodingResult static func encode(_ input: UnicodeScalar, into processCodeUnit: (UTF32.CodeUnit) -> Swift.Void) static func encode(_ input: UnicodeScalar, output put: (UInt32) -> Void) } | UnicodeCodec |
Modified UTF8 [struct]
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 |
To | struct UTF8 : UnicodeCodec { typealias CodeUnit = UInt8 init() mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> UnicodeDecodingResult static func encode(_ input: UnicodeScalar, into processCodeUnit: (UTF8.CodeUnit) -> Swift.Void) static func isContinuation(_ byte: UTF8.CodeUnit) -> Bool static func encode(_ input: UnicodeScalar, output put: (UInt8) -> Void) } | UnicodeCodec |
Modified UTF8.isContinuation(_: UTF8.CodeUnit) -> Bool [static]
Declaration | |
---|---|
From | @warn_unused_result static func isContinuation(_ byte: CodeUnit) -> Bool |
To | static func isContinuation(_ byte: UTF8.CodeUnit) -> Bool |
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 |
To | struct Zip2Sequence<Sequence1 : Sequence, Sequence2 : Sequence> : Sequence { typealias Stream1 = Sequence1.Iterator typealias Stream2 = Sequence2.Iterator typealias Iterator = Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator> typealias Generator = Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator> func makeIterator() -> Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator> init(_ sequence1: Sequence1, _ sequence2: Sequence2) func sorted(by areInIncreasingOrder: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) -> Bool) -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)] func sort(_ isOrderedBefore: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) -> Bool) -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)] var lazy: LazySequence<Zip2Sequence<Sequence1, Sequence2>> { get } func map<T>(_ transform: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> T) rethrows -> [T] func filter(_ isIncluded: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)] func suffix(_ maxLength: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)> func split(maxSplits maxSplits: Int = default, omittingEmptySubsequences omittingEmptySubsequences: Bool = default, whereSeparator isSeparator: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>] var underestimatedCount: Int { get } func forEach(_ body: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Void) rethrows func first(where predicate: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)? func dropFirst(_ n: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)> func dropLast(_ n: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)> func prefix(_ maxLength: Int) -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)> func dropFirst() -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)> func dropLast() -> AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)> func generate() -> Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator> func underestimateCount() -> Int func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, isSeparator isSeparator: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>] func enumerated() -> EnumeratedSequence<Zip2Sequence<Sequence1, Sequence2>> @warn_unqualified_access func min(by areInIncreasingOrder: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)? @warn_unqualified_access func max(by areInIncreasingOrder: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)? func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(with possiblePrefix: PossiblePrefix, by areEquivalent: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_ other: OtherSequence, by areEquivalent: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_ other: OtherSequence, by areInIncreasingOrder: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool func contains(where predicate: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Result) rethrows -> Result func reversed() -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)] func flatMap<SegmentOfResult : Sequence>(_ transform: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element] func flatMap<ElementOfResult>(_ transform: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func enumerate() -> EnumeratedSequence<Zip2Sequence<Sequence1, Sequence2>> func minElement(_ isOrderedBefore: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)? func maxElement(_ isOrderedBefore: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> (Sequence1.Iterator.Element, Sequence2.Iterator.Element)? func reverse() -> [(Sequence1.Iterator.Element, Sequence2.Iterator.Element)] func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_ possiblePrefix: PossiblePrefix, isEquivalent isEquivalent: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_ other: OtherSequence, isEquivalent isEquivalent: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (Sequence1.Iterator.Element, Sequence2.Iterator.Element)>(_ other: OtherSequence, isOrderedBefore isOrderedBefore: ((Sequence1.Iterator.Element, Sequence2.Iterator.Element), (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Bool) rethrows -> Bool func contains(_ predicate: (Sequence1.Iterator.Element, Sequence2.Iterator.Element) throws -> Bool) rethrows -> Bool func reduce<Result>(_ initial: Result, combine combine: (Result, (Sequence1.Iterator.Element, Sequence2.Iterator.Element)) throws -> Result) rethrows -> Result } | Sequence | Sequence1 : Sequence, Sequence2 : Sequence |
Modified !=(_: 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 !=(_: _OptionalNilComparisonType, _: T?) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func !=<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool |
To | func !=<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
To | func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
Modified !=(_: ContiguousArray<Element>, _: ContiguousArray<Element>) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func !=<Element : Equatable>(_ lhs: ContiguousArray<Element>, _ rhs: ContiguousArray<Element>) -> Bool |
To | func !=<Element : Equatable>(_ lhs: ContiguousArray<Element>, _ rhs: ContiguousArray<Element>) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
To | func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
Modified !=(_: ArraySlice<Element>, _: ArraySlice<Element>) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func !=<Element : Equatable>(_ lhs: ArraySlice<Element>, _ rhs: ArraySlice<Element>) -> Bool |
To | func !=<Element : Equatable>(_ lhs: ArraySlice<Element>, _ rhs: ArraySlice<Element>) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func !=<A : Equatable, B : Equatable, C : Equatable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
To | func !=<A : Equatable, B : Equatable, C : Equatable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
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 !=(_: T?, _: _OptionalNilComparisonType) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func !=<T>(_ lhs: T?, _ rhs: _OptionalNilComparisonType) -> Bool |
To | func !=<T>(_ lhs: T?, _ rhs: _OptionalNilComparisonType) -> Bool |
Modified !=(_: [Element], _: [Element]) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func !=<Element : Equatable>(_ lhs: [Element], _ rhs: [Element]) -> Bool |
To | func !=<Element : Equatable>(_ lhs: [Element], _ rhs: [Element]) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
To | func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func !==(_ lhs: AnyObject?, _ rhs: AnyObject?) -> Bool |
To | func !==(_ lhs: AnyObject?, _ rhs: AnyObject?) -> Bool |
Modified &=(_: UInt16, _: UInt16)
Declaration | |
---|---|
From | func &=(inout _ lhs: UInt16, _ rhs: UInt16) |
To | func &=(_ lhs: inout UInt16, _ rhs: UInt16) |
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 &=(_: 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 &=(_: Int16, _: Int16)
Declaration | |
---|---|
From | func &=(inout _ lhs: Int16, _ rhs: Int16) |
To | func &=(_ lhs: inout Int16, _ rhs: Int16) |
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 &=(_: 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 *(_: 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 *=(_: 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 *=(_: 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 *=(_: Double, _: Double)
Declaration | |
---|---|
From | func *=(inout _ lhs: Double, _ rhs: Double) |
To | func *=(_ lhs: inout Double, _ rhs: Double) |
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 *=(_: Float, _: Float)
Declaration | |
---|---|
From | func *=(inout _ lhs: Float, _ rhs: Float) |
To | func *=(_ lhs: inout Float, _ rhs: Float) |
Modified *=(_: Int16, _: Int16)
Declaration | |
---|---|
From | func *=(inout _ lhs: Int16, _ rhs: Int16) |
To | func *=(_ lhs: inout Int16, _ rhs: Int16) |
Modified *=(_: Int64, _: Int64)
Declaration | |
---|---|
From | func *=(inout _ lhs: Int64, _ rhs: Int64) |
To | func *=(_ lhs: inout Int64, _ rhs: Int64) |
Modified *=(_: UInt8, _: UInt8)
Declaration | |
---|---|
From | func *=(inout _ lhs: UInt8, _ rhs: UInt8) |
To | func *=(_ lhs: inout UInt8, _ rhs: UInt8) |
Modified *=(_: Int32, _: Int32)
Declaration | |
---|---|
From | func *=(inout _ lhs: Int32, _ rhs: Int32) |
To | func *=(_ lhs: inout Int32, _ rhs: Int32) |
Modified +(_: Double) -> Double
Declaration | |
---|---|
From | @warn_unused_result prefix func +(_ x: Double) -> Double |
To | prefix func +(_ x: Double) -> Double |
Modified +(_: Float) -> Float
Declaration | |
---|---|
From | @warn_unused_result prefix func +(_ x: Float) -> Float |
To | prefix func +(_ x: 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 +(_: UnsafeMutablePointer<Pointee>, _: Int) -> UnsafeMutablePointer<Pointee>
Declaration | Generics[Parameters] | |
---|---|---|
From | @warn_unused_result func +<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: Int) -> UnsafeMutablePointer<Memory> | Memory |
To | func +<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: Int) -> UnsafeMutablePointer<Pointee> | Pointee |
Modified +(_: Int, _: UnsafeMutablePointer<Pointee>) -> UnsafeMutablePointer<Pointee>
Declaration | Generics[Parameters] | |
---|---|---|
From | @warn_unused_result func +<Memory>(_ lhs: Int, _ rhs: UnsafeMutablePointer<Memory>) -> UnsafeMutablePointer<Memory> | Memory |
To | func +<Pointee>(_ lhs: Int, _ rhs: UnsafeMutablePointer<Pointee>) -> UnsafeMutablePointer<Pointee> | Pointee |
Modified +(_: 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 +(_: 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 +(_: Double, _: Double) -> Double
Declaration | |
---|---|
From | @warn_unused_result func +(_ lhs: Double, _ rhs: Double) -> Double |
To | func +(_ lhs: Double, _ rhs: Double) -> Double |
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 +=(_: 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 +=(_: Int16, _: Int16)
Declaration | |
---|---|
From | func +=(inout _ lhs: Int16, _ rhs: Int16) |
To | func +=(_ lhs: inout Int16, _ rhs: Int16) |
Modified +=(_: Int8, _: Int8)
Declaration | |
---|---|
From | func +=(inout _ lhs: Int8, _ rhs: Int8) |
To | func +=(_ lhs: inout Int8, _ rhs: Int8) |
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 +=(_: UInt, _: UInt)
Declaration | |
---|---|
From | func +=(inout _ lhs: UInt, _ rhs: UInt) |
To | func +=(_ lhs: inout UInt, _ rhs: UInt) |
Modified +=(_: Int32, _: Int32)
Declaration | |
---|---|
From | func +=(inout _ lhs: Int32, _ rhs: Int32) |
To | func +=(_ lhs: inout Int32, _ rhs: Int32) |
Modified +=(_: Double, _: Double)
Declaration | |
---|---|
From | func +=(inout _ lhs: Double, _ rhs: Double) |
To | func +=(_ lhs: inout Double, _ rhs: Double) |
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 +=(_: 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 +=(_: UInt64, _: UInt64)
Declaration | |
---|---|
From | func +=(inout _ lhs: UInt64, _ rhs: UInt64) |
To | func +=(_ lhs: inout UInt64, _ rhs: UInt64) |
Modified +=(_: UInt8, _: UInt8)
Declaration | |
---|---|
From | func +=(inout _ lhs: UInt8, _ rhs: UInt8) |
To | func +=(_ lhs: inout UInt8, _ rhs: UInt8) |
Modified +=(_: Float, _: Float)
Declaration | |
---|---|
From | func +=(inout _ lhs: Float, _ rhs: Float) |
To | func +=(_ lhs: inout Float, _ rhs: Float) |
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 -(_: Double) -> Double
Declaration | |
---|---|
From | @warn_unused_result prefix func -(_ x: Double) -> Double |
To | prefix func -(_ x: Double) -> Double |
Modified -(_: Float) -> Float
Declaration | |
---|---|
From | @warn_unused_result prefix func -(_ x: Float) -> Float |
To | prefix func -(_ x: Float) -> Float |
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 -(_: 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 -(_: UnsafeMutablePointer<Pointee>, _: Int) -> UnsafeMutablePointer<Pointee>
Declaration | Generics[Parameters] | |
---|---|---|
From | @warn_unused_result func -<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: Int) -> UnsafeMutablePointer<Memory> | Memory |
To | func -<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: Int) -> UnsafeMutablePointer<Pointee> | Pointee |
Modified -(_: UnsafeMutablePointer<Pointee>, _: UnsafeMutablePointer<Pointee>) -> Int
Declaration | Generics[Parameters] | |
---|---|---|
From | @warn_unused_result func -<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: UnsafeMutablePointer<Memory>) -> Int | Memory |
To | func -<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: UnsafeMutablePointer<Pointee>) -> Int | Pointee |
Modified -(_: 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 -(_: 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 -=(_: 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 -=(_: Int16, _: Int16)
Declaration | |
---|---|
From | func -=(inout _ lhs: Int16, _ rhs: Int16) |
To | func -=(_ lhs: inout Int16, _ rhs: Int16) |
Modified -=(_: Float, _: Float)
Declaration | |
---|---|
From | func -=(inout _ lhs: Float, _ rhs: Float) |
To | func -=(_ lhs: inout Float, _ rhs: Float) |
Modified -=(_: UInt16, _: UInt16)
Declaration | |
---|---|
From | func -=(inout _ lhs: UInt16, _ rhs: UInt16) |
To | func -=(_ lhs: inout UInt16, _ rhs: UInt16) |
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 -=(_: Int64, _: Int64)
Declaration | |
---|---|
From | func -=(inout _ lhs: Int64, _ rhs: Int64) |
To | func -=(_ lhs: inout Int64, _ rhs: Int64) |
Modified -=(_: UInt32, _: UInt32)
Declaration | |
---|---|
From | func -=(inout _ lhs: UInt32, _ rhs: UInt32) |
To | func -=(_ lhs: inout UInt32, _ rhs: UInt32) |
Modified -=(_: Int32, _: Int32)
Declaration | |
---|---|
From | func -=(inout _ lhs: Int32, _ rhs: Int32) |
To | func -=(_ lhs: inout Int32, _ rhs: Int32) |
Modified -=(_: Double, _: Double)
Declaration | |
---|---|
From | func -=(inout _ lhs: Double, _ rhs: Double) |
To | func -=(_ lhs: inout Double, _ rhs: Double) |
Modified -=(_: UInt8, _: UInt8)
Declaration | |
---|---|
From | func -=(inout _ lhs: UInt8, _ rhs: UInt8) |
To | func -=(_ lhs: inout UInt8, _ rhs: UInt8) |
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 -=(_: UInt, _: UInt)
Declaration | |
---|---|
From | func -=(inout _ lhs: UInt, _ rhs: UInt) |
To | func -=(_ lhs: inout UInt, _ rhs: UInt) |
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 -=(_: Int8, _: Int8)
Declaration | |
---|---|
From | func -=(inout _ lhs: Int8, _ rhs: Int8) |
To | func -=(_ lhs: inout Int8, _ rhs: Int8) |
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 /=(_: Double, _: Double)
Declaration | |
---|---|
From | func /=(inout _ lhs: Double, _ rhs: Double) |
To | func /=(_ lhs: inout Double, _ rhs: Double) |
Modified /=(_: Float, _: Float)
Declaration | |
---|---|
From | func /=(inout _ lhs: Float, _ rhs: Float) |
To | func /=(_ lhs: inout Float, _ rhs: Float) |
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 |
Declaration | |
---|---|
From | @warn_unused_result func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
To | func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
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 |
Declaration | |
---|---|
From | @warn_unused_result func <<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
To | func <<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
To | func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
To | func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
Modified <(_: UnsafeMutablePointer<Pointee>, _: UnsafeMutablePointer<Pointee>) -> Bool
Declaration | Generics[Parameters] | |
---|---|---|
From | @warn_unused_result func <<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: UnsafeMutablePointer<Memory>) -> Bool | Memory |
To | func <<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: UnsafeMutablePointer<Pointee>) -> Bool | Pointee |
Modified <<=(_: 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 <<=(_: 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 <<=(_: 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 <<=(_: 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 <<=(_: UInt, _: UInt)
Declaration | |
---|---|
From | func <<=(inout _ lhs: UInt, _ rhs: UInt) |
To | func <<=(_ lhs: inout UInt, _ rhs: UInt) |
Declaration | |
---|---|
From | @warn_unused_result func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
To | func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
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 |
Declaration | |
---|---|
From | @warn_unused_result func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
To | func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func <=<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
To | func <=<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
To | func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
Modified ==(_: _HeapBuffer<Value, Element>, _: _HeapBuffer<Value, Element>) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func ==<Value, Element>(_ lhs: _HeapBuffer<Value, Element>, _ rhs: _HeapBuffer<Value, Element>) -> Bool |
To | func ==<Value, Element>(_ lhs: _HeapBuffer<Value, Element>, _ rhs: _HeapBuffer<Value, Element>) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
To | func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
Modified ==(_: _OptionalNilComparisonType, _: T?) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func ==<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool |
To | func ==<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
To | func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
Modified ==(_: ArraySlice<Element>, _: ArraySlice<Element>) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func ==<Element : Equatable>(_ lhs: ArraySlice<Element>, _ rhs: ArraySlice<Element>) -> Bool |
To | func ==<Element : Equatable>(_ lhs: ArraySlice<Element>, _ rhs: ArraySlice<Element>) -> Bool |
Modified ==(_: 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 |
Declaration | |
---|---|
From | @warn_unused_result func ==<A : Equatable, B : Equatable, C : Equatable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
To | func ==<A : Equatable, B : Equatable, C : Equatable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
To | func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
Modified ==(_: AutoreleasingUnsafeMutablePointer<Pointee>, _: AutoreleasingUnsafeMutablePointer<Pointee>) -> Bool
Declaration | Generics[Parameters] | |
---|---|---|
From | @warn_unused_result func ==<Memory>(_ lhs: AutoreleasingUnsafeMutablePointer<Memory>, _ rhs: AutoreleasingUnsafeMutablePointer<Memory>) -> Bool | Memory |
To | func ==<Pointee>(_ lhs: AutoreleasingUnsafeMutablePointer<Pointee>, _ rhs: AutoreleasingUnsafeMutablePointer<Pointee>) -> Bool | Pointee |
Modified ==(_: ContiguousArray<Element>, _: ContiguousArray<Element>) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func ==<Element : Equatable>(_ lhs: ContiguousArray<Element>, _ rhs: ContiguousArray<Element>) -> Bool |
To | func ==<Element : Equatable>(_ lhs: ContiguousArray<Element>, _ rhs: ContiguousArray<Element>) -> Bool |
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 ==(_: UnsafeMutablePointer<Pointee>, _: UnsafeMutablePointer<Pointee>) -> Bool
Declaration | Generics[Parameters] | |
---|---|---|
From | @warn_unused_result func ==<Memory>(_ lhs: UnsafeMutablePointer<Memory>, _ rhs: UnsafeMutablePointer<Memory>) -> Bool | Memory |
To | func ==<Pointee>(_ lhs: UnsafeMutablePointer<Pointee>, _ rhs: UnsafeMutablePointer<Pointee>) -> Bool | Pointee |
Modified ==(_: (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 ==(_: 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 ==(_: [Element], _: [Element]) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func ==<Element : Equatable>(_ lhs: [Element], _ rhs: [Element]) -> Bool |
To | func ==<Element : Equatable>(_ lhs: [Element], _ rhs: [Element]) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func ===(_ lhs: AnyObject?, _ rhs: AnyObject?) -> Bool |
To | func ===(_ lhs: AnyObject?, _ rhs: AnyObject?) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
To | func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
To | func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func ><A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
To | func ><A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
To | func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
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 |
Declaration | |
---|---|
From | @warn_unused_result func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
To | func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(_ lhs: (A, B, C, D), _ rhs: (A, B, C, D)) -> Bool |
Modified >=(_: (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 |
Declaration | |
---|---|
From | @warn_unused_result func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
To | func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(_ lhs: (A, B, C, D, E), _ rhs: (A, B, C, D, E)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
To | func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(_ lhs: (A, B, C, D, E, F), _ rhs: (A, B, C, D, E, F)) -> Bool |
Declaration | |
---|---|
From | @warn_unused_result func >=<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
To | func >=<A : Comparable, B : Comparable, C : Comparable>(_ lhs: (A, B, C), _ rhs: (A, B, C)) -> Bool |
Modified >>=(_: 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 >>=(_: UInt16, _: UInt16)
Declaration | |
---|---|
From | func >>=(inout _ lhs: UInt16, _ rhs: UInt16) |
To | func >>=(_ lhs: inout UInt16, _ rhs: UInt16) |
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 >>=(_: 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 >>=(_: Int64, _: Int64)
Declaration | |
---|---|
From | func >>=(inout _ lhs: Int64, _ rhs: Int64) |
To | func >>=(_ lhs: inout Int64, _ rhs: Int64) |
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) |
Declaration | |
---|---|
From | @warn_unused_result func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T) rethrows -> T |
To | func ??<T>(_ optional: T?, _ defaultValue: @autoclosure () throws -> T) rethrows -> T |
Declaration | |
---|---|
From | @warn_unused_result func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T?) rethrows -> T? |
To | func ??<T>(_ optional: T?, _ defaultValue: @autoclosure () throws -> T?) rethrows -> T? |
Modified ^=(_: 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 ^=(_: 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 ^=(_: 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 ^=(_: UInt32, _: UInt32)
Declaration | |
---|---|
From | func ^=(inout _ lhs: UInt32, _ rhs: UInt32) |
To | func ^=(_ lhs: inout UInt32, _ rhs: UInt32) |
Modified ^=(_: Int, _: Int)
Declaration | |
---|---|
From | func ^=(inout _ lhs: Int, _ rhs: Int) |
To | func ^=(_ lhs: inout Int, _ rhs: Int) |
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) |
Declaration | |
---|---|
From | func assert(@autoclosure _ condition: () -> Bool, @autoclosure _ message: () -> String = default, file file: StaticString = #file, line line: UInt = #line) |
To | func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = default, file file: StaticString = #file, line line: UInt = #line) |
Declaration | |
---|---|
From | func assertionFailure(@autoclosure _ message: () -> String = default, file file: StaticString = #file, line line: UInt = #line) |
To | func assertionFailure(_ message: @autoclosure () -> String = default, file file: StaticString = #file, line line: UInt = #line) |
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 |
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 |
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 |
Declaration | |
---|---|
From | func precondition(@autoclosure _ condition: () -> Bool, @autoclosure _ message: () -> String = default, file file: StaticString = #file, line line: UInt = #line) |
To | func precondition(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = default, file file: StaticString = #file, line line: UInt = #line) |
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) |
Declaration | |
---|---|
From | func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: T throws -> Result) rethrows -> Result |
To | func withExtendedLifetime<T, Result>(_ x: T, _ body: (T) throws -> Result) rethrows -> Result |
Declaration | |
---|---|
From | 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 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 |=(_: UInt64, _: UInt64)
Declaration | |
---|---|
From | func |=(inout _ lhs: UInt64, _ rhs: UInt64) |
To | func |=(_ lhs: inout UInt64, _ rhs: UInt64) |
Modified |=(_: Int16, _: Int16)
Declaration | |
---|---|
From | func |=(inout _ lhs: Int16, _ rhs: Int16) |
To | func |=(_ lhs: inout Int16, _ rhs: Int16) |
Modified |=(_: Int8, _: Int8)
Declaration | |
---|---|
From | func |=(inout _ lhs: Int8, _ rhs: Int8) |
To | func |=(_ lhs: inout Int8, _ rhs: Int8) |
Modified |=(_: Int64, _: Int64)
Declaration | |
---|---|
From | func |=(inout _ lhs: Int64, _ rhs: Int64) |
To | func |=(_ lhs: inout Int64, _ rhs: Int64) |
Modified |=(_: UInt32, _: UInt32)
Declaration | |
---|---|
From | func |=(inout _ lhs: UInt32, _ rhs: UInt32) |
To | func |=(_ lhs: inout UInt32, _ rhs: UInt32) |
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 |=(_: UInt8, _: UInt8)
Declaration | |
---|---|
From | func |=(inout _ lhs: UInt8, _ rhs: UInt8) |
To | func |=(_ lhs: inout UInt8, _ rhs: UInt8) |
Modified |=(_: UInt16, _: UInt16)
Declaration | |
---|---|
From | func |=(inout _ lhs: UInt16, _ rhs: UInt16) |
To | func |=(_ lhs: inout UInt16, _ rhs: UInt16) |
Modified |=(_: UInt, _: UInt)
Declaration | |
---|---|
From | func |=(inout _ lhs: UInt, _ rhs: UInt) |
To | func |=(_ lhs: inout UInt, _ rhs: UInt) |
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 |
Modified ~=(_: _OptionalNilComparisonType, _: T?) -> Bool
Declaration | |
---|---|
From | @warn_unused_result func ~=<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool |
To | func ~=<T>(_ lhs: _OptionalNilComparisonType, _ rhs: T?) -> Bool |