Documentation Archive Developer
Search

Swift Changes for Swift

Swift

Removed AnyGenerator
Removed AnyGenerator.init()
Removed AnyGenerator.next() -> Element?
Removed AnySequence.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed BidirectionalIndexType.predecessor() -> Self
Removed BidirectionalIndexType.predecessor() -> Self
Removed CollectionType.count
Removed CollectionType.count
Removed CollectionType.dropLast(_: Int) -> Self.SubSequence
Removed CollectionType.dropLast(_: Int) -> Self.SubSequence
Removed CollectionType.first
Removed CollectionType.first
Removed CollectionType.isEmpty
Removed CollectionType.isEmpty
Removed CollectionType.prefixThrough(_: Self.Index) -> Self.SubSequence
Removed CollectionType.prefixThrough(_: Self.Index) -> Self.SubSequence
Removed CollectionType.prefixUpTo(_: Self.Index) -> Self.SubSequence
Removed CollectionType.prefixUpTo(_: Self.Index) -> Self.SubSequence
Removed CollectionType.startIndex
Removed CollectionType.startIndex
Removed CollectionType.suffix(_: Int) -> Self.SubSequence
Removed CollectionType.suffix(_: Int) -> Self.SubSequence
Removed CollectionType.suffixFrom(_: Self.Index) -> Self.SubSequence
Removed CollectionType.suffixFrom(_: Self.Index) -> Self.SubSequence
Removed Double.value
Removed Float.value
Removed ForwardIndexType.advancedBy(_: Self.Distance) -> Self
Removed ForwardIndexType.advancedBy(_: Self.Distance) -> Self
Removed ForwardIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed ForwardIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed ForwardIndexType.distanceTo(_: Self) -> Self.Distance
Removed ForwardIndexType.distanceTo(_: Self) -> Self.Distance
Removed Int.value
Removed Int16.value
Removed Int32.value
Removed Int64.value
Removed Int8.value
Removed LazySequenceType.elements
Removed LazySequenceType.elements
Removed RandomAccessIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed RandomAccessIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Removed RangeReplaceableCollectionType.append(_: Self.Generator.Element)
Removed RangeReplaceableCollectionType.append(_: Self.Generator.Element)
Removed RangeReplaceableCollectionType.appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Removed RangeReplaceableCollectionType.appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Removed RangeReplaceableCollectionType.insert(_: Self.Generator.Element, atIndex: Self.Index)
Removed RangeReplaceableCollectionType.insert(_: Self.Generator.Element, atIndex: Self.Index)
Removed RangeReplaceableCollectionType.removeAll(keepCapacity: Bool)
Removed RangeReplaceableCollectionType.removeAll(keepCapacity: Bool)
Removed RangeReplaceableCollectionType.removeAtIndex(_: Self.Index) -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeAtIndex(_: Self.Index) -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Removed RangeReplaceableCollectionType.removeFirst(_: Int)
Removed RangeReplaceableCollectionType.removeFirst(_: Int)
Removed RangeReplaceableCollectionType.removeRange(_: Range<Self.Index>)
Removed RangeReplaceableCollectionType.removeRange(_: Range<Self.Index>)
Removed RangeReplaceableCollectionType.reserveCapacity(_: Self.Index.Distance)
Removed RangeReplaceableCollectionType.reserveCapacity(_: Self.Index.Distance)
Removed SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Removed SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Removed SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Removed SequenceType.forEach(_: (Self.Generator.Element) throws -> ()) rethrows
Removed SequenceType.forEach(_: (Self.Generator.Element) throws -> ()) rethrows
Removed SequenceType.generate() -> Self.Generator
Removed SequenceType.generate() -> Self.Generator
Removed SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Removed SequenceType.underestimateCount() -> Int
Removed SequenceType.underestimateCount() -> Int
Removed SequenceType.underestimateCount() -> Int
Removed SetAlgebraType.element(_: Self.Element, isDisjointWith: Self.Element) -> Bool [class]
Removed SetAlgebraType.element(_: Self.Element, isDisjointWith: Self.Element) -> Bool [class]
Removed SetAlgebraType.element(_: Self.Element, subsumes: Self.Element) -> Bool [class]
Removed SetAlgebraType.element(_: Self.Element, subsumes: Self.Element) -> Bool [class]
Removed SetAlgebraType.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed SetAlgebraType.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Removed SetAlgebraType.isDisjointWith(_: Self) -> Bool
Removed SetAlgebraType.isDisjointWith(_: Self) -> Bool
Removed SetAlgebraType.isEmpty
Removed SetAlgebraType.isEmpty
Removed SetAlgebraType.isSubsetOf(_: Self) -> Bool
Removed SetAlgebraType.isSubsetOf(_: Self) -> Bool
Removed SetAlgebraType.isSupersetOf(_: Self) -> Bool
Removed SetAlgebraType.isSupersetOf(_: Self) -> Bool
Removed SetAlgebraType.subtract(_: Self) -> Self
Removed SetAlgebraType.subtract(_: Self) -> Self
Removed SetAlgebraType.subtractInPlace(_: Self)
Removed SetAlgebraType.subtractInPlace(_: Self)
Removed UInt.value
Removed UInt16.value
Removed UInt32.value
Removed UInt64.value
Removed UInt8.value
Removed UnicodeCodecType.encode(_: UnicodeScalar, output: (Self.CodeUnit) -> ()) [class]
Removed UTF16.encode(_: UnicodeScalar, output: (CodeUnit) -> ()) [static]
Removed UTF32.encode(_: UnicodeScalar, output: (CodeUnit) -> ()) [static]
Removed UTF8.encode(_: UnicodeScalar, output: (CodeUnit) -> ()) [static]
Removed !=(_: T, _: T) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed !=(_: T, _: T) -> Bool
Removed +(_: C, _: S) -> C
Removed +(_: C, _: S) -> C
Removed ++(_: Int32) -> Int32
Removed ++(_: Int16) -> Int16
Removed ++(_: Int) -> Int
Removed ++(_: UInt64) -> UInt64
Removed ++(_: UInt) -> UInt
Removed ++(_: Int8) -> Int8
Removed ++(_: Int64) -> Int64
Removed ++(_: T) -> T
Removed ++(_: Int) -> Int
Removed ++(_: Int8) -> Int8
Removed ++(_: Int16) -> Int16
Removed ++(_: Int32) -> Int32
Removed ++(_: UInt8) -> UInt8
Removed ++(_: UInt8) -> UInt8
Removed ++(_: UInt32) -> UInt32
Removed ++(_: UInt) -> UInt
Removed ++(_: Float) -> Float
Removed ++(_: UInt16) -> UInt16
Removed ++(_: Float) -> Float
Removed ++(_: UInt16) -> UInt16
Removed ++(_: Double) -> Double
Removed ++(_: UInt64) -> UInt64
Removed ++(_: Double) -> Double
Removed ++(_: UInt32) -> UInt32
Removed ++(_: T) -> T
Removed ++(_: Int64) -> Int64
Removed --(_: UInt16) -> UInt16
Removed --(_: T) -> T
Removed --(_: Double) -> Double
Removed --(_: T) -> T
Removed --(_: UInt16) -> UInt16
Removed --(_: Int) -> Int
Removed --(_: Int16) -> Int16
Removed --(_: Int64) -> Int64
Removed --(_: Int8) -> Int8
Removed --(_: UInt32) -> UInt32
Removed --(_: Double) -> Double
Removed --(_: Float) -> Float
Removed --(_: Int32) -> Int32
Removed --(_: UInt64) -> UInt64
Removed --(_: Int) -> Int
Removed --(_: UInt64) -> UInt64
Removed --(_: Int64) -> Int64
Removed --(_: UInt32) -> UInt32
Removed --(_: UInt) -> UInt
Removed --(_: UInt8) -> UInt8
Removed --(_: Float) -> Float
Removed --(_: UInt) -> UInt
Removed --(_: Int32) -> Int32
Removed --(_: UInt8) -> UInt8
Removed --(_: Int8) -> Int8
Removed --(_: Int16) -> Int16
Removed ...(_: Pos, _: Pos) -> Range<Pos>
Removed ...(_: Pos, _: Pos) -> Range<Pos>
Removed ..<(_: Pos, _: Pos) -> Range<Pos>
Removed ..<(_: Pos, _: Pos) -> Range<Pos>
Removed ==(_: T, _: T) -> Bool
Removed ==(_: FloatingPointClassification, _: FloatingPointClassification) -> Bool
Removed ==(_: T, _: T) -> Bool
Removed transcode<Input : GeneratorType, InputEncoding : UnicodeCodecType, OutputEncoding : UnicodeCodecType where InputEncoding.CodeUnit == Input.Element>(_: InputEncoding.Type, _: OutputEncoding.Type, _: Input, _: (OutputEncoding.CodeUnit) -> (), stopOnError: Bool) -> Bool
Added AnyGenerator [struct]
Added AnyGenerator.init<G : GeneratorType where G.Element == Element>(_: G)
Added AnyGenerator.init(body: () -> Element?)
Added AnyGenerator.next() -> Element?
Added AnySequence.init<S : SequenceType where S.Generator.Element == Element, S.SubSequence : SequenceType, S.SubSequence.Generator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_: S)
Added BidirectionalIndexType.predecessor() -> Self
Added BidirectionalIndexType.predecessor() -> Self
Added CollectionType.count
Added CollectionType.count
Added CollectionType.dropLast(_: Int) -> Self.SubSequence
Added CollectionType.dropLast(_: Int) -> Self.SubSequence
Added CollectionType.first
Added CollectionType.first
Added CollectionType.isEmpty
Added CollectionType.isEmpty
Added CollectionType.popLast() -> Self.Generator.Element?
Added CollectionType.prefixThrough(_: Self.Index) -> Self.SubSequence
Added CollectionType.prefixThrough(_: Self.Index) -> Self.SubSequence
Added CollectionType.prefixUpTo(_: Self.Index) -> Self.SubSequence
Added CollectionType.prefixUpTo(_: Self.Index) -> Self.SubSequence
Added CollectionType.removeFirst(_: Int)
Added CollectionType.removeLast() -> Self.Generator.Element
Added CollectionType.removeLast(_: Int)
Added CollectionType.startIndex
Added CollectionType.startIndex
Added CollectionType.suffix(_: Int) -> Self.SubSequence
Added CollectionType.suffix(_: Int) -> Self.SubSequence
Added CollectionType.suffixFrom(_: Self.Index) -> Self.SubSequence
Added CollectionType.suffixFrom(_: Self.Index) -> Self.SubSequence
Added ForwardIndexType.advancedBy(_: Self.Distance) -> Self
Added ForwardIndexType.advancedBy(_: Self.Distance) -> Self
Added ForwardIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Added ForwardIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Added ForwardIndexType.distanceTo(_: Self) -> Self.Distance
Added ForwardIndexType.distanceTo(_: Self) -> Self.Distance
Added ImplicitlyUnwrappedOptional.debugDescription
Added LazySequenceType.elements
Added LazySequenceType.elements
Added RandomAccessIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Added RandomAccessIndexType.advancedBy(_: Self.Distance, limit: Self) -> Self
Added RangeReplaceableCollectionType.append(_: Self.Generator.Element)
Added RangeReplaceableCollectionType.append(_: Self.Generator.Element)
Added RangeReplaceableCollectionType.appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Added RangeReplaceableCollectionType.appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Added RangeReplaceableCollectionType.init<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Added RangeReplaceableCollectionType.init<S : SequenceType where S.Generator.Element == Generator.Element>(_: S)
Added RangeReplaceableCollectionType.insert(_: Self.Generator.Element, atIndex: Self.Index)
Added RangeReplaceableCollectionType.insert(_: Self.Generator.Element, atIndex: Self.Index)
Added RangeReplaceableCollectionType.removeAll(keepCapacity: Bool)
Added RangeReplaceableCollectionType.removeAll(keepCapacity: Bool)
Added RangeReplaceableCollectionType.removeAtIndex(_: Self.Index) -> Self.Generator.Element
Added RangeReplaceableCollectionType.removeAtIndex(_: Self.Index) -> Self.Generator.Element
Added RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Added RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Added RangeReplaceableCollectionType.removeFirst() -> Self.Generator.Element
Added RangeReplaceableCollectionType.removeFirst(_: Int)
Added RangeReplaceableCollectionType.removeFirst(_: Int)
Added RangeReplaceableCollectionType.removeFirst(_: Int)
Added RangeReplaceableCollectionType.removeLast(_: Int)
Added RangeReplaceableCollectionType.removeRange(_: Range<Self.Index>)
Added RangeReplaceableCollectionType.removeRange(_: Range<Self.Index>)
Added RangeReplaceableCollectionType.reserveCapacity(_: Self.Index.Distance)
Added RangeReplaceableCollectionType.reserveCapacity(_: Self.Index.Distance)
Added SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Added SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Added SequenceType.filter(_: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
Added SequenceType.forEach(_: (Self.Generator.Element) throws -> Void) rethrows
Added SequenceType.forEach(_: (Self.Generator.Element) throws -> Void) rethrows
Added SequenceType.generate() -> Self.Generator
Added SequenceType.generate() -> Self.Generator
Added SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Added SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Added SequenceType.map<T>(_: (Self.Generator.Element) throws -> T) rethrows -> [T]
Added SequenceType.underestimateCount() -> Int
Added SequenceType.underestimateCount() -> Int
Added SequenceType.underestimateCount() -> Int
Added SetAlgebraType.element(_: Self.Element, isDisjointWith: Self.Element) -> Bool [class]
Added SetAlgebraType.element(_: Self.Element, isDisjointWith: Self.Element) -> Bool [class]
Added SetAlgebraType.element(_: Self.Element, subsumes: Self.Element) -> Bool [class]
Added SetAlgebraType.element(_: Self.Element, subsumes: Self.Element) -> Bool [class]
Added SetAlgebraType.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Added SetAlgebraType.init<S : SequenceType where S.Generator.Element == Element>(_: S)
Added SetAlgebraType.isDisjointWith(_: Self) -> Bool
Added SetAlgebraType.isDisjointWith(_: Self) -> Bool
Added SetAlgebraType.isEmpty
Added SetAlgebraType.isEmpty
Added SetAlgebraType.isSubsetOf(_: Self) -> Bool
Added SetAlgebraType.isSubsetOf(_: Self) -> Bool
Added SetAlgebraType.isSupersetOf(_: Self) -> Bool
Added SetAlgebraType.isSupersetOf(_: Self) -> Bool
Added SetAlgebraType.subtract(_: Self) -> Self
Added SetAlgebraType.subtract(_: Self) -> Self
Added SetAlgebraType.subtractInPlace(_: Self)
Added SetAlgebraType.subtractInPlace(_: Self)
Added UnicodeCodecType.encode(_: UnicodeScalar, output: (Self.CodeUnit) -> Void) [class]
Added UTF16.encode(_: UnicodeScalar, output: (CodeUnit) -> Void) [static]
Added UTF32.encode(_: UnicodeScalar, output: (CodeUnit) -> Void) [static]
Added UTF8.encode(_: UnicodeScalar, output: (CodeUnit) -> Void) [static]
Added !=(_: T, _: T) -> Bool
Added !=(_: T, _: T) -> Bool
Added !=(_: T, _: T) -> Bool
Added +(_: C, _: S) -> C
Added +(_: C, _: S) -> C
Added ++(_: Int32) -> Int32
Added ++(_: Int) -> Int
Added ++(_: UInt) -> UInt
Added ++(_: UInt64) -> UInt64
Added ++(_: Float) -> Float
Added ++(_: UInt64) -> UInt64
Added ++(_: Float) -> Float
Added ++(_: Int8) -> Int8
Added ++(_: Int8) -> Int8
Added ++(_: UInt16) -> UInt16
Added ++(_: Int64) -> Int64
Added ++(_: Int16) -> Int16
Added ++(_: Int) -> Int
Added ++(_: UInt8) -> UInt8
Added ++(_: UInt32) -> UInt32
Added ++(_: Int64) -> Int64
Added ++(_: UInt32) -> UInt32
Added ++(_: Int16) -> Int16
Added ++(_: UInt8) -> UInt8
Added ++(_: UInt16) -> UInt16
Added ++(_: Double) -> Double
Added ++(_: Int32) -> Int32
Added ++(_: Double) -> Double
Added ++(_: UInt) -> UInt
Added ++(_: T) -> T
Added ++(_: T) -> T
Added --(_: Int) -> Int
Added --(_: UInt8) -> UInt8
Added --(_: T) -> T
Added --(_: Int16) -> Int16
Added --(_: Int) -> Int
Added --(_: Int8) -> Int8
Added --(_: Int64) -> Int64
Added --(_: UInt) -> UInt
Added --(_: Int8) -> Int8
Added --(_: Float) -> Float
Added --(_: Double) -> Double
Added --(_: Float) -> Float
Added --(_: Int16) -> Int16
Added --(_: T) -> T
Added --(_: UInt64) -> UInt64
Added --(_: Int32) -> Int32
Added --(_: Double) -> Double
Added --(_: UInt64) -> UInt64
Added --(_: UInt32) -> UInt32
Added --(_: UInt16) -> UInt16
Added --(_: UInt8) -> UInt8
Added --(_: UInt32) -> UInt32
Added --(_: UInt) -> UInt
Added --(_: Int32) -> Int32
Added --(_: UInt16) -> UInt16
Added --(_: Int64) -> Int64
Added ...(_: Pos, _: Pos) -> Range<Pos>
Added ...(_: Pos, _: Pos) -> Range<Pos>
Added ..<(_: Pos, _: Pos) -> Range<Pos>
Added ..<(_: Pos, _: Pos) -> Range<Pos>
Added <(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> Bool
Added ==(_: T, _: T) -> Bool
Added ==(_: T, _: T) -> Bool
Added >=(_: _SwiftNSOperatingSystemVersion, _: _SwiftNSOperatingSystemVersion) -> Bool
Added transcode<Input : GeneratorType, InputEncoding : UnicodeCodecType, OutputEncoding : UnicodeCodecType where InputEncoding.CodeUnit == Input.Element>(_: InputEncoding.Type, _: OutputEncoding.Type, _: Input, _: (OutputEncoding.CodeUnit) -> Void, stopOnError: Bool) -> Bool
Declaration
From
struct AnySequence<Element> : SequenceType {
    typealias T = Element
    init<S : SequenceType where S.Generator.Element == Element>(_ base: S)
    init<G : GeneratorType where G.Element == Element>(_ makeUnderlyingGenerator: () -> G)
    func generate() -> AnyGenerator<Element>
}
extension AnySequence {
    func underestimateCount() -> Int
}
To
struct AnySequence<Element> : SequenceType {
    typealias T = Element
    init<S : SequenceType where S.Generator.Element == Element, S.SubSequence : SequenceType, S.SubSequence.Generator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_ base: S)
    init<G : GeneratorType where G.Element == Element>(_ makeUnderlyingGenerator: () -> G)
    func generate() -> AnyGenerator<Element>
}
extension AnySequence {
    @warn_unused_result
    func dropFirst(_ n: Int) -> AnySequence<Element>
    @warn_unused_result
    func prefix(_ maxLength: Int) -> AnySequence<Element>
}
extension AnySequence {
    func underestimateCount() -> Int
}

Modified ArrayLiteralConvertible
Declaration
From
protocol ArrayLiteralConvertible {
    typealias Element
    init(arrayLiteral elements: Self.Element...)
}
To
protocol ArrayLiteralConvertible {
    associatedtype Element
    init(arrayLiteral elements: Self.Element...)
}

Modified AutoreleasingUnsafeMutablePointer.init()
Deprecation
From--
TotvOS 9.2

Modified Bit [enum]
Deprecation
From--
TotvOS 9.2

Modified Bit.advancedBy(_: Distance) -> Bit
Deprecation
From--
TotvOS 9.2

Modified Bit.distanceTo(_: Bit) -> Int
Deprecation
From--
TotvOS 9.2

Modified Bit.predecessor() -> Bit
Deprecation
From--
TotvOS 9.2

Modified Bit.successor() -> Bit
Deprecation
From--
TotvOS 9.2

Modified BooleanLiteralConvertible
Declaration
From
protocol BooleanLiteralConvertible {
    typealias BooleanLiteralType
    init(booleanLiteral value: Self.BooleanLiteralType)
}
To
protocol BooleanLiteralConvertible {
    associatedtype BooleanLiteralType
    init(booleanLiteral value: Self.BooleanLiteralType)
}

Modified CollectionType
Declaration
From
protocol CollectionType : Indexable, SequenceType {
    typealias Generator : GeneratorType = IndexingGenerator<Self>
    func generate() -> Self.Generator
    typealias SubSequence : Indexable, SequenceType = Slice<Self>
    subscript (_ position: Self.Index) -> Self.Generator.Element { get }
    subscript (_ bounds: Range<Self.Index>) -> Self.SubSequence { get }
    @warn_unused_result
    func prefixUpTo(_ end: Self.Index) -> Self.SubSequence
    @warn_unused_result
    func suffixFrom(_ start: Self.Index) -> Self.SubSequence
    @warn_unused_result
    func prefixThrough(_ position: Self.Index) -> Self.SubSequence
    var isEmpty: Bool { get }
    var count: Self.Index.Distance { get }
    var first: Self.Generator.Element? { get }
}
To
protocol CollectionType : Indexable, SequenceType {
    associatedtype Generator : GeneratorType = IndexingGenerator<Self>
    func generate() -> Self.Generator
    associatedtype SubSequence : Indexable, SequenceType = Slice<Self>
    subscript (_ position: Self.Index) -> Self.Generator.Element { get }
    subscript (_ bounds: Range<Self.Index>) -> Self.SubSequence { get }
    @warn_unused_result
    func prefixUpTo(_ end: Self.Index) -> Self.SubSequence
    @warn_unused_result
    func suffixFrom(_ start: Self.Index) -> Self.SubSequence
    @warn_unused_result
    func prefixThrough(_ position: Self.Index) -> Self.SubSequence
    var isEmpty: Bool { get }
    var count: Self.Index.Distance { get }
    var first: Self.Generator.Element? { get }
}

Modified CollectionType.popLast() -> Self.Generator.Element?
Deprecation
From--
TotvOS 9.2

Modified COpaquePointer.init()
Deprecation
From--
TotvOS 9.2

Modified DictionaryLiteralConvertible
Declaration
From
protocol DictionaryLiteralConvertible {
    typealias Key
    typealias Value
    init(dictionaryLiteral elements: (Self.Key, Self.Value)...)
}
To
protocol DictionaryLiteralConvertible {
    associatedtype Key
    associatedtype Value
    init(dictionaryLiteral elements: (Self.Key, Self.Value)...)
}

DeclarationProtocols
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 : 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
To
struct Double {
    init()
    init(_bits v: Builtin.FPIEEE64)
    init(_ value: Double)
}
extension Double {
    init(_ value: CGFloat)
}
extension Double : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Double : CustomStringConvertible {
    var description: String { get }
}
extension Double : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Double : FloatingPointType {
    static var infinity: Double { get }
    static var NaN: Double { get }
    static var quietNaN: Double { get }
    var isSignMinus: Bool { get }
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignaling: Bool { get }
}
extension Double {
    var floatingPointClass: FloatingPointClassification { get }
}
extension Double : IntegerLiteralConvertible {
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
}
extension Double {
    init(_builtinFloatLiteral value: Builtin.FPIEEE64)
}
extension Double : FloatLiteralConvertible {
    init(floatLiteral value: Double)
}
extension Double : Comparable, Equatable {
}
extension Double : Hashable {
    var hashValue: Int { get }
}
extension Double : AbsoluteValuable {
    @warn_unused_result
    static func abs(_ x: Double) -> Double
}
extension Double {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
}
extension Double {
    init(_ other: Float)
}
extension Double : Strideable {
    func distanceTo(_ other: Double) -> Double
    func advancedBy(_ amount: Double) -> Double
}
extension Double {
    init?(_ text: String)
}
extension Double : _Reflectable {
}
extension Double : _CVarArgPassedAsDouble, _CVarArgAlignedType {
}
AbsoluteValuable, Comparable, CustomDebugStringConvertible, CustomStringConvertible, Equatable, FloatLiteralConvertible, FloatingPointType, Hashable, IntegerLiteralConvertible, Strideable

Modified EnumerateGenerator.init(_: Base)
Deprecation
From--
TotvOS 9.2

Modified EnumerateSequence.init(_: Base)
Deprecation
From--
TotvOS 9.2

Modified ExtendedGraphemeClusterLiteralConvertible
Declaration
From
protocol ExtendedGraphemeClusterLiteralConvertible : UnicodeScalarLiteralConvertible {
    typealias ExtendedGraphemeClusterLiteralType
    init(extendedGraphemeClusterLiteral value: Self.ExtendedGraphemeClusterLiteralType)
}
To
protocol ExtendedGraphemeClusterLiteralConvertible : UnicodeScalarLiteralConvertible {
    associatedtype ExtendedGraphemeClusterLiteralType
    init(extendedGraphemeClusterLiteral value: Self.ExtendedGraphemeClusterLiteralType)
}

DeclarationProtocols
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 : 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
To
struct Float {
    init()
    init(_bits v: Builtin.FPIEEE32)
    init(_ value: Float)
}
extension Float {
    init(_ value: CGFloat)
}
extension Float : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Float : CustomStringConvertible {
    var description: String { get }
}
extension Float : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Float : FloatingPointType {
    static var infinity: Float { get }
    static var NaN: Float { get }
    static var quietNaN: Float { get }
    var isSignMinus: Bool { get }
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignaling: Bool { get }
}
extension Float {
    var floatingPointClass: FloatingPointClassification { get }
}
extension Float : IntegerLiteralConvertible {
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
}
extension Float {
    init(_builtinFloatLiteral value: Builtin.FPIEEE64)
}
extension Float : FloatLiteralConvertible {
    init(floatLiteral value: Float)
}
extension Float : Comparable, Equatable {
}
extension Float : Hashable {
    var hashValue: Int { get }
}
extension Float : AbsoluteValuable {
    @warn_unused_result
    static func abs(_ x: Float) -> Float
}
extension Float {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
}
extension Float {
    init(_ other: Double)
}
extension Float : Strideable {
    func distanceTo(_ other: Float) -> Float
    func advancedBy(_ amount: Float) -> Float
}
extension Float {
    init?(_ text: String)
}
extension Float : _Reflectable {
}
extension Float : _CVarArgPassedAsDouble, _CVarArgAlignedType {
}
AbsoluteValuable, Comparable, CustomDebugStringConvertible, CustomStringConvertible, Equatable, FloatLiteralConvertible, FloatingPointType, Hashable, IntegerLiteralConvertible, Strideable

DeclarationProtocols
From
enum FloatingPointClassification {
    case SignalingNaN
    case QuietNaN
    case NegativeInfinity
    case NegativeNormal
    case NegativeSubnormal
    case NegativeZero
    case PositiveZero
    case PositiveSubnormal
    case PositiveNormal
    case PositiveInfinity
}
extension FloatingPointClassification : Equatable {
}
Equatable
To
enum FloatingPointClassification {
    case SignalingNaN
    case QuietNaN
    case NegativeInfinity
    case NegativeNormal
    case NegativeSubnormal
    case NegativeZero
    case PositiveZero
    case PositiveSubnormal
    case PositiveNormal
    case PositiveInfinity
}
--

Modified FloatLiteralConvertible
Declaration
From
protocol FloatLiteralConvertible {
    typealias FloatLiteralType
    init(floatLiteral value: Self.FloatLiteralType)
}
To
protocol FloatLiteralConvertible {
    associatedtype FloatLiteralType
    init(floatLiteral value: Self.FloatLiteralType)
}

Modified ForwardIndexType
Declaration
From
protocol ForwardIndexType : _Incrementable {
    typealias Distance : _SignedIntegerType = Int
    @warn_unused_result
    func advancedBy(_ n: Self.Distance) -> Self
    @warn_unused_result
    func advancedBy(_ n: Self.Distance, limit limit: Self) -> Self
    @warn_unused_result
    func distanceTo(_ end: Self) -> Self.Distance
}
To
protocol ForwardIndexType : _Incrementable {
    associatedtype Distance : _SignedIntegerType = Int
    @warn_unused_result
    func advancedBy(_ n: Self.Distance) -> Self
    @warn_unused_result
    func advancedBy(_ n: Self.Distance, limit limit: Self) -> Self
    @warn_unused_result
    func distanceTo(_ end: Self) -> Self.Distance
}

Modified GeneratorType
Declaration
From
protocol GeneratorType {
    typealias Element
    @warn_unused_result
    mutating func next() -> Self.Element?
}
To
protocol GeneratorType {
    associatedtype Element
    @warn_unused_result
    mutating func next() -> Self.Element?
}

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

Modified ImplicitlyUnwrappedOptional.flatMap<U>(_: (Wrapped) throws -> U!) rethrows -> U!
Deprecation
From--
TotvOS 9.2

Modified ImplicitlyUnwrappedOptional.init()
Deprecation
From--
TotvOS 9.2

Modified ImplicitlyUnwrappedOptional.map<U>(_: (Wrapped) throws -> U) rethrows -> U!
Deprecation
From--
TotvOS 9.2

Modified Indexable
Declaration
From
protocol Indexable {
    typealias Index : ForwardIndexType
    var startIndex: Self.Index { get }
    var endIndex: Self.Index { get }
    subscript (_ position: Self.Index) -> Self._Element { get }
}
To
protocol Indexable {
    associatedtype Index : ForwardIndexType
    var startIndex: Self.Index { get }
    var endIndex: Self.Index { get }
    subscript (_ position: Self.Index) -> Self._Element { get }
}

Modified Int [struct]
Declaration
From
struct Int : SignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int64
    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 {
}
To
struct Int : SignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ v: Builtin.Word)
    init(_ value: Int)
    init(bigEndian value: Int)
    init(littleEndian value: Int)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int)
    var bigEndian: Int { get }
    var littleEndian: Int { get }
    var byteSwapped: Int { get }
    static var max: Int { get }
    static var min: Int { get }
}
extension Int {
    init(_ value: CGFloat)
}
extension Int : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Int : RandomAccessIndexType {
    func successor() -> Int
    func predecessor() -> Int
    func distanceTo(_ other: Int) -> Distance
    func advancedBy(_ n: Distance) -> Int
}
extension Int : Hashable {
    var hashValue: Int { get }
}
extension Int : CustomStringConvertible {
    var description: String { get }
}
extension Int {
    static func addWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int : SignedNumberType {
}
extension Int {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(bitPattern bitPattern: UInt)
}
extension Int : BitwiseOperationsType {
    static var allZeros: Int { get }
}
extension Int {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int {
    init?(_ text: String, radix radix: Int = default)
}
extension Int : _Reflectable {
}
extension Int : MirrorPathType {
}
extension Int : CVarArgType {
}

Declaration
From
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 {
}
To
struct Int16 : SignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: Int16)
    init(bigEndian value: Int16)
    init(littleEndian value: Int16)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int16)
    var bigEndian: Int16 { get }
    var littleEndian: Int16 { get }
    var byteSwapped: Int16 { get }
    static var max: Int16 { get }
    static var min: Int16 { get }
}
extension Int16 {
    init(_ value: CGFloat)
}
extension Int16 : Hashable {
    var hashValue: Int { get }
}
extension Int16 : CustomStringConvertible {
    var description: String { get }
}
extension Int16 : RandomAccessIndexType {
    func successor() -> Int16
    func predecessor() -> Int16
    func distanceTo(_ other: Int16) -> Distance
    func advancedBy(_ n: Distance) -> Int16
}
extension Int16 {
    static func addWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int16 : SignedNumberType {
}
extension Int16 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt16)
}
extension Int16 : BitwiseOperationsType {
    static var allZeros: Int16 { get }
}
extension Int16 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int16 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int16 : _Reflectable {
}
extension Int16 : CVarArgType {
}

