Guides and Sample Code Developer
Search

Swift Changes for Swift

Swift

Removed Array.init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_: S)
Removed ArraySlice.init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_: S)
Removed Bit [enum]
Removed Bit.One
Removed Bit.Zero
Removed BooleanType
Removed ContiguousArray.init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_: S)
Removed CVarArgType
Removed Dictionary.subscript(_: DictionaryIndex<Key, Value>) -> (Key, Value)
Removed Double.NaN
Removed ErrorType
Removed FlattenBidirectionalCollection.subscript(_: FlattenBidirectionalCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element
Removed FlattenCollection.subscript(_: FlattenCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element
Removed Float.NaN
Removed Indexable.subscript(_: Self.Index) -> Self._Element
Removed IntegerType
Removed IntervalType
Removed LazyFilterCollection.subscript(_: LazyFilterIndex<Base>) -> Base.Generator.Element
Removed Process.argc
Removed Repeat.count
Removed SequenceType
Removed Set.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed Set.union<S : SequenceType where S.Generator.Element == Element>(_: S) -> Set<Element>
Removed Streamable
Removed String.init<T>(_: T)
Removed String.CharacterView.init<S : SequenceType where S.Generator.Element == Character>(_: S)
Removed UTF16.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed UTF32.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed UTF8.decode<G : GeneratorType where G.Element == CodeUnit>(_: G) -> UnicodeDecodingResult
Removed !=(_: T, _: T) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed %(_: T, _: T) -> T
Removed %=(_: T, _: T)
Removed &*(_: T, _: T) -> T
Removed &+(_: T, _: T) -> T
Removed &-(_: T, _: T) -> T
Removed *(_: T, _: T) -> T
Removed *=(_: T, _: T)
Removed +(_: T) -> T
Removed -(_: T) -> T
Removed -(_: T, _: T) -> T
Removed /(_: T, _: T) -> T
Removed /=(_: T, _: T)
Removed <(_: T, _: T) -> Bool
Removed <=(_: T, _: T) -> Bool
Removed ==(_: ManagedBufferPointer<Value, Element>, _: ManagedBufferPointer<Value, Element>) -> Bool
Removed ==(_: T, _: T) -> Bool
Removed ==(_: T, _: T) -> Bool
Removed >(_: T, _: T) -> Bool
Removed >=(_: T, _: T) -> Bool
Removed abs<T : SignedNumberType>(_: T) -> T
Removed Any
Removed Bit.Distance
Removed Int.Distance
Removed Repeat.Index
Added AnyBidirectionalCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.count
Added AnyBidirectionalCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax
Added AnyBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyBidirectionalCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.first
Added AnyBidirectionalCollection.first
Added AnyBidirectionalCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added AnyBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnyBidirectionalCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnyBidirectionalCollection.formIndex(_: AnyIndex, offsetBy: IntMax)
Added AnyBidirectionalCollection.formIndex(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> Bool
Added AnyBidirectionalCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex
Added AnyBidirectionalCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?
Added AnyBidirectionalCollection.index(of: Element) -> AnyIndex?
Added AnyBidirectionalCollection.index(where: (Element) throws -> Bool) rethrows -> AnyIndex?
Added AnyBidirectionalCollection.indices
Added AnyBidirectionalCollection.init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyBidirectionalCollection.init<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.joined() -> FlattenBidirectionalCollection<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.joined() -> FlattenSequence<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.joined() -> FlattenCollection<AnyBidirectionalCollection<Element>>
Added AnyBidirectionalCollection.last
Added AnyBidirectionalCollection.last
Added AnyBidirectionalCollection.lazy
Added AnyBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyBidirectionalCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyBidirectionalCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyBidirectionalCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyBidirectionalCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyBidirectionalCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnyBidirectionalCollection.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnyBidirectionalCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyBidirectionalCollection<Element>]
Added AnyBidirectionalCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnyBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added AnyBidirectionalCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyBidirectionalCollection.subscript(_: ClosedRange<AnyIndex>) -> AnyBidirectionalCollection<Element>
Added AnyBidirectionalCollection.underestimatedCount
Added AnyBidirectionalCollection.underestimatedCount
Added AnyBidirectionalCollection.underestimatedCount
Added AnyCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnyCollection.count
Added AnyCollection.count
Added AnyCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax
Added AnyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyCollection.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.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 : Collection where C.Iterator.Element == Element, C.SubSequence : Collection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : Collection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : Collection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyCollection.init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyCollection.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.joined() -> FlattenSequence<AnyCollection<Element>>
Added AnyCollection.joined() -> FlattenCollection<AnyCollection<Element>>
Added AnyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnyCollection.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyCollection.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnyCollection.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnyCollection.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyCollection<Element>]
Added AnyCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added AnyCollection.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyCollection.subscript(_: ClosedRange<AnyIndex>) -> AnyCollection<Element>
Added AnyCollection.underestimatedCount
Added AnyCollection.underestimatedCount
Added AnyCollection.underestimatedCount
Added AnyIterator.init<I : IteratorProtocol where I.Element == Element>(_: I)
Added AnyRandomAccessCollection.contains(where: (Element) throws -> Bool) rethrows -> Bool
Added AnyRandomAccessCollection.count
Added AnyRandomAccessCollection.distance(from: AnyIndex, to: AnyIndex) -> IntMax
Added AnyRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnyRandomAccessCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnyRandomAccessCollection.first
Added AnyRandomAccessCollection.first
Added AnyRandomAccessCollection.first(where: (Element) throws -> Bool) rethrows -> Element?
Added AnyRandomAccessCollection.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnyRandomAccessCollection.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnyRandomAccessCollection.formIndex(_: AnyIndex, offsetBy: IntMax)
Added AnyRandomAccessCollection.formIndex(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> Bool
Added AnyRandomAccessCollection.index(_: AnyIndex, offsetBy: IntMax) -> AnyIndex
Added AnyRandomAccessCollection.index(_: AnyIndex, offsetBy: IntMax, limitedBy: AnyIndex) -> AnyIndex?
Added AnyRandomAccessCollection.index(of: Element) -> AnyIndex?
Added AnyRandomAccessCollection.index(where: (Element) throws -> Bool) rethrows -> AnyIndex?
Added AnyRandomAccessCollection.indices
Added AnyRandomAccessCollection.init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_: C)
Added AnyRandomAccessCollection.joined() -> FlattenSequence<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.joined() -> FlattenBidirectionalCollection<AnyRandomAccessCollection<Element>>
Added AnyRandomAccessCollection.joined() -> FlattenCollection<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) -> [AnySequence<Element>]
Added AnyRandomAccessCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnyRandomAccessCollection<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<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added AnySequence.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added AnySequence.init<S : Sequence where S.Iterator.Element == Element, S.SubSequence : Sequence, S.SubSequence.Iterator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_: S)
Added AnySequence.init<I : IteratorProtocol where I.Element == Element>(_: () -> I)
Added AnySequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added AnySequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnySequence.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnySequence.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added AnySequence.max(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnySequence.min(by: (Element, Element) throws -> Bool) rethrows -> Element?
Added AnySequence.reduce<Result>(_: Result, _: (Result, Element) throws -> Result) rethrows -> Result
Added AnySequence.sorted(by: (Element, Element) -> Bool) -> [Element]
Added AnySequence.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added AnySequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added AnySequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added AnySequence.underestimatedCount
Added AnySequence.underestimatedCount
Added Array.append<C : Collection where C.Iterator.Element == Element>(contentsOf: C)
Added Array.append<S : Sequence where S.Iterator.Element == Element>(contentsOf: S)
Added Array.count
Added Array.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Array.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Array.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added Array.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Array.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Array.formIndex(_: Int, offsetBy: Int)
Added Array.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Array.indices
Added Array.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added Array.joined() -> FlattenBidirectionalCollection<Array<Element>>
Added Array.joined() -> FlattenSequence<Array<Element>>
Added Array.joined() -> FlattenCollection<Array<Element>>
Added Array.joined(separator: String) -> String
Added Array.lazy
Added Array.lazy
Added Array.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added Array.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Array.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Array.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added Array.partition(by: (Element) throws -> Bool) rethrows -> Int
Added Array.partition(by: (Element) throws -> Bool) rethrows -> Int
Added Array.replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Added Array.sorted() -> [Element]
Added Array.sorted() -> [Element]
Added Array.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added Array.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Element>]
Added Array.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added Array.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added Array.subscript(_: Range<Int>) -> MutableSlice<Array<Element>>
Added Array.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added Array.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added Array.underestimatedCount
Added Array.underestimatedCount
Added ArraySlice.append<S : Sequence where S.Iterator.Element == Element>(contentsOf: S)
Added ArraySlice.append<C : Collection where C.Iterator.Element == Element>(contentsOf: C)
Added ArraySlice.count
Added ArraySlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ArraySlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ArraySlice.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added ArraySlice.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ArraySlice.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ArraySlice.formIndex(_: Int, offsetBy: Int)
Added ArraySlice.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added ArraySlice.indices
Added ArraySlice.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added ArraySlice.joined() -> FlattenSequence<ArraySlice<Element>>
Added ArraySlice.joined() -> FlattenBidirectionalCollection<ArraySlice<Element>>
Added ArraySlice.joined() -> FlattenCollection<ArraySlice<Element>>
Added ArraySlice.lazy
Added ArraySlice.lazy
Added ArraySlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ArraySlice.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ArraySlice.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added ArraySlice.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added ArraySlice.partition(by: (Element) throws -> Bool) rethrows -> Int
Added ArraySlice.partition(by: (Element) throws -> Bool) rethrows -> Int
Added ArraySlice.removeFirst() -> Element
Added ArraySlice.removeLast() -> Element
Added ArraySlice.removeLast(_: Int)
Added ArraySlice.replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Added ArraySlice.sorted() -> [Element]
Added ArraySlice.sorted() -> [Element]
Added ArraySlice.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Element>]
Added ArraySlice.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added ArraySlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added ArraySlice.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ArraySlice.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ArraySlice.subscript(_: Range<Int>) -> MutableSlice<ArraySlice<Element>>
Added ArraySlice.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ArraySlice.underestimatedCount
Added ArraySlice.underestimatedCount
Added BidirectionalCollection.indices
Added BidirectionalCollection.last
Added BidirectionalCollection.last
Added BidirectionalCollection.lazy
Added BidirectionalCollection.subscript(_: Range<Self.Index>) -> BidirectionalSlice<Self>
Added BidirectionalIndexable
Added BidirectionalIndexable.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance
Added BidirectionalIndexable.formIndex(before: Self.Index)
Added BidirectionalIndexable.formIndex(before: Self.Index)
Added BidirectionalIndexable.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index
Added BidirectionalIndexable.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added BidirectionalIndexable.index(before: Self.Index) -> Self.Index
Added BidirectionalSlice [struct]
Added BidirectionalSlice.base
Added BidirectionalSlice.contains(where: (Base._Element) throws -> Bool) rethrows -> Bool
Added BidirectionalSlice.count
Added BidirectionalSlice.distance(from: Base.Index, to: Base.Index) -> Base.IndexDistance
Added BidirectionalSlice.dropFirst() -> BidirectionalSlice<Base>
Added BidirectionalSlice.dropFirst(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.dropLast() -> BidirectionalSlice<Base>
Added BidirectionalSlice.dropLast(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence) -> Bool
Added BidirectionalSlice.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Base._Element>(_: OtherSequence, by: (Base._Element, Base._Element) throws -> Bool) rethrows -> Bool
Added BidirectionalSlice.endIndex
Added BidirectionalSlice.enumerated() -> EnumeratedSequence<BidirectionalSlice<Base>>
Added BidirectionalSlice.filter(_: (Base._Element) throws -> Bool) rethrows -> [Base._Element]
Added BidirectionalSlice.first
Added BidirectionalSlice.first(where: (Base._Element) throws -> Bool) rethrows -> Base._Element?
Added BidirectionalSlice.flatMap<SegmentOfResult : Sequence>(_: (Base._Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added BidirectionalSlice.flatMap<ElementOfResult>(_: (Base._Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added BidirectionalSlice.forEach(_: (Base._Element) throws -> Void) rethrows
Added BidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance)
Added BidirectionalSlice.formIndex(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Bool
Added BidirectionalSlice.formIndex(after: Base.Index)
Added BidirectionalSlice.formIndex(before: Base.Index)
Added BidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance) -> Base.Index
Added BidirectionalSlice.index(_: Base.Index, offsetBy: Base.IndexDistance, limitedBy: Base.Index) -> Base.Index?
Added BidirectionalSlice.index(after: Base.Index) -> Base.Index
Added BidirectionalSlice.index(before: Base.Index) -> Base.Index
Added BidirectionalSlice.index(of: Base._Element) -> Base.Index?
Added BidirectionalSlice.index(where: (Base._Element) throws -> Bool) rethrows -> Base.Index?
Added BidirectionalSlice.indices
Added BidirectionalSlice.init(base: Base, bounds: Range<Base.Index>)
Added BidirectionalSlice.isEmpty
Added BidirectionalSlice.joined() -> FlattenCollection<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined() -> FlattenSequence<BidirectionalSlice<Base>>
Added BidirectionalSlice.joined() -> FlattenBidirectionalCollection<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(_: ClosedRange<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: Range<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: CountableRange<Base.Index>) -> BidirectionalSlice<Base>
Added BidirectionalSlice.subscript(_: Base.Index) -> Base._Element
Added BidirectionalSlice.subscript(_: Range<Base.Index>) -> BidirectionalSlice<BidirectionalSlice<Base>>
Added BidirectionalSlice.suffix(_: Int) -> BidirectionalSlice<Base>
Added BidirectionalSlice.suffix(from: Base.Index) -> BidirectionalSlice<Base>
Added BidirectionalSlice.underestimatedCount
Added BidirectionalSlice.underestimatedCount
Added BitwiseOperations
Added BitwiseOperations.&(_: Self, _: Self) -> Self
Added BitwiseOperations.^(_: Self, _: Self) -> Self
Added BitwiseOperations.allZeros
Added BitwiseOperations.|(_: Self, _: Self) -> Self
Added BitwiseOperations.~(_: Self) -> Self
Added Character._SmallUTF16.contains(_: UInt16) -> Bool
Added Character._SmallUTF16.contains(where: (UInt16) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF16.count
Added Character._SmallUTF16.distance(from: Int, to: Int) -> Int
Added Character._SmallUTF16.dropFirst() -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.dropFirst(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.dropLast() -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.dropLast(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence) -> Bool
Added Character._SmallUTF16.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt16>(_: OtherSequence, by: (UInt16, UInt16) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF16.enumerated() -> EnumeratedSequence<Character._SmallUTF16>
Added Character._SmallUTF16.filter(_: (UInt16) throws -> Bool) rethrows -> [UInt16]
Added Character._SmallUTF16.first
Added Character._SmallUTF16.first(where: (UInt16) throws -> Bool) rethrows -> UInt16?
Added Character._SmallUTF16.flatMap<ElementOfResult>(_: (UInt16) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Character._SmallUTF16.flatMap<SegmentOfResult : Sequence>(_: (UInt16) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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(_: Range<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.subscript(_: CountableRange<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.suffix(_: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.suffix(from: Int) -> RandomAccessSlice<Character._SmallUTF16>
Added Character._SmallUTF16.underestimatedCount
Added Character._SmallUTF16.underestimatedCount
Added Character._SmallUTF8.contains(_: UInt8) -> Bool
Added Character._SmallUTF8.contains(where: (UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.count
Added Character._SmallUTF8.distance(from: Int, to: Int) -> Int
Added Character._SmallUTF8.dropFirst() -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.dropFirst(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.dropLast() -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.dropLast(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence) -> Bool
Added Character._SmallUTF8.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.enumerated() -> EnumeratedSequence<Character._SmallUTF8>
Added Character._SmallUTF8.filter(_: (UInt8) throws -> Bool) rethrows -> [UInt8]
Added Character._SmallUTF8.first
Added Character._SmallUTF8.first(where: (UInt8) throws -> Bool) rethrows -> UInt8?
Added Character._SmallUTF8.flatMap<SegmentOfResult : Sequence>(_: (UInt8) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Character._SmallUTF8.flatMap<ElementOfResult>(_: (UInt8) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Character._SmallUTF8.forEach(_: (UInt8) throws -> Void) rethrows
Added Character._SmallUTF8.formIndex(_: Int, offsetBy: Int)
Added Character._SmallUTF8.formIndex(_: Int, offsetBy: Int, limitedBy: Int) -> Bool
Added Character._SmallUTF8.formIndex(after: Int)
Added Character._SmallUTF8.formIndex(before: Int)
Added Character._SmallUTF8.index(_: Int, offsetBy: Int) -> Int
Added Character._SmallUTF8.index(_: Int, offsetBy: Int, limitedBy: Int) -> Int?
Added Character._SmallUTF8.index(after: Int) -> Int
Added Character._SmallUTF8.index(before: Int) -> Int
Added Character._SmallUTF8.index(of: UInt8) -> Int?
Added Character._SmallUTF8.index(where: (UInt8) throws -> Bool) rethrows -> Int?
Added Character._SmallUTF8.indices
Added Character._SmallUTF8.isEmpty
Added Character._SmallUTF8.last
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lazy
Added Character._SmallUTF8.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence) -> Bool
Added Character._SmallUTF8.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == UInt8>(_: OtherSequence, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.map<T>(_: (UInt8) throws -> T) rethrows -> [T]
Added Character._SmallUTF8.map<T>(_: (UInt8) throws -> T) rethrows -> [T]
Added Character._SmallUTF8.max() -> UInt8?
Added Character._SmallUTF8.max(by: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?
Added Character._SmallUTF8.min() -> UInt8?
Added Character._SmallUTF8.min(by: (UInt8, UInt8) throws -> Bool) rethrows -> UInt8?
Added Character._SmallUTF8.prefix(_: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.prefix(through: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.prefix(upTo: Int) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.reduce<Result>(_: Result, _: (Result, UInt8) throws -> Result) rethrows -> Result
Added Character._SmallUTF8.reversed() -> ReversedRandomAccessCollection<Character._SmallUTF8>
Added Character._SmallUTF8.sorted() -> [UInt8]
Added Character._SmallUTF8.sorted(by: (UInt8, UInt8) -> Bool) -> [UInt8]
Added Character._SmallUTF8.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (UInt8) throws -> Bool) rethrows -> [RandomAccessSlice<Character._SmallUTF8>]
Added Character._SmallUTF8.split(separator: UInt8, maxSplits: Int, omittingEmptySubsequences: Bool) -> [RandomAccessSlice<Character._SmallUTF8>]
Added Character._SmallUTF8.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with: PossiblePrefix) -> Bool
Added Character._SmallUTF8.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == UInt8>(with: PossiblePrefix, by: (UInt8, UInt8) throws -> Bool) rethrows -> Bool
Added Character._SmallUTF8.subscript(_: CountableClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.subscript(_: CountableRange<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.subscript(_: ClosedRange<Int>) -> RandomAccessSlice<Character._SmallUTF8>
Added Character._SmallUTF8.subscript(_: Range<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 ClosedRangeIterator [struct]
Added ClosedRangeIterator.contains(_: Bound) -> Bool
Added ClosedRangeIterator.contains(where: (Bound) throws -> Bool) rethrows -> Bool
Added ClosedRangeIterator.dropFirst() -> AnySequence<Bound>
Added ClosedRangeIterator.dropFirst(_: Int) -> AnySequence<Bound>
Added ClosedRangeIterator.dropLast() -> AnySequence<Bound>
Added ClosedRangeIterator.dropLast(_: Int) -> AnySequence<Bound>
Added ClosedRangeIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added ClosedRangeIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added ClosedRangeIterator.enumerated() -> EnumeratedSequence<ClosedRangeIterator<Bound>>
Added ClosedRangeIterator.filter(_: (Bound) throws -> Bool) rethrows -> [Bound]
Added ClosedRangeIterator.first(where: (Bound) throws -> Bool) rethrows -> Bound?
Added ClosedRangeIterator.flatMap<SegmentOfResult : Sequence>(_: (Bound) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added ClosedRangeIterator.flatMap<ElementOfResult>(_: (Bound) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added ClosedRangeIterator.forEach(_: (Bound) throws -> Void) rethrows
Added ClosedRangeIterator.joined() -> FlattenSequence<ClosedRangeIterator<Bound>>
Added ClosedRangeIterator.joined(separator: String) -> String
Added ClosedRangeIterator.joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> JoinedSequence<ClosedRangeIterator<Bound>>
Added ClosedRangeIterator.lazy
Added ClosedRangeIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence) -> Bool
Added ClosedRangeIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Bound>(_: OtherSequence, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added ClosedRangeIterator.makeIterator() -> ClosedRangeIterator<Bound>
Added ClosedRangeIterator.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added ClosedRangeIterator.max() -> Bound?
Added ClosedRangeIterator.max(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added ClosedRangeIterator.min() -> Bound?
Added ClosedRangeIterator.min(by: (Bound, Bound) throws -> Bool) rethrows -> Bound?
Added ClosedRangeIterator.next() -> Bound?
Added ClosedRangeIterator.prefix(_: Int) -> AnySequence<Bound>
Added ClosedRangeIterator.reduce<Result>(_: Result, _: (Result, Bound) throws -> Result) rethrows -> Result
Added ClosedRangeIterator.reversed() -> [Bound]
Added ClosedRangeIterator.sorted() -> [Bound]
Added ClosedRangeIterator.sorted(by: (Bound, Bound) -> Bool) -> [Bound]
Added ClosedRangeIterator.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Bound) throws -> Bool) rethrows -> [AnySequence<Bound>]
Added ClosedRangeIterator.split(separator: Bound, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Bound>]
Added ClosedRangeIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix) -> Bool
Added ClosedRangeIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Bound>(with: PossiblePrefix, by: (Bound, Bound) throws -> Bool) rethrows -> Bool
Added ClosedRangeIterator.suffix(_: Int) -> AnySequence<Bound>
Added ClosedRangeIterator.underestimatedCount
Added Collection.count
Added Collection.count
Added Collection.distance(from: Self.Index, to: Self.Index) -> Self.IndexDistance
Added Collection.first
Added Collection.first
Added Collection.index(_: Self.Index, offsetBy: Self.IndexDistance) -> Self.Index
Added Collection.index(_: Self.Index, offsetBy: Self.IndexDistance, limitedBy: Self.Index) -> Self.Index?
Added Collection.index(of: Self.Iterator.Element) -> Self.Index?
Added Collection.index(where: (Self.Iterator.Element) throws -> Bool) rethrows -> Self.Index?
Added Collection.isEmpty
Added Collection.isEmpty
Added Collection.makeIterator() -> Self.Iterator
Added Collection.makeIterator() -> IndexingIterator<Self>
Added Collection.map<T>(_: (Self.Iterator.Element) throws -> T) rethrows -> [T]
Added Collection.prefix(through: Self.Index) -> Self.SubSequence
Added Collection.prefix(through: Self.Index) -> Self.SubSequence
Added Collection.prefix(upTo: Self.Index) -> Self.SubSequence
Added Collection.prefix(upTo: Self.Index) -> Self.SubSequence
Added Collection.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Self.Iterator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Added Collection.split(separator: Self.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Self.SubSequence]
Added Collection.subscript(_: Range<Self.Index>) -> Slice<Self>
Added Collection.subscript(_: Range<Self.Index>) -> Self.SubSequence
Added Collection.suffix(from: Self.Index) -> Self.SubSequence
Added Collection.suffix(from: Self.Index) -> Self.SubSequence
Added CollectionOfOne.count
Added CollectionOfOne.distance(from: Int, to: Int) -> Int
Added CollectionOfOne.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added CollectionOfOne.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added CollectionOfOne.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added CollectionOfOne.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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.indices
Added CollectionOfOne.joined() -> FlattenBidirectionalCollection<CollectionOfOne<Element>>
Added CollectionOfOne.joined() -> FlattenCollection<CollectionOfOne<Element>>
Added CollectionOfOne.joined() -> FlattenSequence<CollectionOfOne<Element>>
Added CollectionOfOne.lazy
Added CollectionOfOne.lazy
Added CollectionOfOne.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added CollectionOfOne.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added CollectionOfOne.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added CollectionOfOne.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added CollectionOfOne.partition(by: (Element) throws -> Bool) rethrows -> Int
Added CollectionOfOne.partition(by: (Element) throws -> Bool) rethrows -> Int
Added CollectionOfOne.sorted() -> [Element]
Added CollectionOfOne.sorted() -> [Element]
Added CollectionOfOne.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [MutableRandomAccessSlice<CollectionOfOne<Element>>]
Added CollectionOfOne.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added CollectionOfOne.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added CollectionOfOne.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added CollectionOfOne.subscript(_: Range<Int>) -> MutableSlice<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(_: CountableRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: Range<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: ClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.subscript(_: CountableClosedRange<Int>) -> MutableRandomAccessSlice<CollectionOfOne<Element>>
Added CollectionOfOne.underestimatedCount
Added CollectionOfOne.underestimatedCount
Added ContiguousArray.append<C : Collection where C.Iterator.Element == Element>(contentsOf: C)
Added ContiguousArray.append<S : Sequence where S.Iterator.Element == Element>(contentsOf: S)
Added ContiguousArray.count
Added ContiguousArray.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added ContiguousArray.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ContiguousArray.filter(_: (Element) throws -> Bool) rethrows -> [Element]
Added ContiguousArray.flatMap<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.indices
Added ContiguousArray.init<S : Sequence where S.Iterator.Element == Element>(_: S)
Added ContiguousArray.joined() -> FlattenSequence<ContiguousArray<Element>>
Added ContiguousArray.joined() -> FlattenCollection<ContiguousArray<Element>>
Added ContiguousArray.joined() -> FlattenBidirectionalCollection<ContiguousArray<Element>>
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.replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_: Range<Int>, with: C)
Added ContiguousArray.sorted() -> [Element]
Added ContiguousArray.sorted() -> [Element]
Added ContiguousArray.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [ArraySlice<Element>]
Added ContiguousArray.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added ContiguousArray.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix) -> Bool
Added ContiguousArray.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Element>(with: PossiblePrefix, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added ContiguousArray.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: CountableRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: Range<Int>) -> MutableSlice<ContiguousArray<Element>>
Added ContiguousArray.subscript(_: ClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.subscript(_: CountableClosedRange<Int>) -> ArraySlice<Element>
Added ContiguousArray.underestimatedCount
Added ContiguousArray.underestimatedCount
Added CountableClosedRange.count
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.flatMap<ElementOfResult>(_: (Bound) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added CountableClosedRange.flatMap<SegmentOfResult : Sequence>(_: (Bound) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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.indices
Added CountableClosedRange.indices
Added CountableClosedRange.isEmpty
Added CountableClosedRange.isEmpty
Added CountableClosedRange.joined() -> FlattenCollection<CountableClosedRange<Bound>>
Added CountableClosedRange.joined() -> FlattenBidirectionalCollection<CountableClosedRange<Bound>>
Added CountableClosedRange.joined() -> FlattenSequence<CountableClosedRange<Bound>>
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.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added CountableClosedRange.map<T>(_: (Bound) throws -> T) rethrows -> [T]
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(_: Range<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.subscript(_: ClosedRangeIndex<Bound>) -> Bound
Added CountableClosedRange.subscript(_: Range<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.subscript(_: ClosedRange<ClosedRangeIndex<Bound>>) -> RandomAccessSlice<CountableClosedRange<Bound>>
Added CountableClosedRange.underestimatedCount
Added CountableClosedRange.underestimatedCount
Added CountableRange.count
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.flatMap<SegmentOfResult : Sequence>(_: (Bound) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added CountableRange.flatMap<ElementOfResult>(_: (Bound) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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.indices
Added CountableRange.indices
Added CountableRange.isEmpty
Added CountableRange.isEmpty
Added CountableRange.joined() -> FlattenBidirectionalCollection<CountableRange<Bound>>
Added CountableRange.joined() -> FlattenSequence<CountableRange<Bound>>
Added CountableRange.joined() -> FlattenCollection<CountableRange<Bound>>
Added CountableRange.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.map<T>(_: (Bound) throws -> T) rethrows -> [T]
Added CountableRange.map<T>(_: (Bound) throws -> T) rethrows -> [T]
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(_: Range<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: CountableRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: CountableClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: ClosedRange<Bound>) -> CountableRange<Bound>
Added CountableRange.subscript(_: Bound) -> Bound
Added CountableRange.underestimatedCount
Added CountableRange.underestimatedCount
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(_: CountableClosedRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: Range<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.subscript(_: Elements.Index) -> Elements.Index
Added DefaultBidirectionalIndices.subscript(_: CountableRange<Elements.Index>) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.suffix(_: Int) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.suffix(from: Elements.Index) -> DefaultBidirectionalIndices<Elements>
Added DefaultBidirectionalIndices.underestimatedCount
Added DefaultBidirectionalIndices.underestimatedCount
Added DefaultIndices.distance(from: Elements.Index, to: Elements.Index) -> Int
Added DefaultIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultIndices.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultIndices.flatMap<SegmentOfResult : Sequence>(_: (Elements.Index) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added DefaultIndices.flatMap<ElementOfResult>(_: (Elements.Index) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
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.indices
Added DefaultIndices.joined() -> FlattenCollection<DefaultIndices<Elements>>
Added DefaultIndices.joined() -> FlattenSequence<DefaultIndices<Elements>>
Added DefaultIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence) -> Bool
Added DefaultIndices.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Elements.Index>(_: OtherSequence, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultIndices.map<T>(_: (Elements.Index) throws -> T) rethrows -> [T]
Added DefaultIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix) -> Bool
Added DefaultIndices.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Elements.Index>(with: PossiblePrefix, by: (Elements.Index, Elements.Index) throws -> Bool) rethrows -> Bool
Added DefaultIndices.subscript(_: CountableClosedRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: Elements.Index) -> Elements.Index
Added DefaultIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: Range<Elements.Index>) -> DefaultIndices<Elements>
Added DefaultIndices.subscript(_: CountableRange<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<ElementOfResult>(_: (Elements.Index) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added DefaultRandomAccessIndices.flatMap<SegmentOfResult : Sequence>(_: (Elements.Index) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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() -> FlattenBidirectionalCollection<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.joined() -> FlattenCollection<DefaultRandomAccessIndices<Elements>>
Added DefaultRandomAccessIndices.joined() -> FlattenSequence<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(_: Elements.Index) -> Elements.Index
Added DefaultRandomAccessIndices.subscript(_: ClosedRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: CountableClosedRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: Range<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.subscript(_: CountableRange<Elements.Index>) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.suffix(_: Int) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.suffix(from: Elements.Index) -> DefaultRandomAccessIndices<Elements>
Added DefaultRandomAccessIndices.underestimatedCount
Added DefaultRandomAccessIndices.underestimatedCount
Added Dictionary.count
Added Dictionary.distance(from: DictionaryIndex<Key, Value>, to: DictionaryIndex<Key, Value>) -> Int
Added Dictionary.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (key: Key, value: Value)>(_: OtherSequence, by: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
Added Dictionary.filter(_: (Key, Value) throws -> Bool) rethrows -> [(key: Key, value: Value)]
Added Dictionary.flatMap<ElementOfResult>(_: (Key, Value) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added Dictionary.flatMap<SegmentOfResult : Sequence>(_: (Key, Value) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added Dictionary.formIndex(_: DictionaryIndex<Key, Value>, offsetBy: Int)
Added Dictionary.formIndex(_: DictionaryIndex<Key, Value>, offsetBy: Int, limitedBy: DictionaryIndex<Key, Value>) -> Bool
Added Dictionary.formIndex(after: DictionaryIndex<Key, Value>)
Added Dictionary.index(_: DictionaryIndex<Key, Value>, offsetBy: Int) -> DictionaryIndex<Key, Value>
Added Dictionary.index(_: DictionaryIndex<Key, Value>, offsetBy: Int, limitedBy: DictionaryIndex<Key, Value>) -> DictionaryIndex<Key, Value>?
Added Dictionary.index(after: DictionaryIndex<Key, Value>) -> DictionaryIndex<Key, Value>
Added Dictionary.indices
Added Dictionary.isEmpty
Added Dictionary.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (key: Key, value: Value)>(_: OtherSequence, by: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
Added Dictionary.map<T>(_: (Key, Value) throws -> T) rethrows -> [T]
Added Dictionary.map<T>(_: (Key, Value) throws -> T) rethrows -> [T]
Added Dictionary.remove(at: DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
Added Dictionary.removeValue<ConcreteKey : Hashable>(forKey: ConcreteKey) -> Value?
Added Dictionary.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (key: Key, value: Value)>(with: PossiblePrefix, by: ((key: Key, value: Value), (key: Key, value: Value)) throws -> Bool) rethrows -> Bool
Added Dictionary.subscript(_: ClosedRange<DictionaryIndex<Key, Value>>) -> Slice<Dictionary<Key, Value>>
Added Dictionary.subscript(_: DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
Added Dictionary.subscript(_: _Hashable) -> Value?
Added Dictionary.subscript(_: Range<DictionaryIndex<Key, Value>>) -> Slice<Dictionary<Key, Value>>
Added Dictionary.underestimatedCount
Added Dictionary.underestimatedCount
Added Dictionary.updateValue<ConcreteKey : Hashable>(_: Value, forKey: ConcreteKey) -> Value?
Added Double.add(_: Double)
Added Double.divide(by: Double)
Added Double.multiply(by: Double)
Added Double.pi
Added Double.subtract(_: Double)
Added EmptyCollection.count
Added EmptyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added EmptyCollection.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyCollection.flatMap<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.indices
Added EmptyCollection.joined() -> FlattenCollection<EmptyCollection<Element>>
Added EmptyCollection.joined() -> FlattenSequence<EmptyCollection<Element>>
Added EmptyCollection.joined() -> FlattenBidirectionalCollection<EmptyCollection<Element>>
Added EmptyCollection.lazy
Added EmptyCollection.lazy
Added EmptyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence) -> Bool
Added EmptyCollection.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Element>(_: OtherSequence, by: (Element, Element) throws -> Bool) rethrows -> Bool
Added EmptyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added EmptyCollection.map<T>(_: (Element) throws -> T) rethrows -> [T]
Added EmptyCollection.partition(by: (Element) throws -> Bool) rethrows -> Int
Added EmptyCollection.partition(by: (Element) throws -> Bool) rethrows -> Int
Added EmptyCollection.sorted() -> [Element]
Added EmptyCollection.sorted() -> [Element]
Added EmptyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [AnySequence<Element>]
Added EmptyCollection.split(separator: Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [EmptyCollection<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(_: ClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: ClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: CountableClosedRange<Int>) -> EmptyCollection<Element>
Added EmptyCollection.subscript(_: Range<Int>) -> MutableSlice<EmptyCollection<Element>>
Added EmptyCollection.underestimatedCount
Added EmptyCollection.underestimatedCount
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.flatMap<ElementOfResult>(_: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EmptyIterator.flatMap<SegmentOfResult : Sequence>(_: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
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.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 EnumeratedIterator.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (offset: Int, element: Base.Element)>(_: OtherSequence, by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedIterator.flatMap<ElementOfResult>(_: (Int, Base.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EnumeratedIterator.flatMap<SegmentOfResult : Sequence>(_: (Int, Base.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EnumeratedIterator.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (offset: Int, element: Base.Element)>(_: OtherSequence, by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedIterator.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (offset: Int, element: Base.Element)>(with: PossiblePrefix, by: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedSequence.contains(where: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> Bool
Added EnumeratedSequence.elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (offset: Int, element: Base.Iterator.Element)>(_: OtherSequence, by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedSequence.filter(_: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> [(offset: Int, element: Base.Iterator.Element)]
Added EnumeratedSequence.first(where: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> (offset: Int, element: Base.Iterator.Element)?
Added EnumeratedSequence.flatMap<SegmentOfResult : Sequence>(_: (Int, Base.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added EnumeratedSequence.flatMap<ElementOfResult>(_: (Int, Base.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added EnumeratedSequence.forEach(_: (Int, Base.Iterator.Element) throws -> Void) rethrows
Added EnumeratedSequence.lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == (offset: Int, element: Base.Iterator.Element)>(_: OtherSequence, by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) throws -> Bool) rethrows -> Bool
Added EnumeratedSequence.map<T>(_: (Int, Base.Iterator.Element) throws -> T) rethrows -> [T]
Added EnumeratedSequence.max(by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) throws -> Bool) rethrows -> (offset: Int, element: Base.Iterator.Element)?
Added EnumeratedSequence.min(by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) throws -> Bool) rethrows -> (offset: Int, element: Base.Iterator.Element)?
Added EnumeratedSequence.reduce<Result>(_: Result, _: (Result, (offset: Int, element: Base.Iterator.Element)) throws -> Result) rethrows -> Result
Added EnumeratedSequence.sorted(by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) -> Bool) -> [(offset: Int, element: Base.Iterator.Element)]
Added EnumeratedSequence.split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Int, Base.Iterator.Element) throws -> Bool) rethrows -> [AnySequence<(offset: Int, element: Base.Iterator.Element)>]
Added EnumeratedSequence.starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == (offset: Int, element: Base.Iterator.Element)>(with: PossiblePrefix, by: ((offset: Int, element: Base.Iterator.Element), (offset: Int, element: Base.Iterator.Element)) throws -> Bool) rethrows -> Bool
Added Error
Added ExpressibleByArrayLiteral.init(arrayLiteral: Self.Element)
Added ExpressibleByStringInterpolation
Added ExpressibleByStringInterpolation.init(stringInterpolation: Self)
Added ExpressibleByStringInterpolation.init<T>(stringInterpolationSegment: T)
Added FlattenBidirectionalCollection.contains(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Bool
Added FlattenBidirectionalCollection.count
Added FlattenBidirectionalCollection.distance(from: FlattenBidirectionalCollectionIndex<Base>, to: FlattenBidirectionalCollectionIndex<Base>) -> Base.IndexDistance
Added FlattenBidirectionalCollection.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.filter(_: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> [Base.Iterator.Element.Iterator.Element]
Added FlattenBidirectionalCollection.first
Added FlattenBidirectionalCollection.first(where: (Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> Base.Iterator.Element.Iterator.Element?
Added FlattenBidirectionalCollection.flatMap<ElementOfResult>(_: (Base.Iterator.Element.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Added FlattenBidirectionalCollection.flatMap<SegmentOfResult : Sequence>(_: (Base.Iterator.Element.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
Added FlattenBidirectionalCollection.forEach(_: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows
Added FlattenBidirectionalCollection.formIndex(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance)
Added FlattenBidirectionalCollection.formIndex(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: FlattenBidirectionalCollectionIndex<Base>) -> Bool
Added FlattenBidirectionalCollection.formIndex(after: FlattenBidirectionalCollectionIndex<Base>)
Added FlattenBidirectionalCollection.formIndex(before: FlattenBidirectionalCollectionIndex<Base>)
Added FlattenBidirectionalCollection.index(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance) -> FlattenBidirectionalCollectionIndex<Base>
Added FlattenBidirectionalCollection.index(_: FlattenBidirectionalCollectionIndex<Base>, offsetBy: Base.IndexDistance, limitedBy: FlattenBidirectionalCollectionIndex<Base>) -> FlattenBidirectionalCollectionIndex<Base>?
Added FlattenBidirectionalCollection.index(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.joined() -> FlattenSequence<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined() -> FlattenCollection<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.joined() -> FlattenBidirectionalCollection<FlattenBidirectionalCollection<Base>>
Added FlattenBidirectionalCollection.last
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.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(by: (Base.Iterator.Element.Iterator.Element, Base.Iterator.Element.Iterator.Element) throws -> Bool) rethrows -> 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.reduce<Result>(_: Result, _: (Result, Base.Iterator.Element.Iterator.Element) throws -> Result) rethrows -> Result
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) -> [AnySequence<Base.Iterator.Element.Iterator.Element>]
Added FlattenBidirectionalCollection.split(separator: Base.Iterator.Element.Iterator.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [BidirectionalSlice<FlattenBidirectionalCollection<Base>>]
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.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(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>>