Swift Changes for Swift
Swift
Modified AnyBidirectionalCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct AnyBidirectionalCollection<Element> : AnyCollectionType, CollectionType, Indexable, SequenceType { typealias T = Element init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyBidirectionalCollection<Element>) init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyRandomAccessCollection<Element>) init?(_ other: AnyForwardCollection<Element>) func generate() -> AnyGenerator<Element> var startIndex: AnyBidirectionalIndex { get } var endIndex: AnyBidirectionalIndex { get } subscript (_ position: AnyBidirectionalIndex) -> Element { get } var count: IntMax { get } } extension AnyBidirectionalCollection { func underestimateCount() -> Int } | AnyCollectionType, CollectionType, Indexable, SequenceType |
To | struct AnyBidirectionalCollection<Element> : AnyCollectionType { typealias T = Element init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyBidirectionalCollection<Element>) init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyRandomAccessCollection<Element>) init?(_ other: AnyForwardCollection<Element>) func generate() -> AnyGenerator<Element> var startIndex: AnyBidirectionalIndex { get } var endIndex: AnyBidirectionalIndex { get } subscript (_ position: AnyBidirectionalIndex) -> Element { get } var count: IntMax { get } } extension AnyBidirectionalCollection { func underestimateCount() -> Int } | AnyCollectionType |
Modified AnyBidirectionalIndex [struct]
Declaration | Protocols | |
---|---|---|
From | struct AnyBidirectionalIndex : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType { typealias Distance = IntMax init<BaseIndex : BidirectionalIndexType>(_ base: BaseIndex) func successor() -> AnyBidirectionalIndex func predecessor() -> AnyBidirectionalIndex } | BidirectionalIndexType, Equatable, ForwardIndexType |
To | struct AnyBidirectionalIndex : BidirectionalIndexType { typealias Distance = IntMax init<BaseIndex : BidirectionalIndexType>(_ base: BaseIndex) func successor() -> AnyBidirectionalIndex func predecessor() -> AnyBidirectionalIndex } | BidirectionalIndexType |
Modified AnyForwardCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct AnyForwardCollection<Element> : AnyCollectionType, CollectionType, Indexable, SequenceType { typealias T = Element init<C : CollectionType where C.Index : ForwardIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyForwardCollection<Element>) init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyBidirectionalCollection<Element>) init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyRandomAccessCollection<Element>) func generate() -> AnyGenerator<Element> var startIndex: AnyForwardIndex { get } var endIndex: AnyForwardIndex { get } subscript (_ position: AnyForwardIndex) -> Element { get } var count: IntMax { get } } extension AnyForwardCollection { func underestimateCount() -> Int } | AnyCollectionType, CollectionType, Indexable, SequenceType |
To | struct AnyForwardCollection<Element> : AnyCollectionType { typealias T = Element init<C : CollectionType where C.Index : ForwardIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyForwardCollection<Element>) init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyBidirectionalCollection<Element>) init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyRandomAccessCollection<Element>) func generate() -> AnyGenerator<Element> var startIndex: AnyForwardIndex { get } var endIndex: AnyForwardIndex { get } subscript (_ position: AnyForwardIndex) -> Element { get } var count: IntMax { get } } extension AnyForwardCollection { func underestimateCount() -> Int } | AnyCollectionType |
Modified AnyForwardIndex [struct]
Declaration | Protocols | |
---|---|---|
From | struct AnyForwardIndex : ForwardIndexType, _Incrementable, Equatable { typealias Distance = IntMax init<BaseIndex : ForwardIndexType>(_ base: BaseIndex) func successor() -> AnyForwardIndex } | Equatable, ForwardIndexType |
To | struct AnyForwardIndex : ForwardIndexType { typealias Distance = IntMax init<BaseIndex : ForwardIndexType>(_ base: BaseIndex) func successor() -> AnyForwardIndex } | ForwardIndexType |
Modified AnyGenerator
Protocols | |
---|---|
From | AnyObject, GeneratorType, SequenceType |
To | GeneratorType, SequenceType |
Modified AnyRandomAccessCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct AnyRandomAccessCollection<Element> : AnyCollectionType, CollectionType, Indexable, SequenceType { typealias T = Element init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyRandomAccessCollection<Element>) init?(_ other: AnyForwardCollection<Element>) init?(_ other: AnyBidirectionalCollection<Element>) func generate() -> AnyGenerator<Element> var startIndex: AnyRandomAccessIndex { get } var endIndex: AnyRandomAccessIndex { get } subscript (_ position: AnyRandomAccessIndex) -> Element { get } var count: IntMax { get } } extension AnyRandomAccessCollection { func underestimateCount() -> Int } | AnyCollectionType, CollectionType, Indexable, SequenceType |
To | struct AnyRandomAccessCollection<Element> : AnyCollectionType { typealias T = Element init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C) init(_ other: AnyRandomAccessCollection<Element>) init?(_ other: AnyForwardCollection<Element>) init?(_ other: AnyBidirectionalCollection<Element>) func generate() -> AnyGenerator<Element> var startIndex: AnyRandomAccessIndex { get } var endIndex: AnyRandomAccessIndex { get } subscript (_ position: AnyRandomAccessIndex) -> Element { get } var count: IntMax { get } } extension AnyRandomAccessCollection { func underestimateCount() -> Int } | AnyCollectionType |
Modified AnyRandomAccessIndex [struct]
Declaration | Protocols | |
---|---|---|
From | struct AnyRandomAccessIndex : ForwardIndexType, _Incrementable, Equatable, RandomAccessIndexType, BidirectionalIndexType, Strideable, Comparable, _Strideable, _RandomAccessAmbiguity { typealias Distance = IntMax init<BaseIndex : RandomAccessIndexType>(_ base: BaseIndex) func successor() -> AnyRandomAccessIndex func predecessor() -> AnyRandomAccessIndex func distanceTo(_ other: AnyRandomAccessIndex) -> Distance func advancedBy(_ amount: Distance) -> AnyRandomAccessIndex func advancedBy(_ amount: Distance, limit limit: AnyRandomAccessIndex) -> AnyRandomAccessIndex } | BidirectionalIndexType, Comparable, Equatable, ForwardIndexType, RandomAccessIndexType, Strideable |
To | struct AnyRandomAccessIndex : RandomAccessIndexType { typealias Distance = IntMax init<BaseIndex : RandomAccessIndexType>(_ base: BaseIndex) func successor() -> AnyRandomAccessIndex func predecessor() -> AnyRandomAccessIndex func distanceTo(_ other: AnyRandomAccessIndex) -> Distance func advancedBy(_ amount: Distance) -> AnyRandomAccessIndex func advancedBy(_ amount: Distance, limit limit: AnyRandomAccessIndex) -> AnyRandomAccessIndex } | RandomAccessIndexType |
Modified Array [struct]
Declaration | Protocols | |
---|---|---|
From | struct Array<Element> : CollectionType, Indexable, SequenceType, MutableCollectionType, MutableIndexable, _DestructorSafeContainer { typealias T = Element var startIndex: Int { get } var endIndex: Int { get } subscript (_ index: Int) -> Element subscript (_ subRange: Range<Int>) -> ArraySlice<Element> } extension Array : _ObjectiveCBridgeable { } extension Array : ArrayLiteralConvertible { init(arrayLiteral elements: Element...) } extension Array : _ArrayType, MutableSliceable, RangeReplaceableCollectionType { init() init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S) init(count count: Int, repeatedValue repeatedValue: Element) var count: Int { get } var capacity: Int { get } mutating func reserveCapacity(_ minimumCapacity: Int) mutating func append(_ newElement: Element) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S) mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C) mutating func removeLast() -> Element mutating func insert(_ newElement: Element, atIndex i: Int) mutating func removeAtIndex(_ index: Int) -> Element mutating func removeAll(keepCapacity keepCapacity: Bool = default) func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element] } extension Array : _Reflectable { } extension Array : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension Array { @rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R @rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R } extension Array { mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C) } extension Array { mutating func popLast() -> Element? } | ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Indexable, MutableCollectionType, MutableIndexable, MutableSliceable, RangeReplaceableCollectionType, SequenceType |
To | struct Array<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer { typealias T = Element var startIndex: Int { get } var endIndex: Int { get } subscript (_ index: Int) -> Element subscript (_ subRange: Range<Int>) -> ArraySlice<Element> } extension Array : _ObjectiveCBridgeable { } extension Array : ArrayLiteralConvertible { init(arrayLiteral elements: Element...) } extension Array : _ArrayType { init() init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S) init(count count: Int, repeatedValue repeatedValue: Element) var count: Int { get } var capacity: Int { get } mutating func reserveCapacity(_ minimumCapacity: Int) mutating func append(_ newElement: Element) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S) mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C) mutating func removeLast() -> Element mutating func insert(_ newElement: Element, atIndex i: Int) mutating func removeAtIndex(_ index: Int) -> Element mutating func removeAll(keepCapacity keepCapacity: Bool = default) func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element] } extension Array : _Reflectable { } extension Array : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension Array { func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R } extension Array { mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C) } extension Array { mutating func popLast() -> Element? } | ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, MutableCollectionType |
Modified Array.withUnsafeBufferPointer<R>(_: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
Declaration | |
---|---|
From | @rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R |
To | func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R |
Modified Array.withUnsafeMutableBufferPointer<R>(_: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
Declaration | |
---|---|
From | @rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R |
To | mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R |
Modified ArraySlice [struct]
Declaration | Protocols | |
---|---|---|
From | struct ArraySlice<Element> : Indexable, SequenceType, CollectionType, MutableCollectionType, MutableIndexable, _DestructorSafeContainer { typealias T = Element var startIndex: Int { get } var endIndex: Int { get } subscript (_ index: Int) -> Element subscript (_ subRange: Range<Int>) -> ArraySlice<Element> } extension ArraySlice : ArrayLiteralConvertible { init(arrayLiteral elements: Element...) } extension ArraySlice : _ArrayType, MutableSliceable, RangeReplaceableCollectionType { init() init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S) init(count count: Int, repeatedValue repeatedValue: Element) var count: Int { get } var capacity: Int { get } mutating func reserveCapacity(_ minimumCapacity: Int) mutating func append(_ newElement: Element) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S) mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C) mutating func removeLast() -> Element mutating func insert(_ newElement: Element, atIndex i: Int) mutating func removeAtIndex(_ index: Int) -> Element mutating func removeAll(keepCapacity keepCapacity: Bool = default) func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> ArraySlice<Element> } extension ArraySlice : _Reflectable { } extension ArraySlice : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension ArraySlice { @rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R @rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R } extension ArraySlice { mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C) } | ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Indexable, MutableCollectionType, MutableIndexable, MutableSliceable, RangeReplaceableCollectionType, SequenceType |
To | struct ArraySlice<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer { typealias T = Element var startIndex: Int { get } var endIndex: Int { get } subscript (_ index: Int) -> Element subscript (_ subRange: Range<Int>) -> ArraySlice<Element> } extension ArraySlice : ArrayLiteralConvertible { init(arrayLiteral elements: Element...) } extension ArraySlice : _ArrayType { init() init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S) init(count count: Int, repeatedValue repeatedValue: Element) var count: Int { get } var capacity: Int { get } mutating func reserveCapacity(_ minimumCapacity: Int) mutating func append(_ newElement: Element) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S) mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C) mutating func removeLast() -> Element mutating func insert(_ newElement: Element, atIndex i: Int) mutating func removeAtIndex(_ index: Int) -> Element mutating func removeAll(keepCapacity keepCapacity: Bool = default) func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> ArraySlice<Element> } extension ArraySlice : _Reflectable { } extension ArraySlice : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension ArraySlice { func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R } extension ArraySlice { mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C) } | ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, MutableCollectionType |
Modified ArraySlice.withUnsafeBufferPointer<R>(_: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
Declaration | |
---|---|
From | @rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R |
To | func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R |
Modified ArraySlice.withUnsafeMutableBufferPointer<R>(_: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
Declaration | |
---|---|
From | @rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R |
To | mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R |
Modified Bit [enum]
Declaration | Protocols | |
---|---|---|
From | enum Bit : Int, _Incrementable, Comparable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity, _Reflectable { typealias Distance = Int case Zero case One func successor() -> Bit func predecessor() -> Bit func distanceTo(_ other: Bit) -> Int func advancedBy(_ n: Distance) -> Bit } extension Bit : IntegerArithmeticType, _IntegerArithmeticType { static func addWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool) static func subtractWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool) static func multiplyWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool) static func divideWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool) static func remainderWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool) func toIntMax() -> IntMax } | BidirectionalIndexType, Comparable, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, RandomAccessIndexType, RawRepresentable, Strideable |
To | enum Bit : Int, Comparable, RandomAccessIndexType, _Reflectable { typealias Distance = Int case Zero case One func successor() -> Bit func predecessor() -> Bit func distanceTo(_ other: Bit) -> Int func advancedBy(_ n: Distance) -> Bit } extension Bit : IntegerArithmeticType { static func addWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool) static func subtractWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool) static func multiplyWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool) static func divideWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool) static func remainderWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool) func toIntMax() -> IntMax } | Comparable, IntegerArithmeticType, RandomAccessIndexType |
Modified Character [struct]
Declaration | Protocols | |
---|---|---|
From | struct Character : Hashable, Equatable, ExtendedGraphemeClusterLiteralConvertible, UnicodeScalarLiteralConvertible, Comparable { init(_ scalar: UnicodeScalar) init(_builtinUnicodeScalarLiteral value: Builtin.Int32) init(unicodeScalarLiteral value: Character) init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1) init(extendedGraphemeClusterLiteral value: Character) init(_ s: String) var hashValue: Int { get } } extension Character : CustomDebugStringConvertible { var debugDescription: String { get } } extension Character : _Reflectable { } extension Character : Streamable { func writeTo<Target : OutputStreamType>(inout _ target: Target) } | Comparable, CustomDebugStringConvertible, Equatable, ExtendedGraphemeClusterLiteralConvertible, Hashable, Streamable, UnicodeScalarLiteralConvertible |
To | struct Character : ExtendedGraphemeClusterLiteralConvertible, Equatable, Hashable, Comparable { init(_ scalar: UnicodeScalar) init(_builtinUnicodeScalarLiteral value: Builtin.Int32) init(unicodeScalarLiteral value: Character) init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1) init(extendedGraphemeClusterLiteral value: Character) init(_ s: String) var hashValue: Int { get } } extension Character : CustomDebugStringConvertible { var debugDescription: String { get } } extension Character : _Reflectable { } extension Character : Streamable { func writeTo<Target : OutputStreamType>(inout _ target: Target) } | Comparable, CustomDebugStringConvertible, Equatable, ExtendedGraphemeClusterLiteralConvertible, Hashable, Streamable |
Modified CollectionOfOne [struct]
Declaration | Protocols | |
---|---|---|
From | struct CollectionOfOne<Element> : CollectionType, Indexable, SequenceType { typealias T = Element typealias Index = Bit init(_ element: Element) var startIndex: Index { get } var endIndex: Index { get } func generate() -> GeneratorOfOne<Element> subscript (_ position: Index) -> Element { get } var count: Int { get } } extension CollectionOfOne : _Reflectable { } | CollectionType, Indexable, SequenceType |
To | struct CollectionOfOne<Element> : CollectionType { typealias T = Element typealias Index = Bit init(_ element: Element) var startIndex: Index { get } var endIndex: Index { get } func generate() -> GeneratorOfOne<Element> subscript (_ position: Index) -> Element { get } var count: Int { get } } extension CollectionOfOne : _Reflectable { } | CollectionType |
Modified CollectionType.indexOf(_: (Self.Generator.Element) throws -> Bool) rethrows -> Self.Index?
Declaration | |
---|---|
From | @warn_unused_result @rethrows func indexOf(@noescape _ predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Self.Index? |
To | @warn_unused_result func indexOf(@noescape _ predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Self.Index? |
Modified CollectionType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Declaration | |
---|---|
From | @warn_unused_result @rethrows func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T] |
To | @warn_unused_result func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T] |
Modified CollectionType.split(_: Int, allowEmptySlices: Bool, isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Declaration | |
---|---|
From | @warn_unused_result @rethrows func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence] |
To | @warn_unused_result func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence] |
Modified ContiguousArray [struct]
Declaration | Protocols | |
---|---|---|
From | struct ContiguousArray<Element> : CollectionType, Indexable, SequenceType, MutableCollectionType, MutableIndexable, _DestructorSafeContainer { typealias T = Element var startIndex: Int { get } var endIndex: Int { get } subscript (_ index: Int) -> Element subscript (_ subRange: Range<Int>) -> ArraySlice<Element> } extension ContiguousArray : ArrayLiteralConvertible { init(arrayLiteral elements: Element...) } extension ContiguousArray : _ArrayType, MutableSliceable, RangeReplaceableCollectionType { init() init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S) init(count count: Int, repeatedValue repeatedValue: Element) var count: Int { get } var capacity: Int { get } mutating func reserveCapacity(_ minimumCapacity: Int) mutating func append(_ newElement: Element) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S) mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C) mutating func removeLast() -> Element mutating func insert(_ newElement: Element, atIndex i: Int) mutating func removeAtIndex(_ index: Int) -> Element mutating func removeAll(keepCapacity keepCapacity: Bool = default) func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> ContiguousArray<Element> } extension ContiguousArray : _Reflectable { } extension ContiguousArray : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension ContiguousArray { @rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R @rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R } extension ContiguousArray { mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C) } extension ContiguousArray { mutating func popLast() -> Element? } | ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Indexable, MutableCollectionType, MutableIndexable, MutableSliceable, RangeReplaceableCollectionType, SequenceType |
To | struct ContiguousArray<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer { typealias T = Element var startIndex: Int { get } var endIndex: Int { get } subscript (_ index: Int) -> Element subscript (_ subRange: Range<Int>) -> ArraySlice<Element> } extension ContiguousArray : ArrayLiteralConvertible { init(arrayLiteral elements: Element...) } extension ContiguousArray : _ArrayType { init() init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S) init(count count: Int, repeatedValue repeatedValue: Element) var count: Int { get } var capacity: Int { get } mutating func reserveCapacity(_ minimumCapacity: Int) mutating func append(_ newElement: Element) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S) mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C) mutating func removeLast() -> Element mutating func insert(_ newElement: Element, atIndex i: Int) mutating func removeAtIndex(_ index: Int) -> Element mutating func removeAll(keepCapacity keepCapacity: Bool = default) func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> ContiguousArray<Element> } extension ContiguousArray : _Reflectable { } extension ContiguousArray : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension ContiguousArray { func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R } extension ContiguousArray { mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C) } extension ContiguousArray { mutating func popLast() -> Element? } | ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, MutableCollectionType |
Modified ContiguousArray.withUnsafeBufferPointer<R>(_: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
Declaration | |
---|---|
From | @rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R |
To | func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R |
Modified ContiguousArray.withUnsafeMutableBufferPointer<R>(_: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
Declaration | |
---|---|
From | @rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R |
To | mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R |
Modified Dictionary [struct]
Declaration | Protocols | |
---|---|---|
From | struct Dictionary<Key : Hashable, Value> : CollectionType, Indexable, SequenceType, DictionaryLiteralConvertible { typealias Element = (Key, Value) typealias Index = DictionaryIndex<Key, Value> init() init(minimumCapacity minimumCapacity: Int) var startIndex: DictionaryIndex<Key, Value> { get } var endIndex: DictionaryIndex<Key, Value> { get } @warn_unused_result func indexForKey(_ key: Key) -> DictionaryIndex<Key, Value>? subscript (_ position: DictionaryIndex<Key, Value>) -> (Key, Value) { get } subscript (_ key: Key) -> Value? mutating func updateValue(_ value: Value, forKey key: Key) -> Value? mutating func removeAtIndex(_ index: DictionaryIndex<Key, Value>) -> (Key, Value) mutating func removeValueForKey(_ key: Key) -> Value? mutating func removeAll(keepCapacity keepCapacity: Bool = default) var count: Int { get } func generate() -> DictionaryGenerator<Key, Value> init(dictionaryLiteral elements: (Key, Value)...) var keys: LazyMapCollection<[Key : Value], Key> { get } var values: LazyMapCollection<[Key : Value], Value> { get } var isEmpty: Bool { get } } extension Dictionary : _ObjectiveCBridgeable { } extension Dictionary : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension Dictionary : _Reflectable { } extension Dictionary { mutating func popFirst() -> (Key, Value)? } | CollectionType, CustomDebugStringConvertible, CustomStringConvertible, DictionaryLiteralConvertible, Indexable, SequenceType |
To | struct Dictionary<Key : Hashable, Value> : CollectionType, DictionaryLiteralConvertible { typealias Element = (Key, Value) typealias Index = DictionaryIndex<Key, Value> init() init(minimumCapacity minimumCapacity: Int) var startIndex: DictionaryIndex<Key, Value> { get } var endIndex: DictionaryIndex<Key, Value> { get } @warn_unused_result func indexForKey(_ key: Key) -> DictionaryIndex<Key, Value>? subscript (_ position: DictionaryIndex<Key, Value>) -> (Key, Value) { get } subscript (_ key: Key) -> Value? mutating func updateValue(_ value: Value, forKey key: Key) -> Value? mutating func removeAtIndex(_ index: DictionaryIndex<Key, Value>) -> (Key, Value) mutating func removeValueForKey(_ key: Key) -> Value? mutating func removeAll(keepCapacity keepCapacity: Bool = default) var count: Int { get } func generate() -> DictionaryGenerator<Key, Value> init(dictionaryLiteral elements: (Key, Value)...) var keys: LazyMapCollection<[Key : Value], Key> { get } var values: LazyMapCollection<[Key : Value], Value> { get } var isEmpty: Bool { get } } extension Dictionary : _ObjectiveCBridgeable { } extension Dictionary : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension Dictionary : _Reflectable { } extension Dictionary { mutating func popFirst() -> (Key, Value)? } | CollectionType, CustomDebugStringConvertible, CustomStringConvertible, DictionaryLiteralConvertible |
Modified DictionaryIndex [struct]
Declaration | Protocols | |
---|---|---|
From | struct DictionaryIndex<Key : Hashable, Value> : ForwardIndexType, _Incrementable, Equatable, Comparable { func successor() -> DictionaryIndex<Key, Value> } | Comparable, Equatable, ForwardIndexType |
To | struct DictionaryIndex<Key : Hashable, Value> : ForwardIndexType, Comparable { func successor() -> DictionaryIndex<Key, Value> } | Comparable, ForwardIndexType |
Modified DictionaryLiteral [struct]
Declaration | Protocols | |
---|---|---|
From | struct DictionaryLiteral<Key, Value> : DictionaryLiteralConvertible { init(dictionaryLiteral elements: (Key, Value)...) } extension DictionaryLiteral : CollectionType, Indexable, SequenceType { var startIndex: Int { get } var endIndex: Int { get } typealias Element = (Key, Value) subscript (_ position: Int) -> (Key, Value) { get } } | CollectionType, DictionaryLiteralConvertible, Indexable, SequenceType |
To | struct DictionaryLiteral<Key, Value> : DictionaryLiteralConvertible { init(dictionaryLiteral elements: (Key, Value)...) } extension DictionaryLiteral : CollectionType { var startIndex: Int { get } var endIndex: Int { get } typealias Element = (Key, Value) subscript (_ position: Int) -> (Key, Value) { get } } | CollectionType, DictionaryLiteralConvertible |
Modified Double [struct]
Declaration | Protocols | |
---|---|---|
From | struct Double { var value: Builtin.FPIEEE64 init() init(_bits v: Builtin.FPIEEE64) init(_ value: Double) } extension Double { init(_ value: CGFloat) } extension Double : _ObjectiveCBridgeable { init(_ number: NSNumber) } extension Double : CustomStringConvertible { var description: String { get } } extension Double : FloatingPointType { static var infinity: Double { get } static var NaN: Double { get } static var quietNaN: Double { get } var isSignMinus: Bool { get } var isNormal: Bool { get } var isFinite: Bool { get } var isZero: Bool { get } var isSubnormal: Bool { get } var isInfinite: Bool { get } var isNaN: Bool { get } var isSignaling: Bool { get } } extension Double { var floatingPointClass: FloatingPointClassification { get } } extension Double : IntegerLiteralConvertible { init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int64) } extension Double { init(_builtinFloatLiteral value: Builtin.FPIEEE64) } extension Double : FloatLiteralConvertible { init(floatLiteral value: Double) } extension Double : Comparable, Equatable { } extension Double : Hashable { var hashValue: Int { get } } extension Double : SignedNumberType, AbsoluteValuable { @warn_unused_result static func abs(_ x: Double) -> Double } extension Double { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(_ v: Int64) init(_ v: UInt) init(_ v: Int) } extension Double { init(_ other: Float) } extension Double : Strideable, _Strideable { func distanceTo(_ other: Double) -> Double func advancedBy(_ amount: Double) -> Double } extension Double { init?(_ text: String) } extension Double : _Reflectable { } extension Double : _CVarArgPassedAsDouble, CVarArgType, _CVarArgAlignedType { } | AbsoluteValuable, CVarArgType, Comparable, CustomStringConvertible, Equatable, FloatLiteralConvertible, FloatingPointType, Hashable, IntegerLiteralConvertible, SignedNumberType, Strideable |
To | struct Double { var value: Builtin.FPIEEE64 init() init(_bits v: Builtin.FPIEEE64) init(_ value: Double) } extension Double { init(_ value: CGFloat) } extension Double : _ObjectiveCBridgeable { init(_ number: NSNumber) } extension Double : CustomStringConvertible { var description: String { get } } extension Double : FloatingPointType { static var infinity: Double { get } static var NaN: Double { get } static var quietNaN: Double { get } var isSignMinus: Bool { get } var isNormal: Bool { get } var isFinite: Bool { get } var isZero: Bool { get } var isSubnormal: Bool { get } var isInfinite: Bool { get } var isNaN: Bool { get } var isSignaling: Bool { get } } extension Double { var floatingPointClass: FloatingPointClassification { get } } extension Double : IntegerLiteralConvertible { init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int64) } extension Double { init(_builtinFloatLiteral value: Builtin.FPIEEE64) } extension Double : FloatLiteralConvertible { init(floatLiteral value: Double) } extension Double : Comparable, Equatable { } extension Double : Hashable { var hashValue: Int { get } } extension Double : AbsoluteValuable { @warn_unused_result static func abs(_ x: Double) -> Double } extension Double { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(_ v: Int64) init(_ v: UInt) init(_ v: Int) } extension Double { init(_ other: Float) } extension Double : Strideable { func distanceTo(_ other: Double) -> Double func advancedBy(_ amount: Double) -> Double } extension Double { init?(_ text: String) } extension Double : _Reflectable { } extension Double : _CVarArgPassedAsDouble, _CVarArgAlignedType { } | AbsoluteValuable, Comparable, CustomStringConvertible, Equatable, FloatLiteralConvertible, FloatingPointType, Hashable, IntegerLiteralConvertible, Strideable |
Modified EmptyCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct EmptyCollection<Element> : CollectionType, Indexable, SequenceType { typealias T = Element typealias Index = Int init() var startIndex: Index { get } var endIndex: Index { get } func generate() -> EmptyGenerator<Element> subscript (_ position: Index) -> Element { get } var count: Int { get } } extension EmptyCollection : _Reflectable { } | CollectionType, Indexable, SequenceType |
To | struct EmptyCollection<Element> : CollectionType { typealias T = Element typealias Index = Int init() var startIndex: Index { get } var endIndex: Index { get } func generate() -> EmptyGenerator<Element> subscript (_ position: Index) -> Element { get } var count: Int { get } } extension EmptyCollection : _Reflectable { } | CollectionType |
Modified FlattenBidirectionalCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct FlattenBidirectionalCollection<Base : CollectionType where Base.Generator.Element : CollectionType, Base.Index : BidirectionalIndexType, Base.Generator.Element.Index : BidirectionalIndexType> : CollectionType, Indexable, SequenceType { typealias Index = FlattenBidirectionalCollectionIndex<Base> init(_ base: Base) func generate() -> FlattenGenerator<Base.Generator> var startIndex: FlattenBidirectionalCollectionIndex<Base> { get } var endIndex: FlattenBidirectionalCollectionIndex<Base> { get } subscript (_ position: FlattenBidirectionalCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element { get } func underestimateCount() -> Int } | CollectionType, Indexable, SequenceType |
To | struct FlattenBidirectionalCollection<Base : CollectionType where Base.Generator.Element : CollectionType, Base.Index : BidirectionalIndexType, Base.Generator.Element.Index : BidirectionalIndexType> : CollectionType { typealias Index = FlattenBidirectionalCollectionIndex<Base> init(_ base: Base) func generate() -> FlattenGenerator<Base.Generator> var startIndex: FlattenBidirectionalCollectionIndex<Base> { get } var endIndex: FlattenBidirectionalCollectionIndex<Base> { get } subscript (_ position: FlattenBidirectionalCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element { get } func underestimateCount() -> Int } | CollectionType |
Modified FlattenBidirectionalCollectionIndex [struct]
Declaration | Protocols | |
---|---|---|
From | struct FlattenBidirectionalCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType, BaseElements.Index : BidirectionalIndexType, BaseElements.Generator.Element.Index : BidirectionalIndexType> : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType { func successor() -> FlattenBidirectionalCollectionIndex<BaseElements> func predecessor() -> FlattenBidirectionalCollectionIndex<BaseElements> } | BidirectionalIndexType, Equatable, ForwardIndexType |
To | struct FlattenBidirectionalCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType, BaseElements.Index : BidirectionalIndexType, BaseElements.Generator.Element.Index : BidirectionalIndexType> : BidirectionalIndexType { func successor() -> FlattenBidirectionalCollectionIndex<BaseElements> func predecessor() -> FlattenBidirectionalCollectionIndex<BaseElements> } | BidirectionalIndexType |
Modified FlattenCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct FlattenCollection<Base : CollectionType where Base.Generator.Element : CollectionType> : CollectionType, Indexable, SequenceType { typealias Index = FlattenCollectionIndex<Base> init(_ base: Base) func generate() -> FlattenGenerator<Base.Generator> var startIndex: FlattenCollectionIndex<Base> { get } var endIndex: FlattenCollectionIndex<Base> { get } subscript (_ position: FlattenCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element { get } func underestimateCount() -> Int } | CollectionType, Indexable, SequenceType |
To | struct FlattenCollection<Base : CollectionType where Base.Generator.Element : CollectionType> : CollectionType { typealias Index = FlattenCollectionIndex<Base> init(_ base: Base) func generate() -> FlattenGenerator<Base.Generator> var startIndex: FlattenCollectionIndex<Base> { get } var endIndex: FlattenCollectionIndex<Base> { get } subscript (_ position: FlattenCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element { get } func underestimateCount() -> Int } | CollectionType |
Modified FlattenCollectionIndex [struct]
Declaration | Protocols | |
---|---|---|
From | struct FlattenCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType> : ForwardIndexType, _Incrementable, Equatable { func successor() -> FlattenCollectionIndex<BaseElements> } | Equatable, ForwardIndexType |
To | struct FlattenCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType> : ForwardIndexType { func successor() -> FlattenCollectionIndex<BaseElements> } | ForwardIndexType |
Modified Float [struct]
Declaration | Protocols | |
---|---|---|
From | struct Float { var value: Builtin.FPIEEE32 init() init(_bits v: Builtin.FPIEEE32) init(_ value: Float) } extension Float { init(_ value: CGFloat) } extension Float : _ObjectiveCBridgeable { init(_ number: NSNumber) } extension Float : CustomStringConvertible { var description: String { get } } extension Float : FloatingPointType { static var infinity: Float { get } static var NaN: Float { get } static var quietNaN: Float { get } var isSignMinus: Bool { get } var isNormal: Bool { get } var isFinite: Bool { get } var isZero: Bool { get } var isSubnormal: Bool { get } var isInfinite: Bool { get } var isNaN: Bool { get } var isSignaling: Bool { get } } extension Float { var floatingPointClass: FloatingPointClassification { get } } extension Float : IntegerLiteralConvertible { init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int64) } extension Float { init(_builtinFloatLiteral value: Builtin.FPIEEE64) } extension Float : FloatLiteralConvertible { init(floatLiteral value: Float) } extension Float : Comparable, Equatable { } extension Float : Hashable { var hashValue: Int { get } } extension Float : SignedNumberType, AbsoluteValuable { @warn_unused_result static func abs(_ x: Float) -> Float } extension Float { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(_ v: Int64) init(_ v: UInt) init(_ v: Int) } extension Float { init(_ other: Double) } extension Float : Strideable, _Strideable { func distanceTo(_ other: Float) -> Float func advancedBy(_ amount: Float) -> Float } extension Float { init?(_ text: String) } extension Float : _Reflectable { } extension Float : _CVarArgPassedAsDouble, CVarArgType, _CVarArgAlignedType { } | AbsoluteValuable, CVarArgType, Comparable, CustomStringConvertible, Equatable, FloatLiteralConvertible, FloatingPointType, Hashable, IntegerLiteralConvertible, SignedNumberType, Strideable |
To | struct Float { var value: Builtin.FPIEEE32 init() init(_bits v: Builtin.FPIEEE32) init(_ value: Float) } extension Float { init(_ value: CGFloat) } extension Float : _ObjectiveCBridgeable { init(_ number: NSNumber) } extension Float : CustomStringConvertible { var description: String { get } } extension Float : FloatingPointType { static var infinity: Float { get } static var NaN: Float { get } static var quietNaN: Float { get } var isSignMinus: Bool { get } var isNormal: Bool { get } var isFinite: Bool { get } var isZero: Bool { get } var isSubnormal: Bool { get } var isInfinite: Bool { get } var isNaN: Bool { get } var isSignaling: Bool { get } } extension Float { var floatingPointClass: FloatingPointClassification { get } } extension Float : IntegerLiteralConvertible { init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int64) } extension Float { init(_builtinFloatLiteral value: Builtin.FPIEEE64) } extension Float : FloatLiteralConvertible { init(floatLiteral value: Float) } extension Float : Comparable, Equatable { } extension Float : Hashable { var hashValue: Int { get } } extension Float : AbsoluteValuable { @warn_unused_result static func abs(_ x: Float) -> Float } extension Float { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(_ v: Int64) init(_ v: UInt) init(_ v: Int) } extension Float { init(_ other: Double) } extension Float : Strideable { func distanceTo(_ other: Float) -> Float func advancedBy(_ amount: Float) -> Float } extension Float { init?(_ text: String) } extension Float : _Reflectable { } extension Float : _CVarArgPassedAsDouble, _CVarArgAlignedType { } | AbsoluteValuable, Comparable, CustomStringConvertible, Equatable, FloatLiteralConvertible, FloatingPointType, Hashable, IntegerLiteralConvertible, Strideable |
Modified FloatingPointClassification [enum]
Protocols | |
---|---|
From | Equatable, Hashable |
To | Equatable |
Modified ImplicitlyUnwrappedOptional [enum]
Declaration | |
---|---|
From | enum ImplicitlyUnwrappedOptional<Wrapped> : _Reflectable, NilLiteralConvertible { case None case Some(Wrapped) typealias T = Wrapped init() init(_ some: Wrapped) init(_ v: Wrapped?) init(nilLiteral nilLiteral: ()) @warn_unused_result @rethrows func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U! @warn_unused_result @rethrows func flatMap<U>(@noescape _ f: (Wrapped) throws -> U!) rethrows -> U! } extension ImplicitlyUnwrappedOptional : CustomStringConvertible { var description: String { get } } extension ImplicitlyUnwrappedOptional : _ObjectiveCBridgeable { } |
To | enum ImplicitlyUnwrappedOptional<Wrapped> : _Reflectable, NilLiteralConvertible { case None case Some(Wrapped) typealias T = Wrapped init() init(_ some: Wrapped) init(_ v: Wrapped?) init(nilLiteral nilLiteral: ()) @warn_unused_result func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U! @warn_unused_result func flatMap<U>(@noescape _ f: (Wrapped) throws -> U!) rethrows -> U! } extension ImplicitlyUnwrappedOptional : CustomStringConvertible { var description: String { get } } extension ImplicitlyUnwrappedOptional : _ObjectiveCBridgeable { } |
Modified ImplicitlyUnwrappedOptional.flatMap<U>(_: (Wrapped) throws -> U!) rethrows -> U!
Declaration | |
---|---|
From | @warn_unused_result @rethrows func flatMap<U>(@noescape _ f: (Wrapped) throws -> U!) rethrows -> U! |
To | @warn_unused_result func flatMap<U>(@noescape _ f: (Wrapped) throws -> U!) rethrows -> U! |
Modified ImplicitlyUnwrappedOptional.map<U>(_: (Wrapped) throws -> U) rethrows -> U!
Declaration | |
---|---|
From | @warn_unused_result @rethrows func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U! |
To | @warn_unused_result func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U! |
Modified Int [struct]
Declaration | Protocols | |
---|---|---|
From | struct Int : Equatable, _SignedIntegerType, Comparable, _IntegerType, IntegerArithmeticType, _IntegerArithmeticType, IntegerType, SignedIntegerType { var value: Builtin.Int32 typealias Distance = Int init() init(_ v: Builtin.Word) init(_ value: Int) init(bigEndian value: Int) init(littleEndian value: Int) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int) var bigEndian: Int { get } var littleEndian: Int { get } var byteSwapped: Int { get } static var max: Int { get } static var min: Int { get } } extension Int { init(_ value: CGFloat) } extension Int : _ObjectiveCBridgeable { init(_ number: NSNumber) } extension Int : ForwardIndexType, _Incrementable, RandomAccessIndexType, BidirectionalIndexType, Strideable, _Strideable, _RandomAccessAmbiguity { func successor() -> Int func predecessor() -> Int func distanceTo(_ other: Int) -> Distance func advancedBy(_ n: Distance) -> Int } extension Int : Hashable { var hashValue: Int { get } } extension Int : CustomStringConvertible { var description: String { get } } extension Int { static func addWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func subtractWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func divideWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func remainderWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) func toIntMax() -> IntMax } extension Int : SignedNumberType, IntegerLiteralConvertible { } extension Int { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(bitPattern bitPattern: UInt) } extension Int : BitwiseOperationsType { static var allZeros: Int { get } } extension Int { init(_ other: Float) init(_ other: Double) } extension Int { init?(_ text: String, radix radix: Int = default) } extension Int : _Reflectable { } extension Int : MirrorPathType { } extension Int : CVarArgType { } | BidirectionalIndexType, BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, MirrorPathType, RandomAccessIndexType, SignedIntegerType, SignedNumberType, Strideable |
To | struct Int : SignedIntegerType, Comparable, Equatable { var value: Builtin.Int32 typealias Distance = Int init() init(_ v: Builtin.Word) init(_ value: Int) init(bigEndian value: Int) init(littleEndian value: Int) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int) var bigEndian: Int { get } var littleEndian: Int { get } var byteSwapped: Int { get } static var max: Int { get } static var min: Int { get } } extension Int { init(_ value: CGFloat) } extension Int : _ObjectiveCBridgeable { init(_ number: NSNumber) } extension Int : RandomAccessIndexType { func successor() -> Int func predecessor() -> Int func distanceTo(_ other: Int) -> Distance func advancedBy(_ n: Distance) -> Int } extension Int : Hashable { var hashValue: Int { get } } extension Int : CustomStringConvertible { var description: String { get } } extension Int { static func addWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func subtractWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func divideWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) static func remainderWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool) func toIntMax() -> IntMax } extension Int : SignedNumberType { } extension Int { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(bitPattern bitPattern: UInt) } extension Int : BitwiseOperationsType { static var allZeros: Int { get } } extension Int { init(_ other: Float) init(_ other: Double) } extension Int { init?(_ text: String, radix radix: Int = default) } extension Int : _Reflectable { } extension Int : MirrorPathType { } extension Int : CVarArgType { } | BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, MirrorPathType, RandomAccessIndexType, SignedIntegerType, SignedNumberType |
Modified Int16 [struct]
Declaration | Protocols | |
---|---|---|
From | struct Int16 : _IntegerArithmeticType, Comparable, Equatable, _SignedIntegerType, _IntegerType, IntegerArithmeticType, IntegerType, SignedIntegerType { var value: Builtin.Int16 typealias Distance = Int init() init(_ value: Int16) init(bigEndian value: Int16) init(littleEndian value: Int16) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int16) var bigEndian: Int16 { get } var littleEndian: Int16 { get } var byteSwapped: Int16 { get } static var max: Int16 { get } static var min: Int16 { get } } extension Int16 { init(_ value: CGFloat) } extension Int16 : Hashable { var hashValue: Int { get } } extension Int16 : CustomStringConvertible { var description: String { get } } extension Int16 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity { func successor() -> Int16 func predecessor() -> Int16 func distanceTo(_ other: Int16) -> Distance func advancedBy(_ n: Distance) -> Int16 } extension Int16 { static func addWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func subtractWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func divideWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func remainderWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) func toIntMax() -> IntMax } extension Int16 : SignedNumberType, IntegerLiteralConvertible { } extension Int16 { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ v: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: UInt16) } extension Int16 : BitwiseOperationsType { static var allZeros: Int16 { get } } extension Int16 { init(_ other: Float) init(_ other: Double) } extension Int16 { init?(_ text: String, radix radix: Int = default) } extension Int16 : _Reflectable { } extension Int16 : CVarArgType { } | BidirectionalIndexType, BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, RandomAccessIndexType, SignedIntegerType, SignedNumberType, Strideable |
To | struct Int16 : SignedIntegerType, Comparable, Equatable { var value: Builtin.Int16 typealias Distance = Int init() init(_ value: Int16) init(bigEndian value: Int16) init(littleEndian value: Int16) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int16) var bigEndian: Int16 { get } var littleEndian: Int16 { get } var byteSwapped: Int16 { get } static var max: Int16 { get } static var min: Int16 { get } } extension Int16 { init(_ value: CGFloat) } extension Int16 : Hashable { var hashValue: Int { get } } extension Int16 : CustomStringConvertible { var description: String { get } } extension Int16 : RandomAccessIndexType { func successor() -> Int16 func predecessor() -> Int16 func distanceTo(_ other: Int16) -> Distance func advancedBy(_ n: Distance) -> Int16 } extension Int16 { static func addWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func subtractWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func divideWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) static func remainderWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool) func toIntMax() -> IntMax } extension Int16 : SignedNumberType { } extension Int16 { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ v: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: UInt16) } extension Int16 : BitwiseOperationsType { static var allZeros: Int16 { get } } extension Int16 { init(_ other: Float) init(_ other: Double) } extension Int16 { init?(_ text: String, radix radix: Int = default) } extension Int16 : _Reflectable { } extension Int16 : CVarArgType { } | BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, SignedIntegerType, SignedNumberType |
Modified Int32 [struct]
Declaration | Protocols | |
---|---|---|
From | struct Int32 : _IntegerArithmeticType, Comparable, Equatable, _SignedIntegerType, _IntegerType, IntegerArithmeticType, IntegerType, SignedIntegerType { var value: Builtin.Int32 typealias Distance = Int init() init(_ value: Int32) init(bigEndian value: Int32) init(littleEndian value: Int32) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int32) var bigEndian: Int32 { get } var littleEndian: Int32 { get } var byteSwapped: Int32 { get } static var max: Int32 { get } static var min: Int32 { get } } extension Int32 { init(_ value: CGFloat) } extension Int32 : Hashable { var hashValue: Int { get } } extension Int32 : CustomStringConvertible { var description: String { get } } extension Int32 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity { func successor() -> Int32 func predecessor() -> Int32 func distanceTo(_ other: Int32) -> Distance func advancedBy(_ n: Distance) -> Int32 } extension Int32 { static func addWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func subtractWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func divideWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func remainderWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) func toIntMax() -> IntMax } extension Int32 : SignedNumberType, IntegerLiteralConvertible { } extension Int32 { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: UInt32) } extension Int32 : BitwiseOperationsType { static var allZeros: Int32 { get } } extension Int32 { init(_ other: Float) init(_ other: Double) } extension Int32 { init?(_ text: String, radix radix: Int = default) } extension Int32 : _Reflectable { } extension Int32 : CVarArgType { } | BidirectionalIndexType, BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, RandomAccessIndexType, SignedIntegerType, SignedNumberType, Strideable |
To | struct Int32 : SignedIntegerType, Comparable, Equatable { var value: Builtin.Int32 typealias Distance = Int init() init(_ value: Int32) init(bigEndian value: Int32) init(littleEndian value: Int32) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int32) var bigEndian: Int32 { get } var littleEndian: Int32 { get } var byteSwapped: Int32 { get } static var max: Int32 { get } static var min: Int32 { get } } extension Int32 { init(_ value: CGFloat) } extension Int32 : Hashable { var hashValue: Int { get } } extension Int32 : CustomStringConvertible { var description: String { get } } extension Int32 : RandomAccessIndexType { func successor() -> Int32 func predecessor() -> Int32 func distanceTo(_ other: Int32) -> Distance func advancedBy(_ n: Distance) -> Int32 } extension Int32 { static func addWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func subtractWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func divideWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) static func remainderWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool) func toIntMax() -> IntMax } extension Int32 : SignedNumberType { } extension Int32 { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: UInt32) } extension Int32 : BitwiseOperationsType { static var allZeros: Int32 { get } } extension Int32 { init(_ other: Float) init(_ other: Double) } extension Int32 { init?(_ text: String, radix radix: Int = default) } extension Int32 : _Reflectable { } extension Int32 : CVarArgType { } | BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, SignedIntegerType, SignedNumberType |
Modified Int64 [struct]
Declaration | Protocols | |
---|---|---|
From | struct Int64 : _SignedIntegerType, Comparable, Equatable, _IntegerType, IntegerArithmeticType, _IntegerArithmeticType, IntegerType, SignedIntegerType { var value: Builtin.Int64 typealias Distance = Int init() init(_ value: Int64) init(bigEndian value: Int64) init(littleEndian value: Int64) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int64) var bigEndian: Int64 { get } var littleEndian: Int64 { get } var byteSwapped: Int64 { get } static var max: Int64 { get } static var min: Int64 { get } } extension Int64 { init(_ value: CGFloat) } extension Int64 : Hashable { var hashValue: Int { get } } extension Int64 : CustomStringConvertible { var description: String { get } } extension Int64 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity { func successor() -> Int64 func predecessor() -> Int64 func distanceTo(_ other: Int64) -> Distance func advancedBy(_ n: Distance) -> Int64 } extension Int64 { static func addWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func subtractWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func divideWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func remainderWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) func toIntMax() -> IntMax } extension Int64 : SignedNumberType, IntegerLiteralConvertible { } extension Int64 { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(_ v: UInt) init(_ v: Int) init(bitPattern bitPattern: UInt64) } extension Int64 : BitwiseOperationsType { static var allZeros: Int64 { get } } extension Int64 { init(_ other: Float) init(_ other: Double) } extension Int64 { init?(_ text: String, radix radix: Int = default) } extension Int64 : _Reflectable { } extension Int64 : CVarArgType, _CVarArgAlignedType { } | BidirectionalIndexType, BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, RandomAccessIndexType, SignedIntegerType, SignedNumberType, Strideable |
To | struct Int64 : SignedIntegerType, Comparable, Equatable { var value: Builtin.Int64 typealias Distance = Int init() init(_ value: Int64) init(bigEndian value: Int64) init(littleEndian value: Int64) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int64) var bigEndian: Int64 { get } var littleEndian: Int64 { get } var byteSwapped: Int64 { get } static var max: Int64 { get } static var min: Int64 { get } } extension Int64 { init(_ value: CGFloat) } extension Int64 : Hashable { var hashValue: Int { get } } extension Int64 : CustomStringConvertible { var description: String { get } } extension Int64 : RandomAccessIndexType { func successor() -> Int64 func predecessor() -> Int64 func distanceTo(_ other: Int64) -> Distance func advancedBy(_ n: Distance) -> Int64 } extension Int64 { static func addWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func subtractWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func divideWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) static func remainderWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool) func toIntMax() -> IntMax } extension Int64 : SignedNumberType { } extension Int64 { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(_ v: UInt) init(_ v: Int) init(bitPattern bitPattern: UInt64) } extension Int64 : BitwiseOperationsType { static var allZeros: Int64 { get } } extension Int64 { init(_ other: Float) init(_ other: Double) } extension Int64 { init?(_ text: String, radix radix: Int = default) } extension Int64 : _Reflectable { } extension Int64 : CVarArgType, _CVarArgAlignedType { } | BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, SignedIntegerType, SignedNumberType |
Modified Int8 [struct]
Declaration | Protocols | |
---|---|---|
From | struct Int8 : _IntegerArithmeticType, Comparable, Equatable, _SignedIntegerType, _IntegerType, IntegerArithmeticType, IntegerType, SignedIntegerType { var value: Builtin.Int8 typealias Distance = Int init() init(_ value: Int8) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int8) static var max: Int8 { get } static var min: Int8 { get } } extension Int8 { init(_ value: CGFloat) } extension Int8 : Hashable { var hashValue: Int { get } } extension Int8 : CustomStringConvertible { var description: String { get } } extension Int8 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity { func successor() -> Int8 func predecessor() -> Int8 func distanceTo(_ other: Int8) -> Distance func advancedBy(_ n: Distance) -> Int8 } extension Int8 { static func addWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func subtractWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func divideWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func remainderWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) func toIntMax() -> IntMax } extension Int8 : SignedNumberType, IntegerLiteralConvertible { } extension Int8 { init(_ v: UInt8) init(_ v: UInt16) init(truncatingBitPattern truncatingBitPattern: UInt16) init(_ v: Int16) init(truncatingBitPattern truncatingBitPattern: Int16) init(_ v: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ v: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: UInt8) } extension Int8 : BitwiseOperationsType { static var allZeros: Int8 { get } } extension Int8 { init(_ other: Float) init(_ other: Double) } extension Int8 { init?(_ text: String, radix radix: Int = default) } extension Int8 : _Reflectable { } extension Int8 : CVarArgType { } | BidirectionalIndexType, BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, RandomAccessIndexType, SignedIntegerType, SignedNumberType, Strideable |
To | struct Int8 : SignedIntegerType, Comparable, Equatable { var value: Builtin.Int8 typealias Distance = Int init() init(_ value: Int8) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: Int8) static var max: Int8 { get } static var min: Int8 { get } } extension Int8 { init(_ value: CGFloat) } extension Int8 : Hashable { var hashValue: Int { get } } extension Int8 : CustomStringConvertible { var description: String { get } } extension Int8 : RandomAccessIndexType { func successor() -> Int8 func predecessor() -> Int8 func distanceTo(_ other: Int8) -> Distance func advancedBy(_ n: Distance) -> Int8 } extension Int8 { static func addWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func subtractWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func multiplyWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func divideWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) static func remainderWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool) func toIntMax() -> IntMax } extension Int8 : SignedNumberType { } extension Int8 { init(_ v: UInt8) init(_ v: UInt16) init(truncatingBitPattern truncatingBitPattern: UInt16) init(_ v: Int16) init(truncatingBitPattern truncatingBitPattern: Int16) init(_ v: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ v: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: UInt8) } extension Int8 : BitwiseOperationsType { static var allZeros: Int8 { get } } extension Int8 { init(_ other: Float) init(_ other: Double) } extension Int8 { init?(_ text: String, radix radix: Int = default) } extension Int8 : _Reflectable { } extension Int8 : CVarArgType { } | BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, SignedIntegerType, SignedNumberType |
Modified LazyCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct LazyCollection<Base : CollectionType> : LazyCollectionType, LazySequenceType { typealias Elements = Base var elements: Base { get } typealias Index = Base.Index init(_ base: Base) } extension LazyCollection : SequenceType { func generate() -> Base.Generator func underestimateCount() -> Int } extension LazyCollection : CollectionType, Indexable { var startIndex: Base.Index { get } var endIndex: Base.Index { get } subscript (_ position: Base.Index) -> Base.Generator.Element { get } subscript (_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get } var isEmpty: Bool { get } var count: Base.Index.Distance { get } var first: Base.Generator.Element? { get } typealias S = Void } | CollectionType, Indexable, LazyCollectionType, LazySequenceType, SequenceType |
To | struct LazyCollection<Base : CollectionType> : LazyCollectionType { typealias Elements = Base var elements: Base { get } typealias Index = Base.Index init(_ base: Base) } extension LazyCollection : SequenceType { func generate() -> Base.Generator func underestimateCount() -> Int } extension LazyCollection : CollectionType { var startIndex: Base.Index { get } var endIndex: Base.Index { get } subscript (_ position: Base.Index) -> Base.Generator.Element { get } subscript (_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get } var isEmpty: Bool { get } var count: Base.Index.Distance { get } var first: Base.Generator.Element? { get } typealias S = Void } | CollectionType, LazyCollectionType, SequenceType |
Modified LazyCollectionType
Declaration | |
---|---|
From | protocol LazyCollectionType : CollectionType, LazySequenceType { typealias Elements : CollectionType, SequenceType = Self } |
To | protocol LazyCollectionType : CollectionType, LazySequenceType { typealias Elements : CollectionType = Self } |
Modified LazyFilterCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct LazyFilterCollection<Base : CollectionType> : LazyCollectionType, CollectionType, Indexable, SequenceType, LazySequenceType { typealias Index = LazyFilterIndex<Base> init(_ base: Base, whereElementsSatisfy predicate: (Base.Generator.Element) -> Bool) var startIndex: LazyFilterIndex<Base> { get } var endIndex: LazyFilterIndex<Base> { get } subscript (_ position: LazyFilterIndex<Base>) -> Base.Generator.Element { get } func generate() -> LazyFilterGenerator<Base.Generator> } | CollectionType, Indexable, LazyCollectionType, LazySequenceType, SequenceType |
To | struct LazyFilterCollection<Base : CollectionType> : LazyCollectionType { typealias Index = LazyFilterIndex<Base> init(_ base: Base, whereElementsSatisfy predicate: (Base.Generator.Element) -> Bool) var startIndex: LazyFilterIndex<Base> { get } var endIndex: LazyFilterIndex<Base> { get } subscript (_ position: LazyFilterIndex<Base>) -> Base.Generator.Element { get } func generate() -> LazyFilterGenerator<Base.Generator> } | LazyCollectionType |
Modified LazyFilterIndex [struct]
Declaration | Protocols | |
---|---|---|
From | struct LazyFilterIndex<BaseElements : CollectionType> : ForwardIndexType, _Incrementable, Equatable { func successor() -> LazyFilterIndex<BaseElements> let base: BaseElements.Index typealias Base = BaseElements } | Equatable, ForwardIndexType |
To | struct LazyFilterIndex<BaseElements : CollectionType> : ForwardIndexType { func successor() -> LazyFilterIndex<BaseElements> let base: BaseElements.Index typealias Base = BaseElements } | ForwardIndexType |
Modified LazyFilterSequence [struct]
Declaration | Protocols | |
---|---|---|
From | struct LazyFilterSequence<Base : SequenceType> : LazySequenceType, SequenceType { func generate() -> LazyFilterGenerator<Base.Generator> init(_ base: Base, whereElementsSatisfy predicate: (Base.Generator.Element) -> Bool) let base: Base } | LazySequenceType, SequenceType |
To | struct LazyFilterSequence<Base : SequenceType> : LazySequenceType { func generate() -> LazyFilterGenerator<Base.Generator> init(_ base: Base, whereElementsSatisfy predicate: (Base.Generator.Element) -> Bool) let base: Base } | LazySequenceType |
Modified LazyMapCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct LazyMapCollection<Base : CollectionType, Element> : LazyCollectionType, CollectionType, Indexable, SequenceType, LazySequenceType { typealias Index = Base.Index var startIndex: Base.Index { get } var endIndex: Base.Index { get } subscript (_ position: Base.Index) -> Element { get } var isEmpty: Bool { get } var first: Element? { get } func generate() -> LazyMapGenerator<Base.Generator, Element> func underestimateCount() -> Int var count: Base.Index.Distance { get } init(_ base: Base, transform transform: (Base.Generator.Element) -> Element) typealias T = Element } | CollectionType, Indexable, LazyCollectionType, LazySequenceType, SequenceType |
To | struct LazyMapCollection<Base : CollectionType, Element> : LazyCollectionType { typealias Index = Base.Index var startIndex: Base.Index { get } var endIndex: Base.Index { get } subscript (_ position: Base.Index) -> Element { get } var isEmpty: Bool { get } var first: Element? { get } func generate() -> LazyMapGenerator<Base.Generator, Element> func underestimateCount() -> Int var count: Base.Index.Distance { get } init(_ base: Base, transform transform: (Base.Generator.Element) -> Element) typealias T = Element } | LazyCollectionType |
Modified LazyMapSequence [struct]
Declaration | Protocols | |
---|---|---|
From | struct LazyMapSequence<Base : SequenceType, Element> : LazySequenceType, SequenceType { typealias Elements = LazyMapSequence<Base, Element> func generate() -> LazyMapGenerator<Base.Generator, Element> func underestimateCount() -> Int init(_ base: Base, transform transform: (Base.Generator.Element) -> Element) typealias T = Element } | LazySequenceType, SequenceType |
To | struct LazyMapSequence<Base : SequenceType, Element> : LazySequenceType { typealias Elements = LazyMapSequence<Base, Element> func generate() -> LazyMapGenerator<Base.Generator, Element> func underestimateCount() -> Int init(_ base: Base, transform transform: (Base.Generator.Element) -> Element) typealias T = Element } | LazySequenceType |
Modified LazySequence [struct]
Declaration | Protocols | |
---|---|---|
From | struct LazySequence<Base : SequenceType> : LazySequenceType, SequenceType, _SequenceWrapperType { init(_ base: Base) var elements: Base { get } typealias S = Void } | LazySequenceType, SequenceType |
To | struct LazySequence<Base : SequenceType> : LazySequenceType, _SequenceWrapperType { init(_ base: Base) var elements: Base { get } typealias S = Void } | LazySequenceType |
Modified ManagedBuffer
Protocols | |
---|---|
From | AnyObject |
To | -- |
Modified ManagedProtoBuffer
Protocols | |
---|---|
From | AnyObject |
To | -- |
Modified Mirror.DisplayStyle [enum]
Protocols | |
---|---|
From | Equatable, Hashable |
To | -- |
Modified MutableCollectionType
Declaration | |
---|---|
From | protocol MutableCollectionType : MutableIndexable, CollectionType { typealias SubSequence : Indexable, SequenceType = MutableSlice<Self> subscript (_ position: Self.Index) -> Self.Generator.Element { get set } subscript (_ bounds: Range<Self.Index>) -> Self.SubSequence { get set } } |
To | protocol MutableCollectionType : MutableIndexable, CollectionType { typealias SubSequence = MutableSlice<Self> subscript (_ position: Self.Index) -> Self.Generator.Element { get set } subscript (_ bounds: Range<Self.Index>) -> Self.SubSequence { get set } } |
Modified MutableSlice [struct]
Declaration | Protocols | |
---|---|---|
From | struct MutableSlice<Base : MutableIndexable> : MutableCollectionType, CollectionType, Indexable, SequenceType, MutableIndexable { typealias Index = Base.Index var startIndex: Base.Index { get } var endIndex: Base.Index { get } subscript (_ index: Base.Index) -> Base._Element subscript (_ bounds: Range<Base.Index>) -> MutableSlice<Base> init(base base: Base, bounds bounds: Range<Base.Index>) } | CollectionType, Indexable, MutableCollectionType, MutableIndexable, SequenceType |
To | struct MutableSlice<Base : MutableIndexable> : MutableCollectionType { typealias Index = Base.Index var startIndex: Base.Index { get } var endIndex: Base.Index { get } subscript (_ index: Base.Index) -> Base._Element subscript (_ bounds: Range<Base.Index>) -> MutableSlice<Base> init(base base: Base, bounds bounds: Range<Base.Index>) } | MutableCollectionType |
Modified NonObjectiveCBase
Protocols | |
---|---|
From | AnyObject |
To | -- |
Modified ObjectIdentifier [struct]
Declaration | Protocols | |
---|---|---|
From | struct ObjectIdentifier : Hashable, Equatable, Comparable { var uintValue: UInt { get } var hashValue: Int { get } init(_ x: AnyObject) init(_ x: Any.Type) } | Comparable, Equatable, Hashable |
To | struct ObjectIdentifier : Hashable, Comparable { var uintValue: UInt { get } var hashValue: Int { get } init(_ x: AnyObject) init(_ x: Any.Type) } | Comparable, Hashable |
Modified Optional [enum]
Declaration | |
---|---|
From | enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible { case None case Some(Wrapped) typealias T = Wrapped init() init(_ some: Wrapped) @warn_unused_result @rethrows func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U? @warn_unused_result @rethrows func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U? init(nilLiteral nilLiteral: ()) } extension Optional : CustomDebugStringConvertible { var debugDescription: String { get } } |
To | enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible { case None case Some(Wrapped) typealias T = Wrapped init() init(_ some: Wrapped) @warn_unused_result func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U? @warn_unused_result func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U? init(nilLiteral nilLiteral: ()) } extension Optional : CustomDebugStringConvertible { var debugDescription: String { get } } |
Modified Optional.flatMap<U>(_: (Wrapped) throws -> U?) rethrows -> U?
Declaration | |
---|---|
From | @warn_unused_result @rethrows func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U? |
To | @warn_unused_result func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U? |
Modified Optional.map<U>(_: (Wrapped) throws -> U) rethrows -> U?
Declaration | |
---|---|
From | @warn_unused_result @rethrows func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U? |
To | @warn_unused_result func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U? |
Modified Range [struct]
Declaration | Protocols | |
---|---|---|
From | struct Range<Element : ForwardIndexType> : Equatable, CollectionType, Indexable, SequenceType, CustomStringConvertible, CustomDebugStringConvertible { typealias T = Element init(_ x: Range<Element>) init(start start: Element, end end: Element) subscript (_ position: Element) -> Element { get } subscript (_ _: Element._DisabledRangeIndex) -> Element { get } func generate() -> RangeGenerator<Element> var startIndex: Element var endIndex: Element var description: String { get } var debugDescription: String { get } } extension Range : _Reflectable { } | CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Equatable, Indexable, SequenceType |
To | struct Range<Element : ForwardIndexType> : Equatable, CollectionType, CustomStringConvertible, CustomDebugStringConvertible { typealias T = Element init(_ x: Range<Element>) init(start start: Element, end end: Element) subscript (_ position: Element) -> Element { get } subscript (_ _: Element._DisabledRangeIndex) -> Element { get } func generate() -> RangeGenerator<Element> var startIndex: Element var endIndex: Element var description: String { get } var debugDescription: String { get } } extension Range : _Reflectable { } | CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Equatable |
Modified Repeat [struct]
Declaration | Protocols | |
---|---|---|
From | struct Repeat<Element> : CollectionType, Indexable, SequenceType { typealias T = Element typealias Index = Int init(count count: Int, repeatedValue repeatedValue: Element) var startIndex: Index { get } var endIndex: Index { get } subscript (_ position: Int) -> Element { get } var count: Int let repeatedValue: Element } | CollectionType, Indexable, SequenceType |
To | struct Repeat<Element> : CollectionType { typealias T = Element typealias Index = Int init(count count: Int, repeatedValue repeatedValue: Element) var startIndex: Index { get } var endIndex: Index { get } subscript (_ position: Int) -> Element { get } var count: Int let repeatedValue: Element } | CollectionType |
Modified ReverseCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct ReverseCollection<Base : CollectionType where Base.Index : BidirectionalIndexType> : CollectionType, Indexable, _ReverseCollectionType, SequenceType { init(_ base: Base) typealias Index = ReverseIndex<Base.Index> typealias Generator = IndexingGenerator<ReverseCollection<Base>> typealias T = Base } | CollectionType, Indexable, SequenceType |
To | struct ReverseCollection<Base : CollectionType where Base.Index : BidirectionalIndexType> : CollectionType, _ReverseCollectionType { init(_ base: Base) typealias Index = ReverseIndex<Base.Index> typealias Generator = IndexingGenerator<ReverseCollection<Base>> typealias T = Base } | CollectionType |
Modified ReverseIndex [struct]
Declaration | Protocols | |
---|---|---|
From | struct ReverseIndex<Base : BidirectionalIndexType> : ReverseIndexType, BidirectionalIndexType, ForwardIndexType, _Incrementable, Equatable { typealias Distance = Base.Distance init(_ base: Base) let base: Base typealias I = Base } | BidirectionalIndexType, Equatable, ForwardIndexType, ReverseIndexType |
To | struct ReverseIndex<Base : BidirectionalIndexType> : BidirectionalIndexType, ReverseIndexType { typealias Distance = Base.Distance init(_ base: Base) let base: Base typealias I = Base } | BidirectionalIndexType, ReverseIndexType |
Modified ReverseRandomAccessCollection [struct]
Declaration | Protocols | |
---|---|---|
From | struct ReverseRandomAccessCollection<Base : CollectionType where Base.Index : RandomAccessIndexType> : _ReverseCollectionType, CollectionType, Indexable, SequenceType { init(_ base: Base) typealias Index = ReverseRandomAccessIndex<Base.Index> typealias Generator = IndexingGenerator<ReverseRandomAccessCollection<Base>> typealias T = Base } | CollectionType, Indexable, SequenceType |
To | struct ReverseRandomAccessCollection<Base : CollectionType where Base.Index : RandomAccessIndexType> : _ReverseCollectionType { init(_ base: Base) typealias Index = ReverseRandomAccessIndex<Base.Index> typealias Generator = IndexingGenerator<ReverseRandomAccessCollection<Base>> typealias T = Base } | -- |
Modified ReverseRandomAccessIndex [struct]
Declaration | Protocols | |
---|---|---|
From | struct ReverseRandomAccessIndex<Base : RandomAccessIndexType> : ForwardIndexType, _Incrementable, Equatable, _Strideable, ReverseIndexType, BidirectionalIndexType, RandomAccessIndexType, Strideable, Comparable, _RandomAccessAmbiguity { typealias Distance = Base.Distance init(_ base: Base) let base: Base func distanceTo(_ other: ReverseRandomAccessIndex<Base>) -> Base.Distance func advancedBy(_ n: Base.Distance) -> ReverseRandomAccessIndex<Base> typealias I = Base } | BidirectionalIndexType, Comparable, Equatable, ForwardIndexType, RandomAccessIndexType, ReverseIndexType, Strideable |
To | struct ReverseRandomAccessIndex<Base : RandomAccessIndexType> : RandomAccessIndexType, ReverseIndexType { typealias Distance = Base.Distance init(_ base: Base) let base: Base func distanceTo(_ other: ReverseRandomAccessIndex<Base>) -> Base.Distance func advancedBy(_ n: Base.Distance) -> ReverseRandomAccessIndex<Base> typealias I = Base } | RandomAccessIndexType, ReverseIndexType |
Modified SequenceType
Declaration | |
---|---|
From | protocol SequenceType { typealias Generator : GeneratorType typealias SubSequence @warn_unused_result func generate() -> Self.Generator @warn_unused_result func underestimateCount() -> Int @warn_unused_result @rethrows func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T] @warn_unused_result @rethrows func filter(@noescape _ includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element] @rethrows func forEach(@noescape _ body: (Self.Generator.Element) throws -> ()) rethrows @warn_unused_result func dropFirst(_ n: Int) -> Self.SubSequence @warn_unused_result func dropLast(_ n: Int) -> Self.SubSequence @warn_unused_result func prefix(_ maxLength: Int) -> Self.SubSequence @warn_unused_result func suffix(_ maxLength: Int) -> Self.SubSequence @warn_unused_result @rethrows func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence] } |
To | protocol SequenceType { typealias Generator : GeneratorType typealias SubSequence @warn_unused_result func generate() -> Self.Generator @warn_unused_result func underestimateCount() -> Int @warn_unused_result func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T] @warn_unused_result func filter(@noescape _ includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element] func forEach(@noescape _ body: (Self.Generator.Element) throws -> ()) rethrows @warn_unused_result func dropFirst(_ n: Int) -> Self.SubSequence @warn_unused_result func dropLast(_ n: Int) -> Self.SubSequence @warn_unused_result func prefix(_ maxLength: Int) -> Self.SubSequence @warn_unused_result func suffix(_ maxLength: Int) -> Self.SubSequence @warn_unused_result func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence] } |
Modified SequenceType.contains(_: (Self.Generator.Element) throws -> Bool) rethrows -> Bool
Declaration | |
---|---|
From | @warn_unused_result @rethrows func contains(@noescape _ predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Bool |
To | @warn_unused_result func contains(@noescape _ predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Bool |
Modified SequenceType.elementsEqual<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence, isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool
Declaration | |
---|---|
From | @warn_unused_result @rethrows func elementsEqual<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isEquivalent isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool |
To | @warn_unused_result func elementsEqual<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isEquivalent isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool |
Modified SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Declaration | |
---|---|
From | @warn_unused_result @rethrows func filter(@noescape _ includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element] |
To | @warn_unused_result func filter(@noescape _ includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element] |
Modified SequenceType.flatMap<T>(_: (Self.Generator.Element) throws -> T?) rethrows -> [T]
Declaration | |
---|---|
From | @warn_unused_result @rethrows func flatMap<T>(@noescape _ transform: (Self.Generator.Element) throws -> T?) rethrows -> [T] |
To | @warn_unused_result func flatMap<T>(@noescape _ transform: (Self.Generator.Element) throws -> T?) rethrows -> [T] |
Modified SequenceType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
Declaration | |
---|---|
From | @warn_unused_result @rethrows func flatMap<S : SequenceType>(_ transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element] |
To | @warn_unused_result func flatMap<S : SequenceType>(_ transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element] |
Modified SequenceType.forEach(_: (Self.Generator.Element) throws -> ()) rethrows
Declaration | |
---|---|
From | @rethrows func forEach(@noescape _ body: (Self.Generator.Element) throws -> ()) rethrows |
To | func forEach(@noescape _ body: (Self.Generator.Element) throws -> ()) rethrows |
Modified SequenceType.lexicographicalCompare<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence, isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool
Declaration | |
---|---|
From | @warn_unused_result @rethrows func lexicographicalCompare<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isOrderedBefore isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool |
To | @warn_unused_result func lexicographicalCompare<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isOrderedBefore isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool |
Modified SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Declaration | |
---|---|
From | @warn_unused_result @rethrows func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T] |
To | @warn_unused_result func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T] |
Modified SequenceType.maxElement(_: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element?
Declaration | |
---|---|
From | @warn_unused_result @rethrows func maxElement(@noescape _ isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element? |
To | @warn_unused_result func maxElement(@noescape _ isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element? |
Modified SequenceType.minElement(_: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element?
Declaration | |
---|---|
From | @warn_unused_result @rethrows func minElement(@noescape _ isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element? |
To | @warn_unused_result func minElement(@noescape _ isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element? |
Modified SequenceType.reduce<T>(_: T, combine: (T, Self.Generator.Element) throws -> T) rethrows -> T
Declaration | |
---|---|
From | @warn_unused_result @rethrows func reduce<T>(_ initial: T, @noescape combine combine: (T, Self.Generator.Element) throws -> T) rethrows -> T |
To | @warn_unused_result func reduce<T>(_ initial: T, @noescape combine combine: (T, Self.Generator.Element) throws -> T) rethrows -> T |
Modified SequenceType.split(_: Int, allowEmptySlices: Bool, isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [AnySequence<Self.Generator.Element>]
Declaration | |
---|---|
From | @warn_unused_result @rethrows func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [AnySequence<Self.Generator.Element>] |
To | @warn_unused_result func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [AnySequence<Self.Generator.Element>] |
Modified SequenceType.split(_: Int, allowEmptySlices: Bool, isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Declaration | |
---|---|
From | @warn_unused_result @rethrows func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence] |
To | @warn_unused_result func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence] |
Modified SequenceType.startsWith<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_: OtherSequence, isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool
Declaration | |
---|---|
From | @warn_unused_result @rethrows func startsWith<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isEquivalent isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool |
To | @warn_unused_result func startsWith<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isEquivalent isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool |
Modified Set [struct]
Declaration | Protocols | |
---|---|---|
From | struct Set<Element : Hashable> : Hashable, Equatable, CollectionType, Indexable, SequenceType, ArrayLiteralConvertible { typealias T = Element typealias Index = SetIndex<Element> init(minimumCapacity minimumCapacity: Int) var startIndex: SetIndex<Element> { get } var endIndex: SetIndex<Element> { get } @warn_unused_result func contains(_ member: Element) -> Bool @warn_unused_result func indexOf(_ member: Element) -> SetIndex<Element>? mutating func insert(_ member: Element) mutating func remove(_ member: Element) -> Element? mutating func removeAtIndex(_ index: SetIndex<Element>) -> Element mutating func removeAll(keepCapacity keepCapacity: Bool = default) mutating func removeFirst() -> Element var count: Int { get } subscript (_ position: SetIndex<Element>) -> Element { get } func generate() -> SetGenerator<Element> init(arrayLiteral elements: Element...) init() init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) @warn_unused_result func isSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool @warn_unused_result func isStrictSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool @warn_unused_result func isSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool @warn_unused_result func isStrictSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool @warn_unused_result func isDisjointWith<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool @warn_unused_result func union<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element> mutating func unionInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) @warn_unused_result func subtract<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element> mutating func subtractInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) @warn_unused_result func intersect<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element> mutating func intersectInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) @warn_unused_result func exclusiveOr<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element> mutating func exclusiveOrInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) var hashValue: Int { get } var isEmpty: Bool { get } var first: Element? { get } } extension Set : _ObjectiveCBridgeable { } extension Set : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension Set : _Reflectable { } extension Set { mutating func popFirst() -> Element? } | ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Equatable, Hashable, Indexable, SequenceType |
To | struct Set<Element : Hashable> : Hashable, CollectionType, ArrayLiteralConvertible { typealias T = Element typealias Index = SetIndex<Element> init(minimumCapacity minimumCapacity: Int) var startIndex: SetIndex<Element> { get } var endIndex: SetIndex<Element> { get } @warn_unused_result func contains(_ member: Element) -> Bool @warn_unused_result func indexOf(_ member: Element) -> SetIndex<Element>? mutating func insert(_ member: Element) mutating func remove(_ member: Element) -> Element? mutating func removeAtIndex(_ index: SetIndex<Element>) -> Element mutating func removeAll(keepCapacity keepCapacity: Bool = default) mutating func removeFirst() -> Element var count: Int { get } subscript (_ position: SetIndex<Element>) -> Element { get } func generate() -> SetGenerator<Element> init(arrayLiteral elements: Element...) init() init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) @warn_unused_result func isSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool @warn_unused_result func isStrictSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool @warn_unused_result func isSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool @warn_unused_result func isStrictSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool @warn_unused_result func isDisjointWith<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool @warn_unused_result func union<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element> mutating func unionInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) @warn_unused_result func subtract<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element> mutating func subtractInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) @warn_unused_result func intersect<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element> mutating func intersectInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) @warn_unused_result func exclusiveOr<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element> mutating func exclusiveOrInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) var hashValue: Int { get } var isEmpty: Bool { get } var first: Element? { get } } extension Set : _ObjectiveCBridgeable { } extension Set : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension Set : _Reflectable { } extension Set { mutating func popFirst() -> Element? } | ArrayLiteralConvertible, CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Hashable |
Modified SetIndex [struct]
Declaration | Protocols | |
---|---|---|
From | struct SetIndex<Element : Hashable> : ForwardIndexType, _Incrementable, Equatable, Comparable { typealias T = Element func successor() -> SetIndex<Element> } | Comparable, Equatable, ForwardIndexType |
To | struct SetIndex<Element : Hashable> : ForwardIndexType, Comparable { typealias T = Element func successor() -> SetIndex<Element> } | Comparable, ForwardIndexType |
Modified Slice [struct]
Declaration | Protocols | |
---|---|---|
From | struct Slice<Base : Indexable> : Indexable, SequenceType, CollectionType { typealias Index = Base.Index let startIndex: Base.Index let endIndex: Base.Index subscript (_ index: Base.Index) -> Base._Element { get } subscript (_ bounds: Range<Base.Index>) -> Slice<Base> { get } init(base base: Base, bounds bounds: Range<Base.Index>) } | CollectionType, Indexable, SequenceType |
To | struct Slice<Base : Indexable> : CollectionType { typealias Index = Base.Index let startIndex: Base.Index let endIndex: Base.Index subscript (_ index: Base.Index) -> Base._Element { get } subscript (_ bounds: Range<Base.Index>) -> Slice<Base> { get } init(base base: Base, bounds bounds: Range<Base.Index>) } | CollectionType |
Modified StaticString [struct]
Declaration | |
---|---|
From | struct StaticString : _Reflectable, UnicodeScalarLiteralConvertible, ExtendedGraphemeClusterLiteralConvertible, StringLiteralConvertible, CustomStringConvertible, CustomDebugStringConvertible { var utf8Start: UnsafePointer<UInt8> { get } var unicodeScalar: UnicodeScalar { get } var byteSize: Int { get } var hasPointerRepresentation: Bool { get } var isASCII: Bool { get } func withUTF8Buffer<R>(@noescape _ body: (UnsafeBufferPointer<UInt8>) -> R) -> R var stringValue: String { get } init() init(_builtinUnicodeScalarLiteral value: Builtin.Int32) init(unicodeScalarLiteral value: StaticString) init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1) init(extendedGraphemeClusterLiteral value: StaticString) init(_builtinStringLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1) init(stringLiteral value: StaticString) var description: String { get } var debugDescription: String { get } } |
To | struct StaticString : UnicodeScalarLiteralConvertible, ExtendedGraphemeClusterLiteralConvertible, StringLiteralConvertible, CustomStringConvertible, CustomDebugStringConvertible, _Reflectable { var utf8Start: UnsafePointer<UInt8> { get } var unicodeScalar: UnicodeScalar { get } var byteSize: Int { get } var hasPointerRepresentation: Bool { get } var isASCII: Bool { get } func withUTF8Buffer<R>(@noescape _ body: (UnsafeBufferPointer<UInt8>) -> R) -> R var stringValue: String { get } init() init(_builtinUnicodeScalarLiteral value: Builtin.Int32) init(unicodeScalarLiteral value: StaticString) init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1) init(extendedGraphemeClusterLiteral value: StaticString) init(_builtinStringLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1) init(stringLiteral value: StaticString) var description: String { get } var debugDescription: String { get } } |
Modified String [struct]
Declaration | |
---|---|
From | struct String { init() } extension String { @warn_unused_result static func availableStringEncodings() -> [NSStringEncoding] @warn_unused_result static func defaultCStringEncoding() -> NSStringEncoding @warn_unused_result static func localizedNameOfStringEncoding(_ encoding: NSStringEncoding) -> String @warn_unused_result static func localizedStringWithFormat(_ format: String, _ arguments: CVarArgType...) -> String static func pathWithComponents(_ components: [String]) -> String init?(UTF8String bytes: UnsafePointer<CChar>) @warn_unused_result func canBeConvertedToEncoding(_ encoding: NSStringEncoding) -> Bool var capitalizedString: String { get } var localizedCapitalizedString: String { get } @warn_unused_result func capitalizedStringWithLocale(_ locale: NSLocale?) -> String @warn_unused_result func caseInsensitiveCompare(_ aString: String) -> NSComparisonResult @warn_unused_result func commonPrefixWithString(_ aString: String, options options: NSStringCompareOptions) -> String @warn_unused_result func compare(_ aString: String, options mask: NSStringCompareOptions = default, range range: Range<Index>? = default, locale locale: NSLocale? = default) -> NSComparisonResult @warn_unused_result func completePathIntoString(_ outputName: UnsafeMutablePointer<String> = default, caseSensitive caseSensitive: Bool, matchesIntoArray matchesIntoArray: UnsafeMutablePointer<[String]> = default, filterTypes filterTypes: [String]? = default) -> Int @warn_unused_result func componentsSeparatedByCharactersInSet(_ separator: NSCharacterSet) -> [String] func componentsSeparatedByString(_ separator: String) -> [String] @warn_unused_result func cStringUsingEncoding(_ encoding: NSStringEncoding) -> [CChar]? @warn_unused_result func dataUsingEncoding(_ encoding: NSStringEncoding, allowLossyConversion allowLossyConversion: Bool = default) -> NSData? var decomposedStringWithCanonicalMapping: String { get } var decomposedStringWithCompatibilityMapping: String { get } func enumerateLines(_ body: (line: String, inout stop: Bool) -> ()) func enumerateLinguisticTagsInRange(_ range: Range<Index>, scheme tagScheme: String, options opts: NSLinguisticTaggerOptions, orthography orthography: NSOrthography?, _ body: (String, Range<Index>, Range<Index>, inout Bool) -> ()) func enumerateSubstringsInRange(_ range: Range<Index>, options opts: NSStringEnumerationOptions, _ body: (substring: String?, substringRange: Range<Index>, enclosingRange: Range<Index>, inout Bool) -> ()) var fastestEncoding: NSStringEncoding { get } func fileSystemRepresentation() -> [CChar] func getBytes(inout _ buffer: [UInt8], maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding encoding: NSStringEncoding, options options: NSStringEncodingConversionOptions, range range: Range<Index>, remainingRange leftover: UnsafeMutablePointer<Range<Index>>) -> Bool func getCString(inout _ buffer: [CChar], maxLength maxLength: Int, encoding encoding: NSStringEncoding) -> Bool func getFileSystemRepresentation(inout _ buffer: [CChar], maxLength maxLength: Int) -> Bool func getLineStart(_ start: UnsafeMutablePointer<Index>, end end: UnsafeMutablePointer<Index>, contentsEnd contentsEnd: UnsafeMutablePointer<Index>, forRange forRange: Range<Index>) func getParagraphStart(_ start: UnsafeMutablePointer<Index>, end end: UnsafeMutablePointer<Index>, contentsEnd contentsEnd: UnsafeMutablePointer<Index>, forRange forRange: Range<Index>) var hash: Int { get } init?<S : SequenceType where S.Generator.Element == UInt8>(bytes bytes: S, encoding encoding: NSStringEncoding) init?(bytesNoCopy bytes: UnsafeMutablePointer<Void>, length length: Int, encoding encoding: NSStringEncoding, freeWhenDone flag: Bool) init(utf16CodeUnits utf16CodeUnits: UnsafePointer<unichar>, count count: Int) init(utf16CodeUnitsNoCopy utf16CodeUnitsNoCopy: UnsafePointer<unichar>, count count: Int, freeWhenDone flag: Bool) init(contentsOfFile path: String, encoding enc: NSStringEncoding) throws init(contentsOfFile path: String, usedEncoding usedEncoding: UnsafeMutablePointer<NSStringEncoding> = default) throws init(contentsOfURL url: NSURL, encoding enc: NSStringEncoding) throws init(contentsOfURL url: NSURL, usedEncoding enc: UnsafeMutablePointer<NSStringEncoding> = default) throws init?(CString CString: UnsafePointer<CChar>, encoding enc: NSStringEncoding) init?(data data: NSData, encoding encoding: NSStringEncoding) init(format format: String, _ arguments: CVarArgType...) init(format format: String, arguments arguments: [CVarArgType]) init(format format: String, locale locale: NSLocale?, _ args: CVarArgType...) init(format format: String, locale locale: NSLocale?, arguments arguments: [CVarArgType]) var lastPathComponent: String { get } var utf16Count: Int { get } @warn_unused_result func lengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int @warn_unused_result func lineRangeForRange(_ aRange: Range<Index>) -> Range<Index> @warn_unused_result func linguisticTagsInRange(_ range: Range<Index>, scheme tagScheme: String, options opts: NSLinguisticTaggerOptions = default, orthography orthography: NSOrthography? = default, tokenRanges tokenRanges: UnsafeMutablePointer<[Range<Index>]> = default) -> [String] @warn_unused_result func localizedCaseInsensitiveCompare(_ aString: String) -> NSComparisonResult @warn_unused_result func localizedCompare(_ aString: String) -> NSComparisonResult @warn_unused_result func localizedStandardCompare(_ string: String) -> NSComparisonResult var localizedLowercaseString: String { get } @warn_unused_result func lowercaseStringWithLocale(_ locale: NSLocale?) -> String @warn_unused_result func maximumLengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int @warn_unused_result func paragraphRangeForRange(_ aRange: Range<Index>) -> Range<Index> var pathComponents: [String] { get } var pathExtension: String { get } var precomposedStringWithCanonicalMapping: String { get } var precomposedStringWithCompatibilityMapping: String { get } @warn_unused_result func propertyList() -> AnyObject @warn_unused_result func propertyListFromStringsFileFormat() -> [String : String] @warn_unused_result func rangeOfCharacterFromSet(_ aSet: NSCharacterSet, options mask: NSStringCompareOptions = default, range aRange: Range<Index>? = default) -> Range<Index>? @warn_unused_result func rangeOfComposedCharacterSequenceAtIndex(_ anIndex: Index) -> Range<Index> @warn_unused_result func rangeOfComposedCharacterSequencesForRange(_ range: Range<Index>) -> Range<Index> @warn_unused_result func rangeOfString(_ aString: String, options mask: NSStringCompareOptions = default, range searchRange: Range<Index>? = default, locale locale: NSLocale? = default) -> Range<Index>? @warn_unused_result func localizedStandardContainsString(_ string: String) -> Bool @warn_unused_result func localizedStandardRangeOfString(_ string: String) -> Range<Index>? var smallestEncoding: NSStringEncoding { get } var stringByAbbreviatingWithTildeInPath: String { get } @warn_unused_result func stringByAddingPercentEncodingWithAllowedCharacters(_ allowedCharacters: NSCharacterSet) -> String? func stringByAddingPercentEscapesUsingEncoding(_ encoding: NSStringEncoding) -> String? @warn_unused_result func stringByAppendingFormat(_ format: String, _ arguments: CVarArgType...) -> String func stringByAppendingPathComponent(_ aString: String) -> String func stringByAppendingPathExtension(_ ext: String) -> String? @warn_unused_result func stringByAppendingString(_ aString: String) -> String var stringByDeletingLastPathComponent: String { get } var stringByDeletingPathExtension: String { get } var stringByExpandingTildeInPath: String { get } @warn_unused_result func stringByFoldingWithOptions(_ options: NSStringCompareOptions, locale locale: NSLocale?) -> String @warn_unused_result func stringByPaddingToLength(_ newLength: Int, withString padString: String, startingAtIndex padIndex: Int) -> String var stringByRemovingPercentEncoding: String? { get } @warn_unused_result func stringByReplacingCharactersInRange(_ range: Range<Index>, withString replacement: String) -> String @warn_unused_result func stringByReplacingOccurrencesOfString(_ target: String, withString replacement: String, options options: NSStringCompareOptions = default, range searchRange: Range<Index>? = default) -> String func stringByReplacingPercentEscapesUsingEncoding(_ encoding: NSStringEncoding) -> String? var stringByResolvingSymlinksInPath: String { get } var stringByStandardizingPath: String { get } @warn_unused_result func stringByTrimmingCharactersInSet(_ set: NSCharacterSet) -> String func stringsByAppendingPaths(_ paths: [String]) -> [String] @warn_unused_result func substringFromIndex(_ index: Index) -> String @warn_unused_result func substringToIndex(_ index: Index) -> String @warn_unused_result func substringWithRange(_ aRange: Range<Index>) -> String var localizedUppercaseString: String { get } @warn_unused_result func uppercaseStringWithLocale(_ locale: NSLocale?) -> String func writeToFile(_ path: String, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding) throws func writeToURL(_ url: NSURL, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding) throws @warn_unused_result func stringByApplyingTransform(_ transform: String, reverse reverse: Bool) -> String? @warn_unused_result func containsString(_ other: String) -> Bool @warn_unused_result func localizedCaseInsensitiveContainsString(_ other: String) -> Bool } extension String : _ObjectiveCBridgeable { } extension String { init(_ cocoaString: NSString) } extension String { typealias Index = String.CharacterView.Index var startIndex: Index { get } var endIndex: Index { get } subscript (_ i: Index) -> Character { get } } extension String { struct CharacterView { init(_ text: String) } var characters: String.CharacterView { get } mutating func withMutableCharacters<R>(_ body: (inout String.CharacterView) -> R) -> R init(_ characters: String.CharacterView) } extension String { struct UnicodeScalarView : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType, Comparable { @warn_unused_result func successor() -> String.UnicodeScalarView.Index @warn_unused_result func predecessor() -> String.UnicodeScalarView.Index } var startIndex: String.UnicodeScalarView.Index { get } var endIndex: String.UnicodeScalarView.Index { get } subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get } subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get } struct Generator : GeneratorType { mutating func next() -> UnicodeScalar? } @warn_unused_result func generate() -> String.UnicodeScalarView.Generator var description: String { get } var debugDescription: String { get } } init(_ unicodeScalars: String.UnicodeScalarView) typealias UnicodeScalarIndex = String.UnicodeScalarView.Index } extension String { struct UTF16View : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index { } var startIndex: String.UTF16View.Index { get } var endIndex: String.UTF16View.Index { get } subscript (_ i: String.UTF16View.Index) -> CodeUnit { get } subscript (_ i: Int) -> CodeUnit { get } subscript (_ subRange: Range<Int>) -> String.UTF16View { get } subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get } var description: String { get } var debugDescription: String { get } } var utf16: String.UTF16View { get } init?(_ utf16: String.UTF16View) typealias UTF16Index = String.UTF16View.Index } extension String { struct UTF8View : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index : ForwardIndexType, _Incrementable, Equatable { @warn_unused_result func successor() -> String.UTF8View.Index } var startIndex: String.UTF8View.Index { get } var endIndex: String.UTF8View.Index { get } subscript (_ position: String.UTF8View.Index) -> CodeUnit { get } subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get } var description: String { get } var debugDescription: String { get } } var utf8: String.UTF8View { get } var nulTerminatedUTF8: ContiguousArray<CodeUnit> { get } init?(_ utf8: String.UTF8View) typealias UTF8Index = String.UTF8View.Index } extension String { @warn_unused_result static func fromCString(_ cs: UnsafePointer<CChar>) -> String? @warn_unused_result static func fromCStringRepairingIllFormedUTF8(_ cs: UnsafePointer<CChar>) -> (String?, hadError: Bool) } extension String { init(_ c: Character) } extension String { @rethrows func withCString<Result>(@noescape _ f: UnsafePointer<Int8> throws -> Result) rethrows -> Result } extension String : _Reflectable { } extension String : OutputStreamType { mutating func write(_ other: String) } extension String : Streamable { func writeTo<Target : OutputStreamType>(inout _ target: Target) } extension String { init(_builtinUnicodeScalarLiteral value: Builtin.Int32) } extension String : UnicodeScalarLiteralConvertible { init(unicodeScalarLiteral value: String) } extension String { init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1) } extension String : ExtendedGraphemeClusterLiteralConvertible { init(extendedGraphemeClusterLiteral value: String) } extension String { init(_builtinUTF16StringLiteral start: Builtin.RawPointer, numberOfCodeUnits numberOfCodeUnits: Builtin.Word) } extension String { init(_builtinStringLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1) } extension String : StringLiteralConvertible { init(stringLiteral value: String) } extension String : CustomDebugStringConvertible { var debugDescription: String { get } } extension String : Equatable { } extension String : Comparable { } extension String { mutating func appendContentsOf(_ other: String) mutating func append(_ x: UnicodeScalar) } extension String : Hashable { var hashValue: Int { get } } extension String { subscript (_ subRange: Range<Index>) -> String { get } } extension String { mutating func reserveCapacity(_ n: Int) mutating func append(_ c: Character) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_ newElements: S) init<S : SequenceType where S.Generator.Element == Character>(_ characters: S) } extension String { func join<S : SequenceType where S.Generator.Element == String>(_ elements: S) -> String } extension String { mutating func replaceRange<C : CollectionType where C.Generator.Element == Character>(_ subRange: Range<Index>, with newElements: C) mutating func replaceRange(_ subRange: Range<Index>, with newElements: String) mutating func insert(_ newElement: Character, atIndex i: Index) mutating func insertContentsOf<S : CollectionType where S.Generator.Element == Character>(_ newElements: S, at i: Index) mutating func removeAtIndex(_ i: Index) -> Character mutating func removeRange(_ subRange: Range<Index>) mutating func removeAll(keepCapacity keepCapacity: Bool = default) } extension String { var lowercaseString: String { get } var uppercaseString: String { get } } extension String : StringInterpolationConvertible { init(stringInterpolation strings: String...) init<T>(stringInterpolationSegment expr: T) init(stringInterpolationSegment expr: String) init(stringInterpolationSegment expr: Character) init(stringInterpolationSegment expr: UnicodeScalar) init(stringInterpolationSegment expr: Bool) init(stringInterpolationSegment expr: Float32) init(stringInterpolationSegment expr: Float64) init(stringInterpolationSegment expr: UInt8) init(stringInterpolationSegment expr: Int8) init(stringInterpolationSegment expr: UInt16) init(stringInterpolationSegment expr: Int16) init(stringInterpolationSegment expr: UInt32) init(stringInterpolationSegment expr: Int32) init(stringInterpolationSegment expr: UInt64) init(stringInterpolationSegment expr: Int64) init(stringInterpolationSegment expr: UInt) init(stringInterpolationSegment expr: Int) } extension String { init(count count: Int, repeatedValue c: Character) init(count count: Int, repeatedValue c: UnicodeScalar) var isEmpty: Bool { get } } extension String { func hasPrefix(_ prefix: String) -> Bool func hasSuffix(_ suffix: String) -> Bool } extension String { init<T : _SignedIntegerType>(_ v: T) init<T : UnsignedIntegerType>(_ v: T) init<T : _SignedIntegerType>(_ v: T, radix radix: Int, uppercase uppercase: Bool = default) init<T : UnsignedIntegerType>(_ v: T, radix radix: Int, uppercase uppercase: Bool = default) } extension String { func toInt() -> Int? } extension String { var unicodeScalars: String.UnicodeScalarView } extension String { subscript (_ i: Int) -> Character { get } subscript (_ subRange: Range<Int>) -> String { get } var count: Int { get } } extension String : MirrorPathType { } extension String { init<T>(_ instance: T) init<T>(reflecting subject: T) } |
To | struct String { init() } extension String { @warn_unused_result static func availableStringEncodings() -> [NSStringEncoding] @warn_unused_result static func defaultCStringEncoding() -> NSStringEncoding @warn_unused_result static func localizedNameOfStringEncoding(_ encoding: NSStringEncoding) -> String @warn_unused_result static func localizedStringWithFormat(_ format: String, _ arguments: CVarArgType...) -> String static func pathWithComponents(_ components: [String]) -> String init?(UTF8String bytes: UnsafePointer<CChar>) @warn_unused_result func canBeConvertedToEncoding(_ encoding: NSStringEncoding) -> Bool var capitalizedString: String { get } var localizedCapitalizedString: String { get } @warn_unused_result func capitalizedStringWithLocale(_ locale: NSLocale?) -> String @warn_unused_result func caseInsensitiveCompare(_ aString: String) -> NSComparisonResult @warn_unused_result func commonPrefixWithString(_ aString: String, options options: NSStringCompareOptions) -> String @warn_unused_result func compare(_ aString: String, options mask: NSStringCompareOptions = default, range range: Range<Index>? = default, locale locale: NSLocale? = default) -> NSComparisonResult @warn_unused_result func completePathIntoString(_ outputName: UnsafeMutablePointer<String> = default, caseSensitive caseSensitive: Bool, matchesIntoArray matchesIntoArray: UnsafeMutablePointer<[String]> = default, filterTypes filterTypes: [String]? = default) -> Int @warn_unused_result func componentsSeparatedByCharactersInSet(_ separator: NSCharacterSet) -> [String] func componentsSeparatedByString(_ separator: String) -> [String] @warn_unused_result func cStringUsingEncoding(_ encoding: NSStringEncoding) -> [CChar]? @warn_unused_result func dataUsingEncoding(_ encoding: NSStringEncoding, allowLossyConversion allowLossyConversion: Bool = default) -> NSData? var decomposedStringWithCanonicalMapping: String { get } var decomposedStringWithCompatibilityMapping: String { get } func enumerateLines(_ body: (line: String, inout stop: Bool) -> ()) func enumerateLinguisticTagsInRange(_ range: Range<Index>, scheme tagScheme: String, options opts: NSLinguisticTaggerOptions, orthography orthography: NSOrthography?, _ body: (String, Range<Index>, Range<Index>, inout Bool) -> ()) func enumerateSubstringsInRange(_ range: Range<Index>, options opts: NSStringEnumerationOptions, _ body: (substring: String?, substringRange: Range<Index>, enclosingRange: Range<Index>, inout Bool) -> ()) var fastestEncoding: NSStringEncoding { get } func fileSystemRepresentation() -> [CChar] func getBytes(inout _ buffer: [UInt8], maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding encoding: NSStringEncoding, options options: NSStringEncodingConversionOptions, range range: Range<Index>, remainingRange leftover: UnsafeMutablePointer<Range<Index>>) -> Bool func getCString(inout _ buffer: [CChar], maxLength maxLength: Int, encoding encoding: NSStringEncoding) -> Bool func getFileSystemRepresentation(inout _ buffer: [CChar], maxLength maxLength: Int) -> Bool func getLineStart(_ start: UnsafeMutablePointer<Index>, end end: UnsafeMutablePointer<Index>, contentsEnd contentsEnd: UnsafeMutablePointer<Index>, forRange forRange: Range<Index>) func getParagraphStart(_ start: UnsafeMutablePointer<Index>, end end: UnsafeMutablePointer<Index>, contentsEnd contentsEnd: UnsafeMutablePointer<Index>, forRange forRange: Range<Index>) var hash: Int { get } init?<S : SequenceType where S.Generator.Element == UInt8>(bytes bytes: S, encoding encoding: NSStringEncoding) init?(bytesNoCopy bytes: UnsafeMutablePointer<Void>, length length: Int, encoding encoding: NSStringEncoding, freeWhenDone flag: Bool) init(utf16CodeUnits utf16CodeUnits: UnsafePointer<unichar>, count count: Int) init(utf16CodeUnitsNoCopy utf16CodeUnitsNoCopy: UnsafePointer<unichar>, count count: Int, freeWhenDone flag: Bool) init(contentsOfFile path: String, encoding enc: NSStringEncoding) throws init(contentsOfFile path: String, usedEncoding usedEncoding: UnsafeMutablePointer<NSStringEncoding> = default) throws init(contentsOfURL url: NSURL, encoding enc: NSStringEncoding) throws init(contentsOfURL url: NSURL, usedEncoding enc: UnsafeMutablePointer<NSStringEncoding> = default) throws init?(CString CString: UnsafePointer<CChar>, encoding enc: NSStringEncoding) init?(data data: NSData, encoding encoding: NSStringEncoding) init(format format: String, _ arguments: CVarArgType...) init(format format: String, arguments arguments: [CVarArgType]) init(format format: String, locale locale: NSLocale?, _ args: CVarArgType...) init(format format: String, locale locale: NSLocale?, arguments arguments: [CVarArgType]) var lastPathComponent: String { get } var utf16Count: Int { get } @warn_unused_result func lengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int @warn_unused_result func lineRangeForRange(_ aRange: Range<Index>) -> Range<Index> @warn_unused_result func linguisticTagsInRange(_ range: Range<Index>, scheme tagScheme: String, options opts: NSLinguisticTaggerOptions = default, orthography orthography: NSOrthography? = default, tokenRanges tokenRanges: UnsafeMutablePointer<[Range<Index>]> = default) -> [String] @warn_unused_result func localizedCaseInsensitiveCompare(_ aString: String) -> NSComparisonResult @warn_unused_result func localizedCompare(_ aString: String) -> NSComparisonResult @warn_unused_result func localizedStandardCompare(_ string: String) -> NSComparisonResult var localizedLowercaseString: String { get } @warn_unused_result func lowercaseStringWithLocale(_ locale: NSLocale?) -> String @warn_unused_result func maximumLengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int @warn_unused_result func paragraphRangeForRange(_ aRange: Range<Index>) -> Range<Index> var pathComponents: [String] { get } var pathExtension: String { get } var precomposedStringWithCanonicalMapping: String { get } var precomposedStringWithCompatibilityMapping: String { get } @warn_unused_result func propertyList() -> AnyObject @warn_unused_result func propertyListFromStringsFileFormat() -> [String : String] @warn_unused_result func rangeOfCharacterFromSet(_ aSet: NSCharacterSet, options mask: NSStringCompareOptions = default, range aRange: Range<Index>? = default) -> Range<Index>? @warn_unused_result func rangeOfComposedCharacterSequenceAtIndex(_ anIndex: Index) -> Range<Index> @warn_unused_result func rangeOfComposedCharacterSequencesForRange(_ range: Range<Index>) -> Range<Index> @warn_unused_result func rangeOfString(_ aString: String, options mask: NSStringCompareOptions = default, range searchRange: Range<Index>? = default, locale locale: NSLocale? = default) -> Range<Index>? @warn_unused_result func localizedStandardContainsString(_ string: String) -> Bool @warn_unused_result func localizedStandardRangeOfString(_ string: String) -> Range<Index>? var smallestEncoding: NSStringEncoding { get } var stringByAbbreviatingWithTildeInPath: String { get } @warn_unused_result func stringByAddingPercentEncodingWithAllowedCharacters(_ allowedCharacters: NSCharacterSet) -> String? func stringByAddingPercentEscapesUsingEncoding(_ encoding: NSStringEncoding) -> String? @warn_unused_result func stringByAppendingFormat(_ format: String, _ arguments: CVarArgType...) -> String func stringByAppendingPathComponent(_ aString: String) -> String func stringByAppendingPathExtension(_ ext: String) -> String? @warn_unused_result func stringByAppendingString(_ aString: String) -> String var stringByDeletingLastPathComponent: String { get } var stringByDeletingPathExtension: String { get } var stringByExpandingTildeInPath: String { get } @warn_unused_result func stringByFoldingWithOptions(_ options: NSStringCompareOptions, locale locale: NSLocale?) -> String @warn_unused_result func stringByPaddingToLength(_ newLength: Int, withString padString: String, startingAtIndex padIndex: Int) -> String var stringByRemovingPercentEncoding: String? { get } @warn_unused_result func stringByReplacingCharactersInRange(_ range: Range<Index>, withString replacement: String) -> String @warn_unused_result func stringByReplacingOccurrencesOfString(_ target: String, withString replacement: String, options options: NSStringCompareOptions = default, range searchRange: Range<Index>? = default) -> String func stringByReplacingPercentEscapesUsingEncoding(_ encoding: NSStringEncoding) -> String? var stringByResolvingSymlinksInPath: String { get } var stringByStandardizingPath: String { get } @warn_unused_result func stringByTrimmingCharactersInSet(_ set: NSCharacterSet) -> String func stringsByAppendingPaths(_ paths: [String]) -> [String] @warn_unused_result func substringFromIndex(_ index: Index) -> String @warn_unused_result func substringToIndex(_ index: Index) -> String @warn_unused_result func substringWithRange(_ aRange: Range<Index>) -> String var localizedUppercaseString: String { get } @warn_unused_result func uppercaseStringWithLocale(_ locale: NSLocale?) -> String func writeToFile(_ path: String, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding) throws func writeToURL(_ url: NSURL, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding) throws @warn_unused_result func stringByApplyingTransform(_ transform: String, reverse reverse: Bool) -> String? @warn_unused_result func containsString(_ other: String) -> Bool @warn_unused_result func localizedCaseInsensitiveContainsString(_ other: String) -> Bool } extension String : _ObjectiveCBridgeable { } extension String { init(_ cocoaString: NSString) } extension String { typealias Index = String.CharacterView.Index var startIndex: Index { get } var endIndex: Index { get } subscript (_ i: Index) -> Character { get } } extension String { struct CharacterView { init(_ text: String) } var characters: String.CharacterView { get } mutating func withMutableCharacters<R>(_ body: (inout String.CharacterView) -> R) -> R init(_ characters: String.CharacterView) } extension String { struct UnicodeScalarView : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index : BidirectionalIndexType, Comparable { @warn_unused_result func successor() -> String.UnicodeScalarView.Index @warn_unused_result func predecessor() -> String.UnicodeScalarView.Index } var startIndex: String.UnicodeScalarView.Index { get } var endIndex: String.UnicodeScalarView.Index { get } subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get } subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get } struct Generator : GeneratorType { mutating func next() -> UnicodeScalar? } @warn_unused_result func generate() -> String.UnicodeScalarView.Generator var description: String { get } var debugDescription: String { get } } init(_ unicodeScalars: String.UnicodeScalarView) typealias UnicodeScalarIndex = String.UnicodeScalarView.Index } extension String { struct UTF16View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index { } var startIndex: String.UTF16View.Index { get } var endIndex: String.UTF16View.Index { get } subscript (_ i: String.UTF16View.Index) -> CodeUnit { get } subscript (_ i: Int) -> CodeUnit { get } subscript (_ subRange: Range<Int>) -> String.UTF16View { get } subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get } var description: String { get } var debugDescription: String { get } } var utf16: String.UTF16View { get } init?(_ utf16: String.UTF16View) typealias UTF16Index = String.UTF16View.Index } extension String { struct UTF8View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index : ForwardIndexType { @warn_unused_result func successor() -> String.UTF8View.Index } var startIndex: String.UTF8View.Index { get } var endIndex: String.UTF8View.Index { get } subscript (_ position: String.UTF8View.Index) -> CodeUnit { get } subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get } var description: String { get } var debugDescription: String { get } } var utf8: String.UTF8View { get } var nulTerminatedUTF8: ContiguousArray<CodeUnit> { get } init?(_ utf8: String.UTF8View) typealias UTF8Index = String.UTF8View.Index } extension String { @warn_unused_result static func fromCString(_ cs: UnsafePointer<CChar>) -> String? @warn_unused_result static func fromCStringRepairingIllFormedUTF8(_ cs: UnsafePointer<CChar>) -> (String?, hadError: Bool) } extension String { init(_ c: Character) } extension String { func withCString<Result>(@noescape _ f: UnsafePointer<Int8> throws -> Result) rethrows -> Result } extension String : _Reflectable { } extension String : OutputStreamType { mutating func write(_ other: String) } extension String : Streamable { func writeTo<Target : OutputStreamType>(inout _ target: Target) } extension String { init(_builtinUnicodeScalarLiteral value: Builtin.Int32) } extension String : UnicodeScalarLiteralConvertible { init(unicodeScalarLiteral value: String) } extension String { init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1) } extension String : ExtendedGraphemeClusterLiteralConvertible { init(extendedGraphemeClusterLiteral value: String) } extension String { init(_builtinUTF16StringLiteral start: Builtin.RawPointer, numberOfCodeUnits numberOfCodeUnits: Builtin.Word) } extension String { init(_builtinStringLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1) } extension String : StringLiteralConvertible { init(stringLiteral value: String) } extension String : CustomDebugStringConvertible { var debugDescription: String { get } } extension String : Equatable { } extension String : Comparable { } extension String { mutating func appendContentsOf(_ other: String) mutating func append(_ x: UnicodeScalar) } extension String : Hashable { var hashValue: Int { get } } extension String { subscript (_ subRange: Range<Index>) -> String { get } } extension String { mutating func reserveCapacity(_ n: Int) mutating func append(_ c: Character) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_ newElements: S) init<S : SequenceType where S.Generator.Element == Character>(_ characters: S) } extension String { func join<S : SequenceType where S.Generator.Element == String>(_ elements: S) -> String } extension String { mutating func replaceRange<C : CollectionType where C.Generator.Element == Character>(_ subRange: Range<Index>, with newElements: C) mutating func replaceRange(_ subRange: Range<Index>, with newElements: String) mutating func insert(_ newElement: Character, atIndex i: Index) mutating func insertContentsOf<S : CollectionType where S.Generator.Element == Character>(_ newElements: S, at i: Index) mutating func removeAtIndex(_ i: Index) -> Character mutating func removeRange(_ subRange: Range<Index>) mutating func removeAll(keepCapacity keepCapacity: Bool = default) } extension String { var lowercaseString: String { get } var uppercaseString: String { get } } extension String : StringInterpolationConvertible { init(stringInterpolation strings: String...) init<T>(stringInterpolationSegment expr: T) init(stringInterpolationSegment expr: String) init(stringInterpolationSegment expr: Character) init(stringInterpolationSegment expr: UnicodeScalar) init(stringInterpolationSegment expr: Bool) init(stringInterpolationSegment expr: Float32) init(stringInterpolationSegment expr: Float64) init(stringInterpolationSegment expr: UInt8) init(stringInterpolationSegment expr: Int8) init(stringInterpolationSegment expr: UInt16) init(stringInterpolationSegment expr: Int16) init(stringInterpolationSegment expr: UInt32) init(stringInterpolationSegment expr: Int32) init(stringInterpolationSegment expr: UInt64) init(stringInterpolationSegment expr: Int64) init(stringInterpolationSegment expr: UInt) init(stringInterpolationSegment expr: Int) } extension String { init(count count: Int, repeatedValue c: Character) init(count count: Int, repeatedValue c: UnicodeScalar) var isEmpty: Bool { get } } extension String { func hasPrefix(_ prefix: String) -> Bool func hasSuffix(_ suffix: String) -> Bool } extension String { init<T : _SignedIntegerType>(_ v: T) init<T : UnsignedIntegerType>(_ v: T) init<T : _SignedIntegerType>(_ v: T, radix radix: Int, uppercase uppercase: Bool = default) init<T : UnsignedIntegerType>(_ v: T, radix radix: Int, uppercase uppercase: Bool = default) } extension String { func toInt() -> Int? } extension String { var unicodeScalars: String.UnicodeScalarView } extension String { subscript (_ i: Int) -> Character { get } subscript (_ subRange: Range<Int>) -> String { get } var count: Int { get } } extension String : MirrorPathType { } extension String { init<T>(_ instance: T) init<T>(reflecting subject: T) } |
Modified String.withCString<Result>(_: UnsafePointer<Int8> throws -> Result) rethrows -> Result
Declaration | |
---|---|
From | @rethrows func withCString<Result>(@noescape _ f: UnsafePointer<Int8> throws -> Result) rethrows -> Result |
To | func withCString<Result>(@noescape _ f: UnsafePointer<Int8> throws -> Result) rethrows -> Result |
Modified String.CharacterView [struct]
Declaration | Protocols | |
---|---|---|
From | struct CharacterView { init(_ text: String) } extension String.CharacterView : CollectionType, Indexable, SequenceType { struct Index : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType, Comparable, _Reflectable { func successor() -> String.CharacterView.Index func predecessor() -> String.CharacterView.Index } var startIndex: String.CharacterView.Index { get } var endIndex: String.CharacterView.Index { get } subscript (_ i: String.CharacterView.Index) -> Character { get } } extension String.CharacterView : RangeReplaceableCollectionType { init() mutating func replaceRange<C : CollectionType where C.Generator.Element == Character>(_ subRange: Range<String.CharacterView.Index>, with newElements: C) mutating func reserveCapacity(_ n: Int) mutating func append(_ c: Character) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_ newElements: S) init<S : SequenceType where S.Generator.Element == Character>(_ characters: S) } extension String.CharacterView { subscript (_ subRange: Range<String.CharacterView.Index>) -> String.CharacterView { get } } | CollectionType, Indexable, RangeReplaceableCollectionType, SequenceType |
To | struct CharacterView { init(_ text: String) } extension String.CharacterView : CollectionType { struct Index : BidirectionalIndexType, Comparable, _Reflectable { func successor() -> String.CharacterView.Index func predecessor() -> String.CharacterView.Index } var startIndex: String.CharacterView.Index { get } var endIndex: String.CharacterView.Index { get } subscript (_ i: String.CharacterView.Index) -> Character { get } } extension String.CharacterView : RangeReplaceableCollectionType { init() mutating func replaceRange<C : CollectionType where C.Generator.Element == Character>(_ subRange: Range<String.CharacterView.Index>, with newElements: C) mutating func reserveCapacity(_ n: Int) mutating func append(_ c: Character) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_ newElements: S) init<S : SequenceType where S.Generator.Element == Character>(_ characters: S) } extension String.CharacterView { subscript (_ subRange: Range<String.CharacterView.Index>) -> String.CharacterView { get } } | CollectionType, RangeReplaceableCollectionType |
Modified String.CharacterView.Index [struct]
Declaration | Protocols | |
---|---|---|
From | struct Index : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType, Comparable, _Reflectable { func successor() -> String.CharacterView.Index func predecessor() -> String.CharacterView.Index } | BidirectionalIndexType, Comparable, Equatable, ForwardIndexType |
To | struct Index : BidirectionalIndexType, Comparable, _Reflectable { func successor() -> String.CharacterView.Index func predecessor() -> String.CharacterView.Index } | BidirectionalIndexType, Comparable |
Modified String.UnicodeScalarView [struct]
Declaration | Protocols | |
---|---|---|
From | struct UnicodeScalarView : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType, Comparable { @warn_unused_result func successor() -> String.UnicodeScalarView.Index @warn_unused_result func predecessor() -> String.UnicodeScalarView.Index } var startIndex: String.UnicodeScalarView.Index { get } var endIndex: String.UnicodeScalarView.Index { get } subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get } subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get } struct Generator : GeneratorType { mutating func next() -> UnicodeScalar? } @warn_unused_result func generate() -> String.UnicodeScalarView.Generator var description: String { get } var debugDescription: String { get } } extension String.UnicodeScalarView : RangeReplaceableCollectionType { init() mutating func reserveCapacity(_ n: Int) mutating func append(_ x: UnicodeScalar) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == UnicodeScalar>(_ newElements: S) mutating func replaceRange<C : CollectionType where C.Generator.Element == UnicodeScalar>(_ subRange: Range<String.UnicodeScalarView.Index>, with newElements: C) } | CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Indexable, RangeReplaceableCollectionType, SequenceType |
To | struct UnicodeScalarView : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index : BidirectionalIndexType, Comparable { @warn_unused_result func successor() -> String.UnicodeScalarView.Index @warn_unused_result func predecessor() -> String.UnicodeScalarView.Index } var startIndex: String.UnicodeScalarView.Index { get } var endIndex: String.UnicodeScalarView.Index { get } subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get } subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get } struct Generator : GeneratorType { mutating func next() -> UnicodeScalar? } @warn_unused_result func generate() -> String.UnicodeScalarView.Generator var description: String { get } var debugDescription: String { get } } extension String.UnicodeScalarView : RangeReplaceableCollectionType { init() mutating func reserveCapacity(_ n: Int) mutating func append(_ x: UnicodeScalar) mutating func appendContentsOf<S : SequenceType where S.Generator.Element == UnicodeScalar>(_ newElements: S) mutating func replaceRange<C : CollectionType where C.Generator.Element == UnicodeScalar>(_ subRange: Range<String.UnicodeScalarView.Index>, with newElements: C) } | CollectionType, CustomDebugStringConvertible, CustomStringConvertible, RangeReplaceableCollectionType |
Modified String.UnicodeScalarView.Index [struct]
Declaration | Protocols | |
---|---|---|
From | struct Index : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType, Comparable { @warn_unused_result func successor() -> String.UnicodeScalarView.Index @warn_unused_result func predecessor() -> String.UnicodeScalarView.Index } | BidirectionalIndexType, Comparable, Equatable, ForwardIndexType |
To | struct Index : BidirectionalIndexType, Comparable { @warn_unused_result func successor() -> String.UnicodeScalarView.Index @warn_unused_result func predecessor() -> String.UnicodeScalarView.Index } | BidirectionalIndexType, Comparable |
Modified String.UTF16View [struct]
Declaration | Protocols | |
---|---|---|
From | struct UTF16View : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index { } var startIndex: String.UTF16View.Index { get } var endIndex: String.UTF16View.Index { get } subscript (_ i: String.UTF16View.Index) -> CodeUnit { get } subscript (_ i: Int) -> CodeUnit { get } subscript (_ subRange: Range<Int>) -> String.UTF16View { get } subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get } var description: String { get } var debugDescription: String { get } } | CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Indexable, SequenceType |
To | struct UTF16View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index { } var startIndex: String.UTF16View.Index { get } var endIndex: String.UTF16View.Index { get } subscript (_ i: String.UTF16View.Index) -> CodeUnit { get } subscript (_ i: Int) -> CodeUnit { get } subscript (_ subRange: Range<Int>) -> String.UTF16View { get } subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get } var description: String { get } var debugDescription: String { get } } | CollectionType, CustomDebugStringConvertible, CustomStringConvertible |
Modified String.UTF16View.Index [struct]
Declaration | Protocols | |
---|---|---|
From | struct Index { } extension String.UTF16View.Index : ForwardIndexType, _Incrementable, BidirectionalIndexType { typealias Distance = Int @warn_unused_result func successor() -> String.UTF16View.Index @warn_unused_result func predecessor() -> String.UTF16View.Index } extension String.UTF16View.Index : Equatable, Comparable { } extension String.UTF16View.Index { @warn_unused_result func distanceTo(_ end: String.UTF16View.Index) -> Distance @warn_unused_result func advancedBy(_ n: Distance) -> String.UTF16View.Index @warn_unused_result func advancedBy(_ n: Distance, limit limit: String.UTF16View.Index) -> String.UTF16View.Index } extension String.UTF16View.Index { init?(_ utf8Index: UTF8Index, within utf16: String.UTF16View) init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf16: String.UTF16View) init(_ characterIndex: Index, within utf16: String.UTF16View) @warn_unused_result func samePositionIn(_ utf8: String.UTF8View) -> String.UTF8View.Index? @warn_unused_result func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> UnicodeScalarIndex? @warn_unused_result func samePositionIn(_ characters: String) -> Index? } | BidirectionalIndexType, Comparable, Equatable, ForwardIndexType |
To | struct Index { } extension String.UTF16View.Index : BidirectionalIndexType { typealias Distance = Int @warn_unused_result func successor() -> String.UTF16View.Index @warn_unused_result func predecessor() -> String.UTF16View.Index } extension String.UTF16View.Index : Comparable, Equatable { } extension String.UTF16View.Index { @warn_unused_result func distanceTo(_ end: String.UTF16View.Index) -> Distance @warn_unused_result func advancedBy(_ n: Distance) -> String.UTF16View.Index @warn_unused_result func advancedBy(_ n: Distance, limit limit: String.UTF16View.Index) -> String.UTF16View.Index } extension String.UTF16View.Index { init?(_ utf8Index: UTF8Index, within utf16: String.UTF16View) init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf16: String.UTF16View) init(_ characterIndex: Index, within utf16: String.UTF16View) @warn_unused_result func samePositionIn(_ utf8: String.UTF8View) -> String.UTF8View.Index? @warn_unused_result func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> UnicodeScalarIndex? @warn_unused_result func samePositionIn(_ characters: String) -> Index? } | BidirectionalIndexType, Comparable, Equatable |
Modified String.UTF8View [struct]
Declaration | Protocols | |
---|---|---|
From | struct UTF8View : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index : ForwardIndexType, _Incrementable, Equatable { @warn_unused_result func successor() -> String.UTF8View.Index } var startIndex: String.UTF8View.Index { get } var endIndex: String.UTF8View.Index { get } subscript (_ position: String.UTF8View.Index) -> CodeUnit { get } subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get } var description: String { get } var debugDescription: String { get } } | CollectionType, CustomDebugStringConvertible, CustomStringConvertible, Indexable, SequenceType |
To | struct UTF8View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible { struct Index : ForwardIndexType { @warn_unused_result func successor() -> String.UTF8View.Index } var startIndex: String.UTF8View.Index { get } var endIndex: String.UTF8View.Index { get } subscript (_ position: String.UTF8View.Index) -> CodeUnit { get } subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get } var description: String { get } var debugDescription: String { get } } | CollectionType, CustomDebugStringConvertible, CustomStringConvertible |
Modified String.UTF8View.Index [struct]
Declaration | Protocols | |
---|---|---|
From | struct Index : ForwardIndexType, _Incrementable, Equatable { @warn_unused_result func successor() -> String.UTF8View.Index } extension String.UTF8View.Index { init?(_ utf16Index: UTF16Index, within utf8: String.UTF8View) init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf8: String.UTF8View) init(_ characterIndex: Index, within utf8: String.UTF8View) @warn_unused_result func samePositionIn(_ utf16: String.UTF16View) -> String.UTF16View.Index? @warn_unused_result func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> UnicodeScalarIndex? @warn_unused_result func samePositionIn(_ characters: String) -> Index? } | Equatable, ForwardIndexType |
To | struct Index : ForwardIndexType { @warn_unused_result func successor() -> String.UTF8View.Index } extension String.UTF8View.Index { init?(_ utf16Index: UTF16Index, within utf8: String.UTF8View) init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf8: String.UTF8View) init(_ characterIndex: Index, within utf8: String.UTF8View) @warn_unused_result func samePositionIn(_ utf16: String.UTF16View) -> String.UTF16View.Index? @warn_unused_result func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> UnicodeScalarIndex? @warn_unused_result func samePositionIn(_ characters: String) -> Index? } | ForwardIndexType |
Modified UInt [struct]
Declaration | Protocols | |
---|---|---|
From | struct UInt : _IntegerArithmeticType, Comparable, Equatable, _DisallowMixedSignArithmetic, _IntegerType, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, UnsignedIntegerType { var value: Builtin.Int32 typealias Distance = Int init() init(_ v: Builtin.Word) init(_ value: UInt) init(bigEndian value: UInt) init(littleEndian value: UInt) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: UInt) var bigEndian: UInt { get } var littleEndian: UInt { get } var byteSwapped: UInt { get } static var max: UInt { get } static var min: UInt { get } } extension UInt { init(_ value: CGFloat) } extension UInt : _ObjectiveCBridgeable { init(_ number: NSNumber) } extension UInt : Hashable { var hashValue: Int { get } } extension UInt : CustomStringConvertible { var description: String { get } } extension UInt : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity { func successor() -> UInt func predecessor() -> UInt func distanceTo(_ other: UInt) -> Distance func advancedBy(_ n: Distance) -> UInt } extension UInt { static func addWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func divideWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax } extension UInt { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: Int) init(bitPattern bitPattern: Int) } extension UInt : BitwiseOperationsType { static var allZeros: UInt { get } } extension UInt { init(_ other: Float) init(_ other: Double) } extension UInt { init?(_ text: String, radix radix: Int = default) } extension UInt : _Reflectable { } extension UInt : CVarArgType { } | BidirectionalIndexType, BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, RandomAccessIndexType, Strideable, UnsignedIntegerType |
To | struct UInt : UnsignedIntegerType, Comparable, Equatable { var value: Builtin.Int32 typealias Distance = Int init() init(_ v: Builtin.Word) init(_ value: UInt) init(bigEndian value: UInt) init(littleEndian value: UInt) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: UInt) var bigEndian: UInt { get } var littleEndian: UInt { get } var byteSwapped: UInt { get } static var max: UInt { get } static var min: UInt { get } } extension UInt { init(_ value: CGFloat) } extension UInt : _ObjectiveCBridgeable { init(_ number: NSNumber) } extension UInt : Hashable { var hashValue: Int { get } } extension UInt : CustomStringConvertible { var description: String { get } } extension UInt : RandomAccessIndexType { func successor() -> UInt func predecessor() -> UInt func distanceTo(_ other: UInt) -> Distance func advancedBy(_ n: Distance) -> UInt } extension UInt { static func addWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func divideWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax } extension UInt { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: Int) init(bitPattern bitPattern: Int) } extension UInt : BitwiseOperationsType { static var allZeros: UInt { get } } extension UInt { init(_ other: Float) init(_ other: Double) } extension UInt { init?(_ text: String, radix radix: Int = default) } extension UInt : _Reflectable { } extension UInt : CVarArgType { } | BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, UnsignedIntegerType |
Modified UInt16 [struct]
Declaration | Protocols | |
---|---|---|
From | struct UInt16 : _IntegerArithmeticType, Comparable, Equatable, _DisallowMixedSignArithmetic, _IntegerType, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, UnsignedIntegerType { var value: Builtin.Int16 typealias Distance = Int init() init(_ value: UInt16) init(bigEndian value: UInt16) init(littleEndian value: UInt16) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: UInt16) var bigEndian: UInt16 { get } var littleEndian: UInt16 { get } var byteSwapped: UInt16 { get } static var max: UInt16 { get } static var min: UInt16 { get } } extension UInt16 { init(_ value: CGFloat) } extension UInt16 : Hashable { var hashValue: Int { get } } extension UInt16 : CustomStringConvertible { var description: String { get } } extension UInt16 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity { func successor() -> UInt16 func predecessor() -> UInt16 func distanceTo(_ other: UInt16) -> Distance func advancedBy(_ n: Distance) -> UInt16 } extension UInt16 { static func addWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func divideWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax } extension UInt16 { init(_ v: UInt8) init(_ v: Int8) init(_ v: Int16) init(_ v: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ v: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: Int16) } extension UInt16 : BitwiseOperationsType { static var allZeros: UInt16 { get } } extension UInt16 { init(_ other: Float) init(_ other: Double) } extension UInt16 { init?(_ text: String, radix radix: Int = default) } extension UInt16 : _Reflectable { } extension UInt16 : CVarArgType { } | BidirectionalIndexType, BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, RandomAccessIndexType, Strideable, UnsignedIntegerType |
To | struct UInt16 : UnsignedIntegerType, Comparable, Equatable { var value: Builtin.Int16 typealias Distance = Int init() init(_ value: UInt16) init(bigEndian value: UInt16) init(littleEndian value: UInt16) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: UInt16) var bigEndian: UInt16 { get } var littleEndian: UInt16 { get } var byteSwapped: UInt16 { get } static var max: UInt16 { get } static var min: UInt16 { get } } extension UInt16 { init(_ value: CGFloat) } extension UInt16 : Hashable { var hashValue: Int { get } } extension UInt16 : CustomStringConvertible { var description: String { get } } extension UInt16 : RandomAccessIndexType { func successor() -> UInt16 func predecessor() -> UInt16 func distanceTo(_ other: UInt16) -> Distance func advancedBy(_ n: Distance) -> UInt16 } extension UInt16 { static func addWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func divideWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax } extension UInt16 { init(_ v: UInt8) init(_ v: Int8) init(_ v: Int16) init(_ v: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ v: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: Int16) } extension UInt16 : BitwiseOperationsType { static var allZeros: UInt16 { get } } extension UInt16 { init(_ other: Float) init(_ other: Double) } extension UInt16 { init?(_ text: String, radix radix: Int = default) } extension UInt16 : _Reflectable { } extension UInt16 : CVarArgType { } | BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, UnsignedIntegerType |
Modified UInt32 [struct]
Declaration | Protocols | |
---|---|---|
From | struct UInt32 : _IntegerArithmeticType, Comparable, Equatable, _DisallowMixedSignArithmetic, _IntegerType, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, UnsignedIntegerType { var value: Builtin.Int32 typealias Distance = Int init() init(_ value: UInt32) init(bigEndian value: UInt32) init(littleEndian value: UInt32) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: UInt32) var bigEndian: UInt32 { get } var littleEndian: UInt32 { get } var byteSwapped: UInt32 { get } static var max: UInt32 { get } static var min: UInt32 { get } } extension UInt32 { init(_ value: CGFloat) } extension UInt32 : Hashable { var hashValue: Int { get } } extension UInt32 : CustomStringConvertible { var description: String { get } } extension UInt32 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity { func successor() -> UInt32 func predecessor() -> UInt32 func distanceTo(_ other: UInt32) -> Distance func advancedBy(_ n: Distance) -> UInt32 } extension UInt32 { static func addWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func divideWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax } extension UInt32 { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: Int32) } extension UInt32 : BitwiseOperationsType { static var allZeros: UInt32 { get } } extension UInt32 { init(_ other: Float) init(_ other: Double) } extension UInt32 { init?(_ text: String, radix radix: Int = default) } extension UInt32 : _Reflectable { } extension UInt32 { init(_ v: UnicodeScalar) } extension UInt32 : CVarArgType { } | BidirectionalIndexType, BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, RandomAccessIndexType, Strideable, UnsignedIntegerType |
To | struct UInt32 : UnsignedIntegerType, Comparable, Equatable { var value: Builtin.Int32 typealias Distance = Int init() init(_ value: UInt32) init(bigEndian value: UInt32) init(littleEndian value: UInt32) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: UInt32) var bigEndian: UInt32 { get } var littleEndian: UInt32 { get } var byteSwapped: UInt32 { get } static var max: UInt32 { get } static var min: UInt32 { get } } extension UInt32 { init(_ value: CGFloat) } extension UInt32 : Hashable { var hashValue: Int { get } } extension UInt32 : CustomStringConvertible { var description: String { get } } extension UInt32 : RandomAccessIndexType { func successor() -> UInt32 func predecessor() -> UInt32 func distanceTo(_ other: UInt32) -> Distance func advancedBy(_ n: Distance) -> UInt32 } extension UInt32 { static func addWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func divideWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax } extension UInt32 { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: Int32) } extension UInt32 : BitwiseOperationsType { static var allZeros: UInt32 { get } } extension UInt32 { init(_ other: Float) init(_ other: Double) } extension UInt32 { init?(_ text: String, radix radix: Int = default) } extension UInt32 : _Reflectable { } extension UInt32 { init(_ v: UnicodeScalar) } extension UInt32 : CVarArgType { } | BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, UnsignedIntegerType |
Modified UInt64 [struct]
Declaration | Protocols | |
---|---|---|
From | struct UInt64 : _IntegerArithmeticType, Comparable, Equatable, _DisallowMixedSignArithmetic, _IntegerType, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, UnsignedIntegerType { var value: Builtin.Int64 typealias Distance = Int init() init(_ value: UInt64) init(bigEndian value: UInt64) init(littleEndian value: UInt64) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: UInt64) var bigEndian: UInt64 { get } var littleEndian: UInt64 { get } var byteSwapped: UInt64 { get } static var max: UInt64 { get } static var min: UInt64 { get } } extension UInt64 { init(_ value: CGFloat) } extension UInt64 : Hashable { var hashValue: Int { get } } extension UInt64 : CustomStringConvertible { var description: String { get } } extension UInt64 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity { func successor() -> UInt64 func predecessor() -> UInt64 func distanceTo(_ other: UInt64) -> Distance func advancedBy(_ n: Distance) -> UInt64 } extension UInt64 { static func addWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func divideWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax } extension UInt64 { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: Int64) init(_ v: UInt) init(_ v: Int) init(bitPattern bitPattern: Int64) } extension UInt64 : BitwiseOperationsType { static var allZeros: UInt64 { get } } extension UInt64 { init(_ other: Float) init(_ other: Double) } extension UInt64 { init?(_ text: String, radix radix: Int = default) } extension UInt64 : _Reflectable { } extension UInt64 { init(_ v: UnicodeScalar) } extension UInt64 : CVarArgType, _CVarArgAlignedType { } | BidirectionalIndexType, BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, RandomAccessIndexType, Strideable, UnsignedIntegerType |
To | struct UInt64 : UnsignedIntegerType, Comparable, Equatable { var value: Builtin.Int64 typealias Distance = Int init() init(_ value: UInt64) init(bigEndian value: UInt64) init(littleEndian value: UInt64) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: UInt64) var bigEndian: UInt64 { get } var littleEndian: UInt64 { get } var byteSwapped: UInt64 { get } static var max: UInt64 { get } static var min: UInt64 { get } } extension UInt64 { init(_ value: CGFloat) } extension UInt64 : Hashable { var hashValue: Int { get } } extension UInt64 : CustomStringConvertible { var description: String { get } } extension UInt64 : RandomAccessIndexType { func successor() -> UInt64 func predecessor() -> UInt64 func distanceTo(_ other: UInt64) -> Distance func advancedBy(_ n: Distance) -> UInt64 } extension UInt64 { static func addWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func divideWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax } extension UInt64 { init(_ v: UInt8) init(_ v: Int8) init(_ v: UInt16) init(_ v: Int16) init(_ v: UInt32) init(_ v: Int32) init(_ v: Int64) init(_ v: UInt) init(_ v: Int) init(bitPattern bitPattern: Int64) } extension UInt64 : BitwiseOperationsType { static var allZeros: UInt64 { get } } extension UInt64 { init(_ other: Float) init(_ other: Double) } extension UInt64 { init?(_ text: String, radix radix: Int = default) } extension UInt64 : _Reflectable { } extension UInt64 { init(_ v: UnicodeScalar) } extension UInt64 : CVarArgType, _CVarArgAlignedType { } | BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, UnsignedIntegerType |
Modified UInt8 [struct]
Declaration | Protocols | |
---|---|---|
From | struct UInt8 : _IntegerArithmeticType, Comparable, Equatable, _DisallowMixedSignArithmetic, _IntegerType, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, UnsignedIntegerType { var value: Builtin.Int8 typealias Distance = Int init() init(_ value: UInt8) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: UInt8) static var max: UInt8 { get } static var min: UInt8 { get } } extension UInt8 { init(_ value: CGFloat) } extension UInt8 : Hashable { var hashValue: Int { get } } extension UInt8 : CustomStringConvertible { var description: String { get } } extension UInt8 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity { func successor() -> UInt8 func predecessor() -> UInt8 func distanceTo(_ other: UInt8) -> Distance func advancedBy(_ n: Distance) -> UInt8 } extension UInt8 { static func addWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func divideWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax } extension UInt8 { init(_ v: Int8) init(_ v: UInt16) init(truncatingBitPattern truncatingBitPattern: UInt16) init(_ v: Int16) init(truncatingBitPattern truncatingBitPattern: Int16) init(_ v: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ v: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: Int8) } extension UInt8 : BitwiseOperationsType { static var allZeros: UInt8 { get } } extension UInt8 { init(_ other: Float) init(_ other: Double) } extension UInt8 { init?(_ text: String, radix radix: Int = default) } extension UInt8 : _Reflectable { } extension UInt8 { init(ascii v: UnicodeScalar) } extension UInt8 : CVarArgType { } | BidirectionalIndexType, BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, ForwardIndexType, Hashable, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, RandomAccessIndexType, Strideable, UnsignedIntegerType |
To | struct UInt8 : UnsignedIntegerType, Comparable, Equatable { var value: Builtin.Int8 typealias Distance = Int init() init(_ value: UInt8) init(_builtinIntegerLiteral value: Builtin.Int2048) init(integerLiteral value: UInt8) static var max: UInt8 { get } static var min: UInt8 { get } } extension UInt8 { init(_ value: CGFloat) } extension UInt8 : Hashable { var hashValue: Int { get } } extension UInt8 : CustomStringConvertible { var description: String { get } } extension UInt8 : RandomAccessIndexType { func successor() -> UInt8 func predecessor() -> UInt8 func distanceTo(_ other: UInt8) -> Distance func advancedBy(_ n: Distance) -> UInt8 } extension UInt8 { static func addWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func subtractWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func multiplyWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func divideWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) static func remainderWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool) func toUIntMax() -> UIntMax func toIntMax() -> IntMax } extension UInt8 { init(_ v: Int8) init(_ v: UInt16) init(truncatingBitPattern truncatingBitPattern: UInt16) init(_ v: Int16) init(truncatingBitPattern truncatingBitPattern: Int16) init(_ v: UInt32) init(truncatingBitPattern truncatingBitPattern: UInt32) init(_ v: Int32) init(truncatingBitPattern truncatingBitPattern: Int32) init(_ v: UInt64) init(truncatingBitPattern truncatingBitPattern: UInt64) init(_ v: Int64) init(truncatingBitPattern truncatingBitPattern: Int64) init(_ v: UInt) init(truncatingBitPattern truncatingBitPattern: UInt) init(_ v: Int) init(truncatingBitPattern truncatingBitPattern: Int) init(bitPattern bitPattern: Int8) } extension UInt8 : BitwiseOperationsType { static var allZeros: UInt8 { get } } extension UInt8 { init(_ other: Float) init(_ other: Double) } extension UInt8 { init?(_ text: String, radix radix: Int = default) } extension UInt8 : _Reflectable { } extension UInt8 { init(ascii v: UnicodeScalar) } extension UInt8 : CVarArgType { } | BitwiseOperationsType, CVarArgType, Comparable, CustomStringConvertible, Equatable, Hashable, RandomAccessIndexType, UnsignedIntegerType |
Modified UnicodeScalar [struct]
Declaration | |
---|---|
From | struct UnicodeScalar : UnicodeScalarLiteralConvertible { var value: UInt32 { get } init(_builtinUnicodeScalarLiteral value: Builtin.Int32) init(unicodeScalarLiteral value: UnicodeScalar) init() init(_ v: UInt32) init(_ v: UInt16) init(_ v: UInt8) init(_ v: UnicodeScalar) @warn_unused_result func escape(asASCII forceASCII: Bool) -> String @warn_unused_result func isASCII() -> Bool } extension UnicodeScalar : _Reflectable { } extension UnicodeScalar : Streamable { func writeTo<Target : OutputStreamType>(inout _ target: Target) } extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension UnicodeScalar : Hashable { var hashValue: Int { get } } extension UnicodeScalar { init(_ v: Int) } extension UnicodeScalar : Equatable, Comparable { } |
To | struct UnicodeScalar : UnicodeScalarLiteralConvertible { var value: UInt32 { get } init(_builtinUnicodeScalarLiteral value: Builtin.Int32) init(unicodeScalarLiteral value: UnicodeScalar) init() init(_ v: UInt32) init(_ v: UInt16) init(_ v: UInt8) init(_ v: UnicodeScalar) @warn_unused_result func escape(asASCII forceASCII: Bool) -> String @warn_unused_result func isASCII() -> Bool } extension UnicodeScalar : _Reflectable { } extension UnicodeScalar : Streamable { func writeTo<Target : OutputStreamType>(inout _ target: Target) } extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible { var description: String { get } var debugDescription: String { get } } extension UnicodeScalar : Hashable { var hashValue: Int { get } } extension UnicodeScalar { init(_ v: Int) } extension UnicodeScalar : Comparable, Equatable { } |
Modified Unmanaged [struct]
Declaration | |
---|---|
From | struct Unmanaged<Instance> { typealias T = Instance @warn_unused_result static func fromOpaque(_ value: COpaquePointer) -> Unmanaged<Instance> @warn_unused_result func toOpaque() -> COpaquePointer @warn_unused_result static func passRetained(_ value: Instance) -> Unmanaged<Instance> @warn_unused_result static func passUnretained(_ value: Instance) -> Unmanaged<Instance> @warn_unused_result func takeUnretainedValue() -> Instance @warn_unused_result func takeRetainedValue() -> Instance func retain() -> Unmanaged<Instance> func release() func autorelease() -> Unmanaged<Instance> } |
To | struct Unmanaged<Instance : AnyObject> { typealias T = Instance @warn_unused_result static func fromOpaque(_ value: COpaquePointer) -> Unmanaged<Instance> @warn_unused_result func toOpaque() -> COpaquePointer @warn_unused_result static func passRetained(_ value: Instance) -> Unmanaged<Instance> @warn_unused_result static func passUnretained(_ value: Instance) -> Unmanaged<Instance> @warn_unused_result func takeUnretainedValue() -> Instance @warn_unused_result func takeRetainedValue() -> Instance func retain() -> Unmanaged<Instance> func release() func autorelease() -> Unmanaged<Instance> } |
Modified UnsafeBufferPointer [struct]
Declaration | Protocols | |
---|---|---|
From | struct UnsafeBufferPointer<Element> : CollectionType, Indexable, SequenceType { typealias T = Element var startIndex: Int { get } var endIndex: Int { get } subscript (_ i: Int) -> Element { get } init(start start: UnsafePointer<Element>, count count: Int) func generate() -> UnsafeBufferPointerGenerator<Element> var baseAddress: UnsafePointer<Element> { get } var count: Int { get } } extension UnsafeBufferPointer { init(_ audioBuffer: AudioBuffer) } extension UnsafeBufferPointer : CustomDebugStringConvertible { var debugDescription: String { get } } | CollectionType, CustomDebugStringConvertible, Indexable, SequenceType |
To | struct UnsafeBufferPointer<Element> : CollectionType { typealias T = Element var startIndex: Int { get } var endIndex: Int { get } subscript (_ i: Int) -> Element { get } init(start start: UnsafePointer<Element>, count count: Int) func generate() -> UnsafeBufferPointerGenerator<Element> var baseAddress: UnsafePointer<Element> { get } var count: Int { get } } extension UnsafeBufferPointer { init(_ audioBuffer: AudioBuffer) } extension UnsafeBufferPointer : CustomDebugStringConvertible { var debugDescription: String { get } } | CollectionType, CustomDebugStringConvertible |
Modified UnsafeMutableBufferPointer [struct]
Declaration | Protocols | |
---|---|---|
From | struct UnsafeMutableBufferPointer<Element> : MutableCollectionType, CollectionType, Indexable, SequenceType, MutableIndexable { typealias T = Element var startIndex: Int { get } var endIndex: Int { get } subscript (_ i: Int) -> Element { get nonmutating set } init(start start: UnsafeMutablePointer<Element>, count count: Int) func generate() -> UnsafeBufferPointerGenerator<Element> var baseAddress: UnsafeMutablePointer<Element> { get } var count: Int { get } } extension UnsafeMutableBufferPointer { init(_ audioBuffer: AudioBuffer) } extension UnsafeMutableBufferPointer : CustomDebugStringConvertible { var debugDescription: String { get } } | CollectionType, CustomDebugStringConvertible, Indexable, MutableCollectionType, MutableIndexable, SequenceType |
To | struct UnsafeMutableBufferPointer<Element> : MutableCollectionType { typealias T = Element var startIndex: Int { get } var endIndex: Int { get } subscript (_ i: Int) -> Element { get nonmutating set } init(start start: UnsafeMutablePointer<Element>, count count: Int) func generate() -> UnsafeBufferPointerGenerator<Element> var baseAddress: UnsafeMutablePointer<Element> { get } var count: Int { get } } extension UnsafeMutableBufferPointer { init(_ audioBuffer: AudioBuffer) } extension UnsafeMutableBufferPointer : CustomDebugStringConvertible { var debugDescription: String { get } } | CustomDebugStringConvertible, MutableCollectionType |
Modified UnsafeMutablePointer [struct]
Declaration | Protocols | |
---|---|---|
From | struct UnsafeMutablePointer<Memory> : Equatable, Hashable, NilLiteralConvertible, _PointerType, BidirectionalIndexType, ForwardIndexType, _Incrementable, RandomAccessIndexType, Strideable, Comparable, _Strideable, _RandomAccessAmbiguity { typealias T = Memory typealias Distance = Int init() init(_ other: COpaquePointer) init(bitPattern bitPattern: Int) init(bitPattern bitPattern: UInt) init<U>(_ from: UnsafeMutablePointer<U>) init<U>(_ from: UnsafePointer<U>) init(nilLiteral nilLiteral: ()) @warn_unused_result static func alloc(_ num: Int) -> UnsafeMutablePointer<Memory> func dealloc(_ num: Int) var memory: Memory { get nonmutating set } func initialize(_ newvalue: Memory) @warn_unused_result func move() -> Memory func assignFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func assignBackwardFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func moveInitializeFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func moveInitializeBackwardFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func initializeFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func initializeFrom<C : CollectionType where C.Generator.Element == Memory>(_ source: C) func moveAssignFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func destroy() func destroy(_ count: Int) subscript (_ i: Int) -> Memory { get nonmutating set } var hashValue: Int { get } func successor() -> UnsafeMutablePointer<Memory> func predecessor() -> UnsafeMutablePointer<Memory> func distanceTo(_ x: UnsafeMutablePointer<Memory>) -> Int func advancedBy(_ n: Int) -> UnsafeMutablePointer<Memory> } extension UnsafeMutablePointer : CustomDebugStringConvertible { var debugDescription: String { get } } extension UnsafeMutablePointer : _Reflectable { } extension UnsafeMutablePointer : CVarArgType { } | BidirectionalIndexType, CVarArgType, Comparable, CustomDebugStringConvertible, Equatable, ForwardIndexType, Hashable, NilLiteralConvertible, RandomAccessIndexType, Strideable |
To | struct UnsafeMutablePointer<Memory> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType { typealias T = Memory typealias Distance = Int init() init(_ other: COpaquePointer) init(bitPattern bitPattern: Int) init(bitPattern bitPattern: UInt) init<U>(_ from: UnsafeMutablePointer<U>) init<U>(_ from: UnsafePointer<U>) init(nilLiteral nilLiteral: ()) @warn_unused_result static func alloc(_ num: Int) -> UnsafeMutablePointer<Memory> func dealloc(_ num: Int) var memory: Memory { get nonmutating set } func initialize(_ newvalue: Memory) @warn_unused_result func move() -> Memory func assignFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func assignBackwardFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func moveInitializeFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func moveInitializeBackwardFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func initializeFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func initializeFrom<C : CollectionType where C.Generator.Element == Memory>(_ source: C) func moveAssignFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int) func destroy() func destroy(_ count: Int) subscript (_ i: Int) -> Memory { get nonmutating set } var hashValue: Int { get } func successor() -> UnsafeMutablePointer<Memory> func predecessor() -> UnsafeMutablePointer<Memory> func distanceTo(_ x: UnsafeMutablePointer<Memory>) -> Int func advancedBy(_ n: Int) -> UnsafeMutablePointer<Memory> } extension UnsafeMutablePointer : CustomDebugStringConvertible { var debugDescription: String { get } } extension UnsafeMutablePointer : _Reflectable { } extension UnsafeMutablePointer : CVarArgType { } | CVarArgType, CustomDebugStringConvertible, Hashable, NilLiteralConvertible, RandomAccessIndexType |
Modified UnsafePointer [struct]
Declaration | Protocols | |
---|---|---|
From | struct UnsafePointer<Memory> : Equatable, Hashable, NilLiteralConvertible, _PointerType, BidirectionalIndexType, ForwardIndexType, _Incrementable, RandomAccessIndexType, Strideable, Comparable, _Strideable, _RandomAccessAmbiguity { typealias T = Memory typealias Distance = Int init() init(_ other: COpaquePointer) init(bitPattern bitPattern: Int) init(bitPattern bitPattern: UInt) init<U>(_ from: UnsafeMutablePointer<U>) init<U>(_ from: UnsafePointer<U>) init(nilLiteral nilLiteral: ()) var memory: Memory { get } subscript (_ i: Int) -> Memory { get } var hashValue: Int { get } func successor() -> UnsafePointer<Memory> func predecessor() -> UnsafePointer<Memory> func distanceTo(_ x: UnsafePointer<Memory>) -> Int func advancedBy(_ n: Int) -> UnsafePointer<Memory> } extension UnsafePointer : CustomDebugStringConvertible { var debugDescription: String { get } } extension UnsafePointer : _Reflectable { } extension UnsafePointer : CVarArgType { } | BidirectionalIndexType, CVarArgType, Comparable, CustomDebugStringConvertible, Equatable, ForwardIndexType, Hashable, NilLiteralConvertible, RandomAccessIndexType, Strideable |
To | struct UnsafePointer<Memory> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType { typealias T = Memory typealias Distance = Int init() init(_ other: COpaquePointer) init(bitPattern bitPattern: Int) init(bitPattern bitPattern: UInt) init<U>(_ from: UnsafeMutablePointer<U>) init<U>(_ from: UnsafePointer<U>) init(nilLiteral nilLiteral: ()) var memory: Memory { get } subscript (_ i: Int) -> Memory { get } var hashValue: Int { get } func successor() -> UnsafePointer<Memory> func predecessor() -> UnsafePointer<Memory> func distanceTo(_ x: UnsafePointer<Memory>) -> Int func advancedBy(_ n: Int) -> UnsafePointer<Memory> } extension UnsafePointer : CustomDebugStringConvertible { var debugDescription: String { get } } extension UnsafePointer : _Reflectable { } extension UnsafePointer : CVarArgType { } | CVarArgType, CustomDebugStringConvertible, Hashable, NilLiteralConvertible, RandomAccessIndexType |
Modified VaListBuilder
Protocols | |
---|---|
From | AnyObject |
To | -- |
Modified &&(_: T, _: () throws -> Bool) rethrows -> Bool
Declaration | |
---|---|
From | @warn_unused_result @rethrows func &&<T : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> Bool) rethrows -> Bool |
To | @warn_unused_result func &&<T : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> Bool) rethrows -> Bool |
Modified &&(_: T, _: () throws -> U) rethrows -> Bool
Declaration | |
---|---|
From | @warn_unused_result @rethrows func &&<T : BooleanType, U : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> U) rethrows -> Bool |
To | @warn_unused_result func &&<T : BooleanType, U : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> U) rethrows -> Bool |
Modified ??(_: T?, _: () throws -> T) rethrows -> T
Declaration | |
---|---|
From | @warn_unused_result @rethrows func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T) rethrows -> T |
To | @warn_unused_result func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T) rethrows -> T |
Modified ??(_: T?, _: () throws -> T?) rethrows -> T?
Declaration | |
---|---|
From | @warn_unused_result @rethrows func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T?) rethrows -> T? |
To | @warn_unused_result func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T?) rethrows -> T? |
Modified isUniquelyReferencedNonObjC<T : AnyObject>(_: T) -> Bool
Declaration | |
---|---|
From | func isUniquelyReferencedNonObjC<T>(inout _ object: T) -> Bool |
To | func isUniquelyReferencedNonObjC<T : AnyObject>(inout _ object: T) -> Bool |
Modified isUniquelyReferencedNonObjC<T : AnyObject>(_: T?) -> Bool
Declaration | |
---|---|
From | func isUniquelyReferencedNonObjC<T>(inout _ object: T?) -> Bool |
To | func isUniquelyReferencedNonObjC<T : AnyObject>(inout _ object: T?) -> Bool |
Modified LazyCollectionType.Elements
Declaration | |
---|---|
From | typealias Elements : CollectionType, SequenceType = Self |
To | typealias Elements : CollectionType = Self |
Modified MutableCollectionType.SubSequence
Declaration | |
---|---|
From | typealias SubSequence : Indexable, SequenceType = MutableSlice<Self> |
To | typealias SubSequence = MutableSlice<Self> |
Modified unsafeDowncast<T : AnyObject>(_: AnyObject) -> T
Declaration | |
---|---|
From | @warn_unused_result func unsafeDowncast<T>(_ x: AnyObject) -> T |
To | @warn_unused_result func unsafeDowncast<T : AnyObject>(_ x: AnyObject) -> T |
Modified withExtendedLifetime<T, Result>(_: T, _: T throws -> Result) rethrows -> Result
Declaration | |
---|---|
From | @rethrows func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: T throws -> Result) rethrows -> Result |
To | func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: T throws -> Result) rethrows -> Result |
Modified withExtendedLifetime<T, Result>(_: T, _: () throws -> Result) rethrows -> Result
Declaration | |
---|---|
From | @rethrows func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: () throws -> Result) rethrows -> Result |
To | func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: () throws -> Result) rethrows -> Result |
Modified withUnsafeMutablePointer<T, Result>(_: T, _: UnsafeMutablePointer<T> throws -> Result) rethrows -> Result
Declaration | |
---|---|
From | @rethrows func withUnsafeMutablePointer<T, Result>(inout _ arg: T, @noescape _ body: UnsafeMutablePointer<T> throws -> Result) rethrows -> Result |
To | func withUnsafeMutablePointer<T, Result>(inout _ arg: T, @noescape _ body: UnsafeMutablePointer<T> throws -> Result) rethrows -> Result |
Modified withUnsafeMutablePointers<A0, A1, Result>(_: A0, _: A1, _: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>) throws -> Result) rethrows -> Result
Declaration | |
---|---|
From | @rethrows func withUnsafeMutablePointers<A0, A1, Result>(inout _ arg0: A0, inout _ arg1: A1, @noescape _ body: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>) throws -> Result) rethrows -> Result |
To | func withUnsafeMutablePointers<A0, A1, Result>(inout _ arg0: A0, inout _ arg1: A1, @noescape _ body: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>) throws -> Result) rethrows -> Result |
Modified withUnsafeMutablePointers<A0, A1, A2, Result>(_: A0, _: A1, _: A2, _: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>, UnsafeMutablePointer<A2>) throws -> Result) rethrows -> Result
Declaration | |
---|---|
From | @rethrows func withUnsafeMutablePointers<A0, A1, A2, Result>(inout _ arg0: A0, inout _ arg1: A1, inout _ arg2: A2, @noescape _ body: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>, UnsafeMutablePointer<A2>) throws -> Result) rethrows -> Result |
To | func withUnsafeMutablePointers<A0, A1, A2, Result>(inout _ arg0: A0, inout _ arg1: A1, inout _ arg2: A2, @noescape _ body: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>, UnsafeMutablePointer<A2>) throws -> Result) rethrows -> Result |
Modified withUnsafePointer<T, Result>(_: T, _: UnsafePointer<T> throws -> Result) rethrows -> Result
Declaration | |
---|---|
From | @rethrows func withUnsafePointer<T, Result>(inout _ arg: T, @noescape _ body: UnsafePointer<T> throws -> Result) rethrows -> Result |
To | func withUnsafePointer<T, Result>(inout _ arg: T, @noescape _ body: UnsafePointer<T> throws -> Result) rethrows -> Result |
Modified withUnsafePointers<A0, A1, Result>(_: A0, _: A1, _: (UnsafePointer<A0>, UnsafePointer<A1>) throws -> Result) rethrows -> Result
Declaration | |
---|---|
From | @rethrows func withUnsafePointers<A0, A1, Result>(inout _ arg0: A0, inout _ arg1: A1, @noescape _ body: (UnsafePointer<A0>, UnsafePointer<A1>) throws -> Result) rethrows -> Result |
To | func withUnsafePointers<A0, A1, Result>(inout _ arg0: A0, inout _ arg1: A1, @noescape _ body: (UnsafePointer<A0>, UnsafePointer<A1>) throws -> Result) rethrows -> Result |
Modified withUnsafePointers<A0, A1, A2, Result>(_: A0, _: A1, _: A2, _: (UnsafePointer<A0>, UnsafePointer<A1>, UnsafePointer<A2>) throws -> Result) rethrows -> Result
Declaration | |
---|---|
From | @rethrows func withUnsafePointers<A0, A1, A2, Result>(inout _ arg0: A0, inout _ arg1: A1, inout _ arg2: A2, @noescape _ body: (UnsafePointer<A0>, UnsafePointer<A1>, UnsafePointer<A2>) throws -> Result) rethrows -> Result |
To | func withUnsafePointers<A0, A1, A2, Result>(inout _ arg0: A0, inout _ arg1: A1, inout _ arg2: A2, @noescape _ body: (UnsafePointer<A0>, UnsafePointer<A1>, UnsafePointer<A2>) throws -> Result) rethrows -> Result |
Modified ||(_: T, _: () throws -> U) rethrows -> Bool
Declaration | |
---|---|
From | @warn_unused_result @rethrows func ||<T : BooleanType, U : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> U) rethrows -> Bool |
To | @warn_unused_result func ||<T : BooleanType, U : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> U) rethrows -> Bool |
Modified ||(_: T, _: () throws -> Bool) rethrows -> Bool
Declaration | |
---|---|
From | @warn_unused_result @rethrows func ||<T : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> Bool) rethrows -> Bool |
To | @warn_unused_result func ||<T : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> Bool) rethrows -> Bool |