Declaration
From
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 {
}
To
struct Int32 : SignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: Int32)
    init(bigEndian value: Int32)
    init(littleEndian value: Int32)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int32)
    var bigEndian: Int32 { get }
    var littleEndian: Int32 { get }
    var byteSwapped: Int32 { get }
    static var max: Int32 { get }
    static var min: Int32 { get }
}
extension Int32 {
    init(_ value: CGFloat)
}
extension Int32 : Hashable {
    var hashValue: Int { get }
}
extension Int32 : CustomStringConvertible {
    var description: String { get }
}
extension Int32 : RandomAccessIndexType {
    func successor() -> Int32
    func predecessor() -> Int32
    func distanceTo(_ other: Int32) -> Distance
    func advancedBy(_ n: Distance) -> Int32
}
extension Int32 {
    static func addWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int32 : SignedNumberType {
}
extension Int32 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt32)
}
extension Int32 : BitwiseOperationsType {
    static var allZeros: Int32 { get }
}
extension Int32 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int32 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int32 : _Reflectable {
}
extension Int32 : CVarArgType {
}

Declaration
From
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 {
}
To
struct Int64 : SignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: Int64)
    init(bigEndian value: Int64)
    init(littleEndian value: Int64)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
    var bigEndian: Int64 { get }
    var littleEndian: Int64 { get }
    var byteSwapped: Int64 { get }
    static var max: Int64 { get }
    static var min: Int64 { get }
}
extension Int64 {
    init(_ value: CGFloat)
}
extension Int64 : Hashable {
    var hashValue: Int { get }
}
extension Int64 : CustomStringConvertible {
    var description: String { get }
}
extension Int64 : RandomAccessIndexType {
    func successor() -> Int64
    func predecessor() -> Int64
    func distanceTo(_ other: Int64) -> Distance
    func advancedBy(_ n: Distance) -> Int64
}
extension Int64 {
    static func addWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int64 : SignedNumberType {
}
extension Int64 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: UInt)
    init(_ v: Int)
    init(bitPattern bitPattern: UInt64)
}
extension Int64 : BitwiseOperationsType {
    static var allZeros: Int64 { get }
}
extension Int64 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int64 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int64 : _Reflectable {
}
extension Int64 : CVarArgType, _CVarArgAlignedType {
}

Modified Int8 [struct]
Declaration
From
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 {
}
To
struct Int8 : SignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: Int8)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int8)
    static var max: Int8 { get }
    static var min: Int8 { get }
}
extension Int8 {
    init(_ value: CGFloat)
}
extension Int8 : Hashable {
    var hashValue: Int { get }
}
extension Int8 : CustomStringConvertible {
    var description: String { get }
}
extension Int8 : RandomAccessIndexType {
    func successor() -> Int8
    func predecessor() -> Int8
    func distanceTo(_ other: Int8) -> Distance
    func advancedBy(_ n: Distance) -> Int8
}
extension Int8 {
    static func addWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int8 : SignedNumberType {
}
extension Int8 {
    init(_ v: UInt8)
    init(_ v: UInt16)
    init(truncatingBitPattern truncatingBitPattern: UInt16)
    init(_ v: Int16)
    init(truncatingBitPattern truncatingBitPattern: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt8)
}
extension Int8 : BitwiseOperationsType {
    static var allZeros: Int8 { get }
}
extension Int8 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int8 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int8 : _Reflectable {
}
extension Int8 : CVarArgType {
}

Modified IntegerLiteralConvertible
Declaration
From
protocol IntegerLiteralConvertible {
    typealias IntegerLiteralType
    init(integerLiteral value: Self.IntegerLiteralType)
}
To
protocol IntegerLiteralConvertible {
    associatedtype IntegerLiteralType
    init(integerLiteral value: Self.IntegerLiteralType)
}

Modified IntervalType
Declaration
From
protocol IntervalType {
    typealias Bound : Comparable
    @warn_unused_result
    func contains(_ value: Self.Bound) -> Bool
    @warn_unused_result
    func clamp(_ intervalToClamp: Self) -> Self
    var isEmpty: Bool { get }
    var start: Self.Bound { get }
    var end: Self.Bound { get }
}
To
protocol IntervalType {
    associatedtype Bound : Comparable
    @warn_unused_result
    func contains(_ value: Self.Bound) -> Bool
    @warn_unused_result
    func clamp(_ intervalToClamp: Self) -> Self
    var isEmpty: Bool { get }
    var start: Self.Bound { get }
    var end: Self.Bound { get }
}

Modified LazyCollectionType
Declaration
From
protocol LazyCollectionType : CollectionType, LazySequenceType {
    typealias Elements : CollectionType = Self
}
To
protocol LazyCollectionType : CollectionType, LazySequenceType {
    associatedtype Elements : CollectionType = Self
}

Modified LazyFilterCollection.init(_: Base, whereElementsSatisfy: (Base.Generator.Element) -> Bool)
Deprecation
From--
TotvOS 9.2

Modified LazyFilterGenerator.init(_: Base, whereElementsSatisfy: (Base.Element) -> Bool)
Deprecation
From--
TotvOS 9.2

Modified LazyMapCollection.init(_: Base, transform: (Base.Generator.Element) -> Element)
Deprecation
From--
TotvOS 9.2

Modified LazyMapSequence.init(_: Base, transform: (Base.Generator.Element) -> Element)
Deprecation
From--
TotvOS 9.2

Modified LazySequenceType
Declaration
From
protocol LazySequenceType : SequenceType {
    typealias Elements : SequenceType = Self
    var elements: Self.Elements { get }
    var array: [Self.Generator.Element] { get }
}
To
protocol LazySequenceType : SequenceType {
    associatedtype Elements : SequenceType = Self
    var elements: Self.Elements { get }
    var array: [Self.Generator.Element] { get }
}

Modified LazySequenceType.array
Deprecation
From--
TotvOS 9.2

Modified MutableCollectionType
Declaration
From
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 }
}
To
protocol MutableCollectionType : MutableIndexable, CollectionType {
    associatedtype SubSequence : CollectionType = MutableSlice<Self>
    subscript (_ position: Self.Index) -> Self.Generator.Element { get set }
    subscript (_ bounds: Range<Self.Index>) -> Self.SubSequence { get set }
}

Modified MutableIndexable
Declaration
From
protocol MutableIndexable {
    typealias Index : ForwardIndexType
    var startIndex: Self.Index { get }
    var endIndex: Self.Index { get }
    subscript (_ position: Self.Index) -> Self._Element { get set }
}
To
protocol MutableIndexable {
    associatedtype Index : ForwardIndexType
    var startIndex: Self.Index { get }
    var endIndex: Self.Index { get }
    subscript (_ position: Self.Index) -> Self._Element { get set }
}

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

Modified MutableSliceable
Deprecation
From--
TotvOS 9.2

Modified MutableSliceable.subscript(_: Range<Self.Index>) -> Self.SubSequence
Deprecation
From--
TotvOS 9.2

Modified OptionSetType
Declaration
From
protocol OptionSetType : SetAlgebraType, RawRepresentable {
    typealias Element = Self
    init(rawValue rawValue: Self.RawValue)
}
To
protocol OptionSetType : SetAlgebraType, RawRepresentable {
    associatedtype Element = Self
    init(rawValue rawValue: Self.RawValue)
}

Modified PermutationGenerator [struct]
Deprecation
From--
TotvOS 9.2

Modified PermutationGenerator.init(elements: C, indices: Indices)
Deprecation
From--
TotvOS 9.2

Modified PermutationGenerator.next() -> C.Generator.Element?
Deprecation
From--
TotvOS 9.2

Declaration
From
enum PlaygroundQuickLook {
    case Text(String)
    case Int(Int64)
    case UInt(UInt64)
    case Float(Float32)
    case Double(Float64)
    case Image(Any)
    case Sound(Any)
    case Color(Any)
    case BezierPath(Any)
    case AttributedString(Any)
    case Rectangle(Float64, Float64, Float64, Float64)
    case Point(Float64, Float64)
    case Size(Float64, Float64)
    case Logical(Bool)
    case Range(UInt64, UInt64)
    case View(Any)
    case Sprite(Any)
    case URL(String)
}
extension PlaygroundQuickLook {
    init(reflecting subject: Any)
}
To
enum PlaygroundQuickLook {
    case Text(String)
    case Int(Int64)
    case UInt(UInt64)
    case Float(Float32)
    case Double(Float64)
    case Image(Any)
    case Sound(Any)
    case Color(Any)
    case BezierPath(Any)
    case AttributedString(Any)
    case Rectangle(Float64, Float64, Float64, Float64)
    case Point(Float64, Float64)
    case Size(Float64, Float64)
    case Logical(Bool)
    case Range(Int64, Int64)
    case View(Any)
    case Sprite(Any)
    case URL(String)
}
extension PlaygroundQuickLook {
    init(reflecting subject: Any)
}

Modified PlaygroundQuickLook.Range
Declaration
From
case Range(UInt64, UInt64)
To
case Range(Int64, Int64)

Modified Range.init(start: Element, end: Element)
Deprecation
From--
TotvOS 9.2

Modified RangeGenerator.endIndex
Deprecation
From--
TotvOS 9.2

Modified RangeGenerator.init(_: Range<Element>)
Deprecation
From--
TotvOS 9.2

Modified RangeGenerator.startIndex
Deprecation
From--
TotvOS 9.2

Modified RangeReplaceableCollectionType
Declaration
From
protocol RangeReplaceableCollectionType : CollectionType {
    init()
    mutating func replaceRange<C : CollectionType where C.Generator.Element == Generator.Element>(_ subRange: Range<Self.Index>, with newElements: C)
    mutating func reserveCapacity(_ n: Self.Index.Distance)
    mutating func append(_ x: Self.Generator.Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_ newElements: S)
    mutating func insert(_ newElement: Self.Generator.Element, atIndex i: Self.Index)
    mutating func insertContentsOf<S : CollectionType where S.Generator.Element == Generator.Element>(_ newElements: S, at i: Self.Index)
    mutating func removeAtIndex(_ i: Self.Index) -> Self.Generator.Element
    mutating func removeFirst() -> Self.Generator.Element
    mutating func removeFirst(_ n: Int)
    mutating func removeRange(_ subRange: Range<Self.Index>)
    mutating func removeAll(keepCapacity keepCapacity: Bool)
}
To
protocol RangeReplaceableCollectionType : CollectionType {
    init()
    mutating func replaceRange<C : CollectionType where C.Generator.Element == Generator.Element>(_ subRange: Range<Self.Index>, with newElements: C)
    mutating func reserveCapacity(_ n: Self.Index.Distance)
    init<S : SequenceType where S.Generator.Element == Generator.Element>(_ elements: S)
    mutating func append(_ x: Self.Generator.Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_ newElements: S)
    mutating func insert(_ newElement: Self.Generator.Element, atIndex i: Self.Index)
    mutating func insertContentsOf<S : CollectionType where S.Generator.Element == Generator.Element>(_ newElements: S, at i: Self.Index)
    mutating func removeAtIndex(_ i: Self.Index) -> Self.Generator.Element
    mutating func removeFirst() -> Self.Generator.Element
    mutating func removeFirst(_ n: Int)
    mutating func removeRange(_ subRange: Range<Self.Index>)
    mutating func removeAll(keepCapacity keepCapacity: Bool)
}

Modified RawByte [struct]
Deprecation
From--
TotvOS 9.2

Declaration
From
protocol RawRepresentable {
    typealias RawValue
    init?(rawValue rawValue: Self.RawValue)
    var rawValue: Self.RawValue { get }
}
To
protocol RawRepresentable {
    associatedtype RawValue
    init?(rawValue rawValue: Self.RawValue)
    var rawValue: Self.RawValue { get }
}

Modified ReverseCollection.init(_: Base)
Deprecation
From--
TotvOS 9.2

Modified ReverseIndexType
Declaration
From
protocol ReverseIndexType : BidirectionalIndexType {
    typealias Base : BidirectionalIndexType
    typealias Distance : _SignedIntegerType = Self.Base.Distance
    var base: Self.Base { get }
    init(_ base: Self.Base)
}
To
protocol ReverseIndexType : BidirectionalIndexType {
    associatedtype Base : BidirectionalIndexType
    associatedtype Distance : _SignedIntegerType = Self.Base.Distance
    var base: Self.Base { get }
    init(_ base: Self.Base)
}

Modified ReverseRandomAccessCollection.init(_: Base)
Deprecation
From--
TotvOS 9.2

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
    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]
}
To
protocol SequenceType {
    associatedtype Generator : GeneratorType
    associatedtype 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 -> Void) 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.dropFirst(_: Int) -> AnySequence<Self.Generator.Element>
Generics[Extension Constraints]
From--
To<Syntax xml:space="preserve"><Symbol>SubSequence</Symbol> : <Symbol>SequenceType</Symbol></Syntax>, <Syntax xml:space="preserve"><Symbol>SubSequence</Symbol>.<Symbol>Generator</Symbol>.<Symbol>Element</Symbol> == <Symbol>Generator</Symbol>.<Symbol>Element</Symbol></Syntax>, <Syntax xml:space="preserve"><Symbol>SubSequence</Symbol>.<Symbol>SubSequence</Symbol> == <Symbol>SubSequence</Symbol></Syntax>

Modified SequenceType.dropLast(_: Int) -> AnySequence<Self.Generator.Element>
Generics[Extension Constraints]
From--
To<Syntax xml:space="preserve"><Symbol>SubSequence</Symbol> : <Symbol>SequenceType</Symbol></Syntax>, <Syntax xml:space="preserve"><Symbol>SubSequence</Symbol>.<Symbol>Generator</Symbol>.<Symbol>Element</Symbol> == <Symbol>Generator</Symbol>.<Symbol>Element</Symbol></Syntax>, <Syntax xml:space="preserve"><Symbol>SubSequence</Symbol>.<Symbol>SubSequence</Symbol> == <Symbol>SubSequence</Symbol></Syntax>

Modified SequenceType.prefix(_: Int) -> AnySequence<Self.Generator.Element>
Generics[Extension Constraints]
From--
To<Syntax xml:space="preserve"><Symbol>SubSequence</Symbol> : <Symbol>SequenceType</Symbol></Syntax>, <Syntax xml:space="preserve"><Symbol>SubSequence</Symbol>.<Symbol>Generator</Symbol>.<Symbol>Element</Symbol> == <Symbol>Generator</Symbol>.<Symbol>Element</Symbol></Syntax>, <Syntax xml:space="preserve"><Symbol>SubSequence</Symbol>.<Symbol>SubSequence</Symbol> == <Symbol>SubSequence</Symbol></Syntax>

Modified SetAlgebraType
Declaration
From
protocol SetAlgebraType : Equatable, ArrayLiteralConvertible {
    typealias Element
    init()
    @warn_unused_result
    func contains(_ member: Self.Element) -> Bool
    @warn_unused_result
    func union(_ other: Self) -> Self
    @warn_unused_result
    func intersect(_ other: Self) -> Self
    @warn_unused_result
    func exclusiveOr(_ other: Self) -> Self
    mutating func insert(_ member: Self.Element)
    mutating func remove(_ member: Self.Element) -> Self.Element?
    mutating func unionInPlace(_ other: Self)
    mutating func intersectInPlace(_ other: Self)
    mutating func exclusiveOrInPlace(_ other: Self)
    @warn_unused_result
    func subtract(_ other: Self) -> Self
    @warn_unused_result
    func isSubsetOf(_ other: Self) -> Bool
    @warn_unused_result
    func isDisjointWith(_ other: Self) -> Bool
    @warn_unused_result
    func isSupersetOf(_ other: Self) -> Bool
    var isEmpty: Bool { get }
    init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    mutating func subtractInPlace(_ other: Self)
    @warn_unused_result
    static func element(_ a: Self.Element, subsumes b: Self.Element) -> Bool
    @warn_unused_result
    static func element(_ a: Self.Element, isDisjointWith b: Self.Element) -> Bool
}
To
protocol SetAlgebraType : Equatable, ArrayLiteralConvertible {
    associatedtype Element
    init()
    @warn_unused_result
    func contains(_ member: Self.Element) -> Bool
    @warn_unused_result
    func union(_ other: Self) -> Self
    @warn_unused_result
    func intersect(_ other: Self) -> Self
    @warn_unused_result
    func exclusiveOr(_ other: Self) -> Self
    mutating func insert(_ member: Self.Element)
    mutating func remove(_ member: Self.Element) -> Self.Element?
    mutating func unionInPlace(_ other: Self)
    mutating func intersectInPlace(_ other: Self)
    mutating func exclusiveOrInPlace(_ other: Self)
    @warn_unused_result
    func subtract(_ other: Self) -> Self
    @warn_unused_result
    func isSubsetOf(_ other: Self) -> Bool
    @warn_unused_result
    func isDisjointWith(_ other: Self) -> Bool
    @warn_unused_result
    func isSupersetOf(_ other: Self) -> Bool
    var isEmpty: Bool { get }
    init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    mutating func subtractInPlace(_ other: Self)
    @warn_unused_result
    static func element(_ a: Self.Element, subsumes b: Self.Element) -> Bool
    @warn_unused_result
    static func element(_ a: Self.Element, isDisjointWith b: Self.Element) -> Bool
}

Deprecation
From--
TotvOS 9.2

Modified Strideable
Declaration
From
protocol Strideable : Comparable, _Strideable {
    typealias Stride : SignedNumberType
    @warn_unused_result
    func distanceTo(_ other: Self) -> Self.Stride
    @warn_unused_result
    func advancedBy(_ n: Self.Stride) -> Self
}
To
protocol Strideable : Comparable {
    associatedtype Stride : SignedNumberType
    @warn_unused_result
    func distanceTo(_ other: Self) -> Self.Stride
    @warn_unused_result
    func advancedBy(_ n: Self.Stride) -> Self
}

Modified StringLiteralConvertible
Declaration
From
protocol StringLiteralConvertible : ExtendedGraphemeClusterLiteralConvertible {
    typealias StringLiteralType
    init(stringLiteral value: Self.StringLiteralType)
}
To
protocol StringLiteralConvertible : ExtendedGraphemeClusterLiteralConvertible {
    associatedtype StringLiteralType
    init(stringLiteral value: Self.StringLiteralType)
}

Modified UInt [struct]
Declaration
From
struct UInt : UnsignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int64
    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 {
}
To
struct UInt : UnsignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ v: Builtin.Word)
    init(_ value: UInt)
    init(bigEndian value: UInt)
    init(littleEndian value: UInt)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt)
    var bigEndian: UInt { get }
    var littleEndian: UInt { get }
    var byteSwapped: UInt { get }
    static var max: UInt { get }
    static var min: UInt { get }
}
extension UInt {
    init(_ value: CGFloat)
}
extension UInt : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension UInt : Hashable {
    var hashValue: Int { get }
}
extension UInt : CustomStringConvertible {
    var description: String { get }
}
extension UInt : RandomAccessIndexType {
    func successor() -> UInt
    func predecessor() -> UInt
    func distanceTo(_ other: UInt) -> Distance
    func advancedBy(_ n: Distance) -> UInt
}
extension UInt {
    static func addWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: Int)
    init(bitPattern bitPattern: Int)
}
extension UInt : BitwiseOperationsType {
    static var allZeros: UInt { get }
}
extension UInt {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt : _Reflectable {
}
extension UInt : CVarArgType {
}

Declaration
From
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 {
}
To
struct UInt16 : UnsignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: UInt16)
    init(bigEndian value: UInt16)
    init(littleEndian value: UInt16)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt16)
    var bigEndian: UInt16 { get }
    var littleEndian: UInt16 { get }
    var byteSwapped: UInt16 { get }
    static var max: UInt16 { get }
    static var min: UInt16 { get }
}
extension UInt16 {
    init(_ value: CGFloat)
}
extension UInt16 : Hashable {
    var hashValue: Int { get }
}
extension UInt16 : CustomStringConvertible {
    var description: String { get }
}
extension UInt16 : RandomAccessIndexType {
    func successor() -> UInt16
    func predecessor() -> UInt16
    func distanceTo(_ other: UInt16) -> Distance
    func advancedBy(_ n: Distance) -> UInt16
}
extension UInt16 {
    static func addWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt16 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int16)
}
extension UInt16 : BitwiseOperationsType {
    static var allZeros: UInt16 { get }
}
extension UInt16 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt16 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt16 : _Reflectable {
}
extension UInt16 : CVarArgType {
}

Declaration
From
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 {
}
To
struct UInt32 : UnsignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: UInt32)
    init(bigEndian value: UInt32)
    init(littleEndian value: UInt32)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt32)
    var bigEndian: UInt32 { get }
    var littleEndian: UInt32 { get }
    var byteSwapped: UInt32 { get }
    static var max: UInt32 { get }
    static var min: UInt32 { get }
}
extension UInt32 {
    init(_ value: CGFloat)
}
extension UInt32 : Hashable {
    var hashValue: Int { get }
}
extension UInt32 : CustomStringConvertible {
    var description: String { get }
}
extension UInt32 : RandomAccessIndexType {
    func successor() -> UInt32
    func predecessor() -> UInt32
    func distanceTo(_ other: UInt32) -> Distance
    func advancedBy(_ n: Distance) -> UInt32
}
extension UInt32 {
    static func addWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt32 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int32)
}
extension UInt32 : BitwiseOperationsType {
    static var allZeros: UInt32 { get }
}
extension UInt32 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt32 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt32 : _Reflectable {
}
extension UInt32 {
    init(_ v: UnicodeScalar)
}
extension UInt32 : CVarArgType {
}

Declaration
From
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 {
}
To
struct UInt64 : UnsignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: UInt64)
    init(bigEndian value: UInt64)
    init(littleEndian value: UInt64)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt64)
    var bigEndian: UInt64 { get }
    var littleEndian: UInt64 { get }
    var byteSwapped: UInt64 { get }
    static var max: UInt64 { get }
    static var min: UInt64 { get }
}
extension UInt64 {
    init(_ value: CGFloat)
}
extension UInt64 : Hashable {
    var hashValue: Int { get }
}
extension UInt64 : CustomStringConvertible {
    var description: String { get }
}
extension UInt64 : RandomAccessIndexType {
    func successor() -> UInt64
    func predecessor() -> UInt64
    func distanceTo(_ other: UInt64) -> Distance
    func advancedBy(_ n: Distance) -> UInt64
}
extension UInt64 {
    static func addWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt64 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
    init(bitPattern bitPattern: Int64)
}
extension UInt64 : BitwiseOperationsType {
    static var allZeros: UInt64 { get }
}
extension UInt64 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt64 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt64 : _Reflectable {
}
extension UInt64 {
    init(_ v: UnicodeScalar)
}
extension UInt64 : CVarArgType, _CVarArgAlignedType {
}

Declaration
From
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 {
}
To
struct UInt8 : UnsignedIntegerType, Comparable, Equatable {
    typealias Distance = Int
    init()
    init(_ value: UInt8)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt8)
    static var max: UInt8 { get }
    static var min: UInt8 { get }
}
extension UInt8 {
    init(_ value: CGFloat)
}
extension UInt8 : Hashable {
    var hashValue: Int { get }
}
extension UInt8 : CustomStringConvertible {
    var description: String { get }
}
extension UInt8 : RandomAccessIndexType {
    func successor() -> UInt8
    func predecessor() -> UInt8
    func distanceTo(_ other: UInt8) -> Distance
    func advancedBy(_ n: Distance) -> UInt8
}
extension UInt8 {
    static func addWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt8 {
    init(_ v: Int8)
    init(_ v: UInt16)
    init(truncatingBitPattern truncatingBitPattern: UInt16)
    init(_ v: Int16)
    init(truncatingBitPattern truncatingBitPattern: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int8)
}
extension UInt8 : BitwiseOperationsType {
    static var allZeros: UInt8 { get }
}
extension UInt8 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt8 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt8 : _Reflectable {
}
extension UInt8 {
    init(ascii v: UnicodeScalar)
}
extension UInt8 : CVarArgType {
}

Modified UnicodeCodecType
Declaration
From
protocol UnicodeCodecType {
    typealias CodeUnit
    init()
    mutating func decode<G : GeneratorType where G.Element == CodeUnit>(inout _ next: G) -> UnicodeDecodingResult
    static func encode(_ input: UnicodeScalar, output output: (Self.CodeUnit) -> ())
}
To
protocol UnicodeCodecType {
    associatedtype CodeUnit
    init()
    mutating func decode<G : GeneratorType where G.Element == CodeUnit>(inout _ next: G) -> UnicodeDecodingResult
    static func encode(_ input: UnicodeScalar, output output: (Self.CodeUnit) -> Void)
}

Modified UnicodeScalarLiteralConvertible
Declaration
From
protocol UnicodeScalarLiteralConvertible {
    typealias UnicodeScalarLiteralType
    init(unicodeScalarLiteral value: Self.UnicodeScalarLiteralType)
}
To
protocol UnicodeScalarLiteralConvertible {
    associatedtype UnicodeScalarLiteralType
    init(unicodeScalarLiteral value: Self.UnicodeScalarLiteralType)
}

Deprecation
From--
TotvOS 9.2

Deprecation
From--
TotvOS 9.2

Modified UnsafeMutablePointer.init()
Deprecation
From--
TotvOS 9.2

Modified UnsafePointer.init()
Deprecation
From--
TotvOS 9.2

Modified UTF16 [struct]
Declaration
From
struct UTF16 : UnicodeCodecType {
    typealias CodeUnit = UInt16
    init()
    mutating func decode<G : GeneratorType where G.Element == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult
    static func encode(_ input: UnicodeScalar, output put: (CodeUnit) -> ())
}
extension UTF16 {
    @warn_unused_result
    static func width(_ x: UnicodeScalar) -> Int
    @warn_unused_result
    static func leadSurrogate(_ x: UnicodeScalar) -> CodeUnit
    @warn_unused_result
    static func trailSurrogate(_ x: UnicodeScalar) -> CodeUnit
    @warn_unused_result
    static func isLeadSurrogate(_ x: CodeUnit) -> Bool
    @warn_unused_result
    static func isTrailSurrogate(_ x: CodeUnit) -> Bool
    @warn_unused_result
    static func measure<Encoding : UnicodeCodecType, Input : GeneratorType where Encoding.CodeUnit == Input.Element>(_ _: Encoding.Type, input input: Input, repairIllFormedSequences repairIllFormedSequences: Bool) -> (Int, Bool)?
}
To
struct UTF16 : UnicodeCodecType {
    typealias CodeUnit = UInt16
    init()
    mutating func decode<G : GeneratorType where G.Element == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult
    static func encode(_ input: UnicodeScalar, output put: (CodeUnit) -> Void)
}
extension UTF16 {
    @warn_unused_result
    static func width(_ x: UnicodeScalar) -> Int
    @warn_unused_result
    static func leadSurrogate(_ x: UnicodeScalar) -> CodeUnit
    @warn_unused_result
    static func trailSurrogate(_ x: UnicodeScalar) -> CodeUnit
    @warn_unused_result
    static func isLeadSurrogate(_ x: CodeUnit) -> Bool
    @warn_unused_result
    static func isTrailSurrogate(_ x: CodeUnit) -> Bool
    @warn_unused_result
    static func measure<Encoding : UnicodeCodecType, Input : GeneratorType where Encoding.CodeUnit == Input.Element>(_ _: Encoding.Type, input input: Input, repairIllFormedSequences repairIllFormedSequences: Bool) -> (Int, Bool)?
}

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

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

Modified VaListBuilder
Deprecation
From--
TotvOS 9.2

Modified <(_: T, _: T) -> Bool
DeclarationGenerics[Constraints]
From
func <<T : _Strideable>(_ x: T, _ y: T) -> Bool
T : _Strideable
To
func <<T : Strideable>(_ x: T, _ y: T) -> Bool
T : Strideable

Modified anyGenerator<G : GeneratorType>(_: G) -> AnyGenerator<G.Element>
Deprecation
From--
TotvOS 9.2

Modified anyGenerator<Element>(_: () -> Element?) -> AnyGenerator<Element>
DeclarationDeprecation
From
@warn_unused_result
func anyGenerator<Element>(_ body: () -> Element?) -> AnyGenerator<Element>
--
To
func anyGenerator<Element>(_ body: () -> Element?) -> AnyGenerator<Element>
tvOS 9.2

Modified ArrayLiteralConvertible.Element
Declaration
From
typealias Element
To
associatedtype Element

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

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

Modified BooleanLiteralConvertible.BooleanLiteralType
Declaration
From
typealias BooleanLiteralType
To
associatedtype BooleanLiteralType

Modified CollectionType.Generator
Declaration
From
typealias Generator : GeneratorType = IndexingGenerator<Self>
To
associatedtype Generator : GeneratorType = IndexingGenerator<Self>

Modified CollectionType.SubSequence
Declaration
From
typealias SubSequence : Indexable, SequenceType = Slice<Self>
To
associatedtype SubSequence : Indexable, SequenceType = Slice<Self>

Modified DictionaryLiteralConvertible.Key
Declaration
From
typealias Key
To
associatedtype Key

Modified DictionaryLiteralConvertible.Value
Declaration
From
typealias Value
To
associatedtype Value

Modified ExtendedGraphemeClusterLiteralConvertible.ExtendedGraphemeClusterLiteralType
Declaration
From
typealias ExtendedGraphemeClusterLiteralType
To
associatedtype ExtendedGraphemeClusterLiteralType

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

Modified FloatLiteralConvertible.FloatLiteralType
Declaration
From
typealias FloatLiteralType
To
associatedtype FloatLiteralType

Modified ForwardIndexType.Distance
Declaration
From
typealias Distance : _SignedIntegerType = Int
To
associatedtype Distance : _SignedIntegerType = Int

Modified GeneratorType.Element
Declaration
From
typealias Element
To
associatedtype Element

Modified Indexable.Index
Declaration
From
typealias Index : ForwardIndexType
To
associatedtype Index : ForwardIndexType

Modified IntegerLiteralConvertible.IntegerLiteralType
Declaration
From
typealias IntegerLiteralType
To
associatedtype IntegerLiteralType

Modified IntervalType.Bound
Declaration
From
typealias Bound : Comparable
To
associatedtype Bound : Comparable

Modified LazyCollectionType.Elements
Declaration
From
typealias Elements : CollectionType = Self
To
associatedtype Elements : CollectionType = Self

Modified LazySequenceType.Elements
Declaration
From
typealias Elements : SequenceType = Self
To
associatedtype Elements : SequenceType = Self

Modified MutableCollectionType.SubSequence
Declaration
From
typealias SubSequence = MutableSlice<Self>
To
associatedtype SubSequence : CollectionType = MutableSlice<Self>

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

Modified OptionSetType.Element
Declaration
From
typealias Element = Self
To
associatedtype Element = Self

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

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

Declaration
From
typealias RawValue
To
associatedtype RawValue

Modified ReverseIndexType.Base
Declaration
From
typealias Base : BidirectionalIndexType
To
associatedtype Base : BidirectionalIndexType

Modified ReverseIndexType.Distance
Declaration
From
typealias Distance : _SignedIntegerType = Self.Base.Distance
To
associatedtype Distance : _SignedIntegerType = Self.Base.Distance

Modified SequenceType.Generator
Declaration
From
typealias Generator : GeneratorType
To
associatedtype Generator : GeneratorType

Modified SequenceType.SubSequence
Declaration
From
typealias SubSequence
To
associatedtype SubSequence

Modified SetAlgebraType.Element
Declaration
From
typealias Element
To
associatedtype Element

Declaration
From
typealias Stride : SignedNumberType
To
associatedtype Stride : SignedNumberType

Modified StringLiteralConvertible.StringLiteralType
Declaration
From
typealias StringLiteralType
To
associatedtype StringLiteralType

Modified UnicodeCodecType.CodeUnit
Declaration
From
typealias CodeUnit
To
associatedtype CodeUnit

Modified UnicodeScalarLiteralConvertible.UnicodeScalarLiteralType
Declaration
From
typealias UnicodeScalarLiteralType
To
associatedtype UnicodeScalarLiteralType

Modified unsafeUnwrap<T>(_: T?) -> T
Deprecation
From--
TotvOS 9.2

Modified withVaList<R>(_: VaListBuilder, _: CVaListPointer -> R) -> R
Deprecation
From--
TotvOS 9.2