Swift Changes

Swift (Added)

Added AbsoluteValuable

Added AbsoluteValuable.abs(Self) -> Self [class]

Added AnyObject

Added Array [struct]

Added Array.init()

Added Array.init(_: S)

Added Array.init(_: _ArrayBuffer<T>)

Added Array.init(_fromCocoaArray: _SwiftNSArrayRequiredOverridesType, noCopy: Bool)

Added Array.init(_uninitializedCount: Int)

Added Array.append(T)

Added Array.init(arrayLiteral: T)

Added Array.capacity

Added Array.convertFromHeapArray(Builtin.RawPointer, owner: Builtin.NativeObject, count: Builtin.Word) -> [T] [static]

Added Array.count

Added Array.init(count: Int, repeatedValue: T)

Added Array.debugDescription

Added Array.description

Added Array.endIndex

Added Array.extend(S)

Added Array.filter((T) -> Bool) -> [T]

Added Array.first

Added Array.generate() -> IndexingGenerator<[T]>

Added Array.getMirror() -> MirrorType

Added Array.insert(T, atIndex: Int)

Added Array.isEmpty

Added Array.join(S) -> [T]

Added Array.last

Added Array.map((T) -> U) -> [U]

Added Array.reduce(U, combine:(U, T) -> U) -> U

Added Array.removeAll(Bool)

Added Array.removeAtIndex(Int) -> T

Added Array.removeLast() -> T

Added Array.removeRange(Range<Int>)

Added Array.replaceRange(Range<Int>, with: C)

Added Array.reserveCapacity(Int)

Added Array.reverse() -> [T]

Added Array.sort((T, T) -> Bool)

Added Array.sorted((T, T) -> Bool) -> [T]

Added Array.splice(S, atIndex: Int)

Added Array.startIndex

Added Array.withUnsafeBufferPointer((UnsafeBufferPointer<T>) -> R) -> R

Added Array.withUnsafeMutableBufferPointer((inoutUnsafeMutableBufferPointer<T>) -> R) -> R

Added ArrayLiteralConvertible

Added ArrayLiteralConvertible.init(arrayLiteral: Element)

Added ArrayType

Added ArrayType.init()

Added ArrayType.+=(Self, _: S) [class]

Added ArrayType.init(_: _Buffer)

Added ArrayType.append(Self.Generator.Element)

Added ArrayType.capacity

Added ArrayType.count

Added ArrayType.init(count: Int, repeatedValue: Self.Generator.Element)

Added ArrayType.extend(S)

Added ArrayType.insert(Self.Generator.Element, atIndex: Int)

Added ArrayType.isEmpty

Added ArrayType.join(S) -> Self

Added ArrayType.reduce(U, combine:(U, Self.Generator.Element) -> U) -> U

Added ArrayType.removeAll(Bool)

Added ArrayType.removeAtIndex(Int) -> Self.Generator.Element

Added ArrayType.removeLast() -> Self.Generator.Element

Added ArrayType.reserveCapacity(Int)

Added ArrayType.sort((Self.Generator.Element, Self.Generator.Element) -> Bool)

Added AutoreleasingUnsafeMutablePointer [struct]

Added AutoreleasingUnsafeMutablePointer.init()

Added AutoreleasingUnsafeMutablePointer.init(_: Builtin.RawPointer)

Added AutoreleasingUnsafeMutablePointer.init(_: UnsafeMutablePointer)

Added AutoreleasingUnsafeMutablePointer.init(_: UnsafePointer)

Added AutoreleasingUnsafeMutablePointer.debugDescription

Added AutoreleasingUnsafeMutablePointer.memory

Added AutoreleasingUnsafeMutablePointer.init(nilLiteral: ())

Added AutoreleasingUnsafeMutablePointer.null() -> AutoreleasingUnsafeMutablePointer<T> [static]

Added AutoreleasingUnsafeMutablePointer.value

Added BidirectionalIndexType

Added BidirectionalReverseView [struct]

Added BidirectionalReverseView.endIndex

Added BidirectionalReverseView.generate() -> IndexingGenerator<BidirectionalReverseView<T>>

Added BidirectionalReverseView.startIndex

Added Bit [enum]

Added Bit.One

Added Bit.Zero

Added Bit.addWithOverflow(Bit, _: Bit) -> (Bit, overflow: Bool) [static]

Added Bit.advancedBy(Int) -> Bit

Added Bit.distanceTo(Bit) -> Int

Added Bit.divideWithOverflow(Bit, _: Bit) -> (Bit, overflow: Bool) [static]

Added Bit.getMirror() -> MirrorType

Added Bit.multiplyWithOverflow(Bit, _: Bit) -> (Bit, overflow: Bool) [static]

Added Bit.predecessor() -> Bit

Added Bit.remainderWithOverflow(Bit, _: Bit) -> (Bit, overflow: Bool) [static]

Added Bit.subtractWithOverflow(Bit, _: Bit) -> (Bit, overflow: Bool) [static]

Added Bit.successor() -> Bit

Added Bit.toIntMax() -> IntMax

Added BitwiseOperationsType

Added BitwiseOperationsType.&(Self, _: Self) -> Self [class]

Added BitwiseOperationsType.^(Self, _: Self) -> Self [class]

Added BitwiseOperationsType.allZeros

Added BitwiseOperationsType.|(Self, _: Self) -> Self [class]

Added BitwiseOperationsType.~(Self) -> Self [class]

Added Bool [struct]

Added Bool.init()

Added Bool.init(_: Builtin.Int1)

Added Bool.init(_: T)

Added Bool.init(_builtinBooleanLiteral: Builtin.Int1)

Added Bool.boolValue

Added Bool.init(booleanLiteral: Bool)

Added Bool.description

Added Bool.getMirror() -> MirrorType

Added Bool.hashValue

Added Bool.value

Added BooleanLiteralConvertible

Added BooleanLiteralConvertible.init(booleanLiteral: BooleanLiteralType)

Added BooleanType

Added BooleanType.boolValue

Added CFunctionPointer [struct]

Added CFunctionPointer.init()

Added CFunctionPointer.init(_: COpaquePointer)

Added CFunctionPointer.debugDescription

Added CFunctionPointer.hashValue

Added CFunctionPointer.init(nilLiteral: ())

Added CFunctionPointer.null() -> CFunctionPointer<T> [static]

Added CFunctionPointer.value

Added COpaquePointer [struct]

Added COpaquePointer.init()

Added COpaquePointer.init(_: Builtin.RawPointer)

Added COpaquePointer.init(_: CFunctionPointer<T>)

Added COpaquePointer.init(_: UnsafeMutablePointer<T>)

Added COpaquePointer.init(_: UnsafePointer<T>)

Added COpaquePointer.init(bitPattern: UWord)

Added COpaquePointer.init(bitPattern: Word)

Added COpaquePointer.debugDescription

Added COpaquePointer.encode() -> [Word]

Added COpaquePointer.hashValue

Added COpaquePointer.init(nilLiteral: ())

Added COpaquePointer.null() -> COpaquePointer [static]

Added COpaquePointer.value

Added CVaListPointer [struct]

Added CVaListPointer.debugDescription

Added CVaListPointer.init(fromUnsafeMutablePointer: UnsafeMutablePointer<Void>)

Added CVaListPointer.value

Added CVarArgType

Added CVarArgType.encode() -> [Word]

Added Character [enum]

Added Character.LargeRepresentation

Added Character.SmallRepresentation

Added Character.init(_: String)

Added Character.init(_: UnicodeScalar)

Added Character.init(_builtinExtendedGraphemeClusterLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)

Added Character.init(_builtinUnicodeScalarLiteral: Builtin.Int32)

Added Character.init(extendedGraphemeClusterLiteral: Character)

Added Character.getMirror() -> MirrorType

Added Character.hashValue

Added Character.init(unicodeScalarLiteral: Character)

Added Character.utf16

Added Character.writeTo(Target)

Added CharacterLiteralConvertible

Added CharacterLiteralConvertible.init(characterLiteral: CharacterLiteralType)

Added ClosedInterval [struct]

Added ClosedInterval.init(_: ClosedInterval<T>)

Added ClosedInterval.init(_: T, _: T)

Added ClosedInterval.clamp(ClosedInterval<T>) -> ClosedInterval<T>

Added ClosedInterval.contains(T) -> Bool

Added ClosedInterval.debugDescription

Added ClosedInterval.description

Added ClosedInterval.end

Added ClosedInterval.getMirror() -> MirrorType

Added ClosedInterval.isEmpty

Added ClosedInterval.start

Added CollectionOfOne [struct]

Added CollectionOfOne.init(_: T)

Added CollectionOfOne.element

Added CollectionOfOne.endIndex

Added CollectionOfOne.generate() -> GeneratorOfOne<T>

Added CollectionOfOne.getMirror() -> MirrorType

Added CollectionOfOne.startIndex

Added CollectionType

Added Comparable

Added Comparable.<=(Self, _: Self) -> Bool [class]

Added Comparable.>(Self, _: Self) -> Bool [class]

Added Comparable.>=(Self, _: Self) -> Bool [class]

Added ContiguousArray [struct]

Added ContiguousArray.init()

Added ContiguousArray.init(_: S)

Added ContiguousArray.init(_: _ContiguousArrayBuffer<T>)

Added ContiguousArray.init(_uninitializedCount: Int)

Added ContiguousArray.append(T)

Added ContiguousArray.init(arrayLiteral: T)

Added ContiguousArray.capacity

Added ContiguousArray.count

Added ContiguousArray.init(count: Int, repeatedValue: T)

Added ContiguousArray.debugDescription

Added ContiguousArray.description

Added ContiguousArray.endIndex

Added ContiguousArray.extend(S)

Added ContiguousArray.filter((T) -> Bool) -> ContiguousArray<T>

Added ContiguousArray.first

Added ContiguousArray.generate() -> IndexingGenerator<ContiguousArray<T>>

Added ContiguousArray.getMirror() -> MirrorType

Added ContiguousArray.insert(T, atIndex: Int)

Added ContiguousArray.isEmpty

Added ContiguousArray.join(S) -> ContiguousArray<T>

Added ContiguousArray.last

Added ContiguousArray.map((T) -> U) -> ContiguousArray

Added ContiguousArray.reduce(U, combine:(U, T) -> U) -> U

Added ContiguousArray.removeAll(Bool)

Added ContiguousArray.removeAtIndex(Int) -> T

Added ContiguousArray.removeLast() -> T

Added ContiguousArray.removeRange(Range<Int>)

Added ContiguousArray.replaceRange(Range<Int>, with: C)

Added ContiguousArray.reserveCapacity(Int)

Added ContiguousArray.reverse() -> ContiguousArray<T>

Added ContiguousArray.sort((T, T) -> Bool)

Added ContiguousArray.sorted((T, T) -> Bool) -> ContiguousArray<T>

Added ContiguousArray.splice(S, atIndex: Int)

Added ContiguousArray.startIndex

Added ContiguousArray.withUnsafeBufferPointer((UnsafeBufferPointer<T>) -> R) -> R

Added ContiguousArray.withUnsafeMutableBufferPointer((inoutUnsafeMutableBufferPointer<T>) -> R) -> R

Added DebugPrintable

Added DebugPrintable.debugDescription

Added Dictionary [struct]

Added Dictionary.init()

Added Dictionary.count

Added Dictionary.debugDescription

Added Dictionary.description

Added Dictionary.init(dictionaryLiteral: (Key, Value))

Added Dictionary.endIndex

Added Dictionary.generate() -> DictionaryGenerator<Key, Value>

Added Dictionary.getMirror() -> MirrorType

Added Dictionary.indexForKey(Key) -> DictionaryIndex<Key, Value>?

Added Dictionary.isEmpty

Added Dictionary.keys

Added Dictionary.init(minimumCapacity: Int)

Added Dictionary.removeAll(Bool)

Added Dictionary.removeAtIndex(DictionaryIndex<Key, Value>)

Added Dictionary.removeValueForKey(Key) -> Value?

Added Dictionary.startIndex

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

Added Dictionary.values

Added DictionaryGenerator [struct]

Added DictionaryGenerator.next() -> (Key, Value)?

Added DictionaryIndex [struct]

Added DictionaryIndex.predecessor() -> DictionaryIndex<Key, Value>

Added DictionaryIndex.successor() -> DictionaryIndex<Key, Value>

Added DictionaryLiteralConvertible

Added DictionaryLiteralConvertible.init(dictionaryLiteral: (Key, Value))

Added Double [struct]

Added Double.init()

Added Double.NaN

Added Double.init(_: Builtin.FPIEEE64)

Added Double.init(_: Double)

Added Double.init(_: Float)

Added Double.init(_: Float80)

Added Double.init(_: Int)

Added Double.init(_: Int16)

Added Double.init(_: Int32)

Added Double.init(_: Int64)

Added Double.init(_: Int8)

Added Double.init(_: UInt)

Added Double.init(_: UInt16)

Added Double.init(_: UInt32)

Added Double.init(_: UInt64)

Added Double.init(_: UInt8)

Added Double.init(_builtinFloatLiteral: Builtin.FPIEEE80)

Added Double.init(_builtinIntegerLiteral: Builtin.Int2048)

Added Double.abs(Double) -> Double [static]

Added Double.advancedBy(Double) -> Double

Added Double.description

Added Double.distanceTo(Double) -> Double

Added Double.encode() -> [Word]

Added Double.init(floatLiteral: Double)

Added Double.floatingPointClass

Added Double.hashValue

Added Double.infinity

Added Double.init(integerLiteral: Int64)

Added Double.isFinite

Added Double.isInfinite

Added Double.isNaN

Added Double.isNormal

Added Double.isSignMinus

Added Double.isSignaling

Added Double.isSubnormal

Added Double.isZero

Added Double.quietNaN

Added Double.value

Added EmptyCollection [struct]

Added EmptyCollection.init()

Added EmptyCollection.endIndex

Added EmptyCollection.generate() -> EmptyGenerator<T>

Added EmptyCollection.getMirror() -> MirrorType

Added EmptyCollection.startIndex

Added EmptyGenerator [struct]

Added EmptyGenerator.generate() -> EmptyGenerator<T>

Added EmptyGenerator.next() -> T?

Added EnumerateGenerator [struct]

Added EnumerateGenerator.init(_: Base)

Added EnumerateGenerator.base

Added EnumerateGenerator.count

Added EnumerateGenerator.generate() -> EnumerateGenerator<Base>

Added EnumerateGenerator.next() -> Element?

Added EnumerateSequence [struct]

Added EnumerateSequence.init(_: Base)

Added EnumerateSequence.base

Added EnumerateSequence.generate() -> EnumerateGenerator<Base.Generator>

Added Equatable

Added Equatable.==(Self, _: Self) -> Bool [class]

Added ExtendedGraphemeClusterLiteralConvertible

Added ExtendedGraphemeClusterLiteralConvertible.init(extendedGraphemeClusterLiteral: ExtendedGraphemeClusterLiteralType)

Added ExtensibleCollectionType

Added FilterCollectionView [struct]

Added FilterCollectionView.init(_: Base, includeElement:(Base.Generator.Element) -> Bool)

Added FilterCollectionView.endIndex

Added FilterCollectionView.generate() -> FilterGenerator<Base.Generator>

Added FilterCollectionView.startIndex

Added FilterCollectionViewIndex [struct]

Added FilterCollectionViewIndex.successor() -> FilterCollectionViewIndex<Base>

Added FilterGenerator [struct]

Added FilterGenerator.generate() -> FilterGenerator<Base>

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

Added FilterSequenceView [struct]

Added FilterSequenceView.generate() -> FilterGenerator<Base.Generator>

Added Float [struct]

Added Float.init()

Added Float.NaN

Added Float.init(_: Builtin.FPIEEE32)

Added Float.init(_: Double)

Added Float.init(_: Float)

Added Float.init(_: Float80)

Added Float.init(_: Int)

Added Float.init(_: Int16)

Added Float.init(_: Int32)

Added Float.init(_: Int64)

Added Float.init(_: Int8)

Added Float.init(_: UInt)

Added Float.init(_: UInt16)

Added Float.init(_: UInt32)

Added Float.init(_: UInt64)

Added Float.init(_: UInt8)

Added Float.init(_builtinFloatLiteral: Builtin.FPIEEE80)

Added Float.init(_builtinIntegerLiteral: Builtin.Int2048)

Added Float.abs(Float) -> Float [static]

Added Float.advancedBy(Float) -> Float

Added Float.description

Added Float.distanceTo(Float) -> Float

Added Float.encode() -> [Word]

Added Float.init(floatLiteral: Float)

Added Float.floatingPointClass

Added Float.hashValue

Added Float.infinity

Added Float.init(integerLiteral: Int64)

Added Float.isFinite

Added Float.isInfinite

Added Float.isNaN

Added Float.isNormal

Added Float.isSignMinus

Added Float.isSignaling

Added Float.isSubnormal

Added Float.isZero

Added Float.quietNaN

Added Float.value

Added Float32.getMirror() -> MirrorType

Added Float64.getMirror() -> MirrorType

Added Float80 [struct]

Added Float80.init()

Added Float80.init(_: Builtin.FPIEEE80)

Added Float80.init(_: Double)

Added Float80.init(_: Float)

Added Float80.init(_: Float80)

Added Float80.init(_: Int)

Added Float80.init(_: Int16)

Added Float80.init(_: Int32)

Added Float80.init(_: Int64)

Added Float80.init(_: Int8)

Added Float80.init(_: UInt)

Added Float80.init(_: UInt16)

Added Float80.init(_: UInt32)

Added Float80.init(_: UInt64)

Added Float80.init(_: UInt8)

Added Float80.init(_builtinFloatLiteral: Builtin.FPIEEE80)

Added Float80.init(_builtinIntegerLiteral: Builtin.Int2048)

Added Float80.abs(Float80) -> Float80 [static]

Added Float80.advancedBy(Float80) -> Float80

Added Float80.description

Added Float80.distanceTo(Float80) -> Float80

Added Float80.init(floatLiteral: Float80)

Added Float80.hashValue

Added Float80.init(integerLiteral: Int64)

Added Float80.value

Added FloatLiteralConvertible

Added FloatLiteralConvertible.init(floatLiteral: FloatLiteralType)

Added FloatingPointClassification [enum]

Added FloatingPointClassification.NegativeInfinity

Added FloatingPointClassification.NegativeNormal

Added FloatingPointClassification.NegativeSubnormal

Added FloatingPointClassification.NegativeZero

Added FloatingPointClassification.PositiveInfinity

Added FloatingPointClassification.PositiveNormal

Added FloatingPointClassification.PositiveSubnormal

Added FloatingPointClassification.PositiveZero

Added FloatingPointClassification.QuietNaN

Added FloatingPointClassification.SignalingNaN

Added FloatingPointType

Added FloatingPointType.NaN

Added FloatingPointType.init(_: Int)

Added FloatingPointType.init(_: Int16)

Added FloatingPointType.init(_: Int32)

Added FloatingPointType.init(_: Int64)

Added FloatingPointType.init(_: Int8)

Added FloatingPointType.init(_: UInt)

Added FloatingPointType.init(_: UInt16)

Added FloatingPointType.init(_: UInt32)

Added FloatingPointType.init(_: UInt64)

Added FloatingPointType.init(_: UInt8)

Added FloatingPointType.floatingPointClass

Added FloatingPointType.infinity

Added FloatingPointType.isFinite

Added FloatingPointType.isInfinite

Added FloatingPointType.isNaN

Added FloatingPointType.isNormal

Added FloatingPointType.isSignMinus

Added FloatingPointType.isSignaling

Added FloatingPointType.isSubnormal

Added FloatingPointType.isZero

Added FloatingPointType.quietNaN

Added ForwardIndexType

Added GeneratorOf [struct]

Added GeneratorOf.init(_: () -> T?)

Added GeneratorOf.init(_: G)

Added GeneratorOf.generate() -> GeneratorOf<T>

Added GeneratorOf.next() -> T?

Added GeneratorOfOne [struct]

Added GeneratorOfOne.init(_: T?)

Added GeneratorOfOne.elements

Added GeneratorOfOne.generate() -> GeneratorOfOne<T>

Added GeneratorOfOne.next() -> T?

Added GeneratorSequence [struct]

Added GeneratorSequence.init(_: G)

Added GeneratorSequence.generate() -> GeneratorSequence<G>

Added GeneratorSequence.next() -> G.Element?

Added GeneratorType

Added GeneratorType.next() -> Element?

Added HalfOpenInterval [struct]

Added HalfOpenInterval.init(_: HalfOpenInterval<T>)

Added HalfOpenInterval.init(_: T, _: T)

Added HalfOpenInterval.clamp(HalfOpenInterval<T>) -> HalfOpenInterval<T>

Added HalfOpenInterval.contains(T) -> Bool

Added HalfOpenInterval.debugDescription

Added HalfOpenInterval.description

Added HalfOpenInterval.end

Added HalfOpenInterval.getMirror() -> MirrorType

Added HalfOpenInterval.isEmpty

Added HalfOpenInterval.start

Added Hashable

Added Hashable.hashValue

Added HeapBuffer [struct]

Added HeapBuffer.init()

Added HeapBuffer.init(_: AnyClass, _: Value, _: Int)

Added HeapBuffer.init(_: HeapBufferStorage<Value, Element>)

Added HeapBuffer.baseAddress

Added HeapBuffer.fromNativeObject(Builtin.NativeObject) -> HeapBuffer<Value, Element> [static]

Added HeapBuffer.hasStorage

Added HeapBuffer.isUniquelyReferenced() -> Bool

Added HeapBuffer.storage

Added HeapBuffer.value

Added HeapBufferStorage

Added HeapBufferStorage.deinit

Added ImplicitlyUnwrappedOptional [enum]

Added ImplicitlyUnwrappedOptional.init()

Added ImplicitlyUnwrappedOptional.None

Added ImplicitlyUnwrappedOptional.Some

Added ImplicitlyUnwrappedOptional.init(_: T)

Added ImplicitlyUnwrappedOptional.init(_: T?)

Added ImplicitlyUnwrappedOptional.description

Added ImplicitlyUnwrappedOptional.getMirror() -> MirrorType

Added ImplicitlyUnwrappedOptional.map((T) -> U) -> U!

Added ImplicitlyUnwrappedOptional.init(nilLiteral: ())

Added IndexingGenerator [struct]

Added IndexingGenerator.init(_: C)

Added IndexingGenerator.generate() -> IndexingGenerator<C>

Added IndexingGenerator.next() -> C._Element?

Added Int [struct]

Added Int.init()

Added Int.init(_: Double)

Added Int.init(_: Float)

Added Int.init(_: Float80)

Added Int.init(_: Int)

Added Int.init(_: Int16)

Added Int.init(_: Int32)

Added Int.init(_: Int64)

Added Int.init(_: Int8)

Added Int.init(_: UInt)

Added Int.init(_: UInt16)

Added Int.init(_: UInt32)

Added Int.init(_: UInt64)

Added Int.init(_: UInt8)

Added Int.init(_builtinIntegerLiteral: Builtin.Int2048)

Added Int.addWithOverflow(Int, _: Int) -> (Int, overflow: Bool) [static]

Added Int.advancedBy(Distance) -> Int

Added Int.allZeros

Added Int.bigEndian

Added Int.init(bigEndian: Int)

Added Int.init(bitPattern: UInt)

Added Int.byteSwapped

Added Int.description

Added Int.distanceTo(Int) -> Distance

Added Int.divideWithOverflow(Int, _: Int) -> (Int, overflow: Bool) [static]

Added Int.encode() -> [Word]

Added Int.getMirror() -> MirrorType

Added Int.hashValue

Added Int.init(integerLiteral: Int)

Added Int.littleEndian

Added Int.init(littleEndian: Int)

Added Int.max

Added Int.min

Added Int.multiplyWithOverflow(Int, _: Int) -> (Int, overflow: Bool) [static]

Added Int.predecessor() -> Int

Added Int.remainderWithOverflow(Int, _: Int) -> (Int, overflow: Bool) [static]

Added Int.subtractWithOverflow(Int, _: Int) -> (Int, overflow: Bool) [static]

Added Int.successor() -> Int

Added Int.toIntMax() -> IntMax

Added Int.init(truncatingBitPattern: Int64)

Added Int.init(truncatingBitPattern: UInt64)

Added Int.value

Added Int16 [struct]

Added Int16.init()

Added Int16.init(_: Double)

Added Int16.init(_: Float)

Added Int16.init(_: Float80)

Added Int16.init(_: Int)

Added Int16.init(_: Int16)

Added Int16.init(_: Int32)

Added Int16.init(_: Int64)

Added Int16.init(_: Int8)

Added Int16.init(_: UInt)

Added Int16.init(_: UInt16)

Added Int16.init(_: UInt32)

Added Int16.init(_: UInt64)

Added Int16.init(_: UInt8)

Added Int16.init(_builtinIntegerLiteral: Builtin.Int2048)

Added Int16.addWithOverflow(Int16, _: Int16) -> (Int16, overflow: Bool) [static]

Added Int16.advancedBy(Distance) -> Int16

Added Int16.allZeros

Added Int16.bigEndian

Added Int16.init(bigEndian: Int16)

Added Int16.init(bitPattern: UInt16)

Added Int16.byteSwapped

Added Int16.description

Added Int16.distanceTo(Int16) -> Distance

Added Int16.divideWithOverflow(Int16, _: Int16) -> (Int16, overflow: Bool) [static]

Added Int16.encode() -> [Word]

Added Int16.getMirror() -> MirrorType

Added Int16.hashValue

Added Int16.init(integerLiteral: Int16)

Added Int16.littleEndian

Added Int16.init(littleEndian: Int16)

Added Int16.max

Added Int16.min

Added Int16.multiplyWithOverflow(Int16, _: Int16) -> (Int16, overflow: Bool) [static]

Added Int16.predecessor() -> Int16

Added Int16.remainderWithOverflow(Int16, _: Int16) -> (Int16, overflow: Bool) [static]

Added Int16.subtractWithOverflow(Int16, _: Int16) -> (Int16, overflow: Bool) [static]

Added Int16.successor() -> Int16

Added Int16.toIntMax() -> IntMax

Added Int16.init(truncatingBitPattern: Int)

Added Int16.init(truncatingBitPattern: Int32)

Added Int16.init(truncatingBitPattern: Int64)

Added Int16.init(truncatingBitPattern: UInt)

Added Int16.init(truncatingBitPattern: UInt32)

Added Int16.init(truncatingBitPattern: UInt64)

Added Int16.value

Added Int32 [struct]

Added Int32.init()

Added Int32.init(_: Double)

Added Int32.init(_: Float)

Added Int32.init(_: Float80)

Added Int32.init(_: Int)

Added Int32.init(_: Int16)

Added Int32.init(_: Int32)

Added Int32.init(_: Int64)

Added Int32.init(_: Int8)

Added Int32.init(_: UInt)

Added Int32.init(_: UInt16)

Added Int32.init(_: UInt32)

Added Int32.init(_: UInt64)

Added Int32.init(_: UInt8)

Added Int32.init(_builtinIntegerLiteral: Builtin.Int2048)

Added Int32.addWithOverflow(Int32, _: Int32) -> (Int32, overflow: Bool) [static]

Added Int32.advancedBy(Distance) -> Int32

Added Int32.allZeros

Added Int32.bigEndian

Added Int32.init(bigEndian: Int32)

Added Int32.init(bitPattern: UInt32)

Added Int32.byteSwapped

Added Int32.description

Added Int32.distanceTo(Int32) -> Distance

Added Int32.divideWithOverflow(Int32, _: Int32) -> (Int32, overflow: Bool) [static]

Added Int32.encode() -> [Word]

Added Int32.getMirror() -> MirrorType

Added Int32.hashValue

Added Int32.init(integerLiteral: Int32)

Added Int32.littleEndian

Added Int32.init(littleEndian: Int32)

Added Int32.max

Added Int32.min

Added Int32.multiplyWithOverflow(Int32, _: Int32) -> (Int32, overflow: Bool) [static]

Added Int32.predecessor() -> Int32

Added Int32.remainderWithOverflow(Int32, _: Int32) -> (Int32, overflow: Bool) [static]

Added Int32.subtractWithOverflow(Int32, _: Int32) -> (Int32, overflow: Bool) [static]

Added Int32.successor() -> Int32

Added Int32.toIntMax() -> IntMax

Added Int32.init(truncatingBitPattern: Int)

Added Int32.init(truncatingBitPattern: Int64)

Added Int32.init(truncatingBitPattern: UInt)

Added Int32.init(truncatingBitPattern: UInt64)

Added Int32.value

Added Int64 [struct]

Added Int64.init()

Added Int64.init(_: Double)

Added Int64.init(_: Float)

Added Int64.init(_: Float80)

Added Int64.init(_: Int)

Added Int64.init(_: Int16)

Added Int64.init(_: Int32)

Added Int64.init(_: Int64)

Added Int64.init(_: Int8)

Added Int64.init(_: UInt)

Added Int64.init(_: UInt16)

Added Int64.init(_: UInt32)

Added Int64.init(_: UInt64)

Added Int64.init(_: UInt8)

Added Int64.init(_builtinIntegerLiteral: Builtin.Int2048)

Added Int64.addWithOverflow(Int64, _: Int64) -> (Int64, overflow: Bool) [static]

Added Int64.advancedBy(Distance) -> Int64

Added Int64.allZeros

Added Int64.bigEndian

Added Int64.init(bigEndian: Int64)

Added Int64.init(bitPattern: UInt64)

Added Int64.byteSwapped

Added Int64.description

Added Int64.distanceTo(Int64) -> Distance

Added Int64.divideWithOverflow(Int64, _: Int64) -> (Int64, overflow: Bool) [static]

Added Int64.encode() -> [Word]

Added Int64.getMirror() -> MirrorType

Added Int64.hashValue

Added Int64.init(integerLiteral: Int64)

Added Int64.littleEndian

Added Int64.init(littleEndian: Int64)

Added Int64.max

Added Int64.min

Added Int64.multiplyWithOverflow(Int64, _: Int64) -> (Int64, overflow: Bool) [static]

Added Int64.predecessor() -> Int64

Added Int64.remainderWithOverflow(Int64, _: Int64) -> (Int64, overflow: Bool) [static]

Added Int64.subtractWithOverflow(Int64, _: Int64) -> (Int64, overflow: Bool) [static]

Added Int64.successor() -> Int64

Added Int64.toIntMax() -> IntMax

Added Int64.value

Added Int8 [struct]

Added Int8.init()

Added Int8.init(_: Double)

Added Int8.init(_: Float)

Added Int8.init(_: Float80)

Added Int8.init(_: Int)

Added Int8.init(_: Int16)

Added Int8.init(_: Int32)

Added Int8.init(_: Int64)

Added Int8.init(_: Int8)

Added Int8.init(_: UInt)

Added Int8.init(_: UInt16)

Added Int8.init(_: UInt32)

Added Int8.init(_: UInt64)

Added Int8.init(_: UInt8)

Added Int8.init(_builtinIntegerLiteral: Builtin.Int2048)

Added Int8.addWithOverflow(Int8, _: Int8) -> (Int8, overflow: Bool) [static]

Added Int8.advancedBy(Distance) -> Int8

Added Int8.allZeros

Added Int8.init(bitPattern: UInt8)

Added Int8.description

Added Int8.distanceTo(Int8) -> Distance

Added Int8.divideWithOverflow(Int8, _: Int8) -> (Int8, overflow: Bool) [static]

Added Int8.encode() -> [Word]

Added Int8.getMirror() -> MirrorType

Added Int8.hashValue

Added Int8.init(integerLiteral: Int8)

Added Int8.max

Added Int8.min

Added Int8.multiplyWithOverflow(Int8, _: Int8) -> (Int8, overflow: Bool) [static]

Added Int8.predecessor() -> Int8

Added Int8.remainderWithOverflow(Int8, _: Int8) -> (Int8, overflow: Bool) [static]

Added Int8.subtractWithOverflow(Int8, _: Int8) -> (Int8, overflow: Bool) [static]

Added Int8.successor() -> Int8

Added Int8.toIntMax() -> IntMax

Added Int8.init(truncatingBitPattern: Int)

Added Int8.init(truncatingBitPattern: Int16)

Added Int8.init(truncatingBitPattern: Int32)

Added Int8.init(truncatingBitPattern: Int64)

Added Int8.init(truncatingBitPattern: UInt)

Added Int8.init(truncatingBitPattern: UInt16)

Added Int8.init(truncatingBitPattern: UInt32)

Added Int8.init(truncatingBitPattern: UInt64)

Added Int8.value

Added IntEncoder [struct]

Added IntEncoder.asInt

Added IntEncoder.put(CodeUnit)

Added IntEncoder.shift

Added IntegerArithmeticType

Added IntegerArithmeticType.%(Self, _: Self) -> Self [class]

Added IntegerArithmeticType.*(Self, _: Self) -> Self [class]

Added IntegerArithmeticType.+(Self, _: Self) -> Self [class]

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

Added IntegerArithmeticType.\ [class]

Added IntegerArithmeticType.toIntMax() -> IntMax

Added IntegerLiteralConvertible

Added IntegerLiteralConvertible.init(integerLiteral: IntegerLiteralType)

Added IntegerType

Added IntervalType

Added IntervalType.clamp(Self) -> Self

Added IntervalType.contains(Bound) -> Bool

Added IntervalType.end

Added IntervalType.isEmpty

Added IntervalType.start

Added LazyBidirectionalCollection [struct]

Added LazyBidirectionalCollection.init(_: S)

Added LazyBidirectionalCollection.array

Added LazyBidirectionalCollection.endIndex

Added LazyBidirectionalCollection.filter((S.Generator.Element) -> Bool) -> LazySequence<FilterSequenceView<S>>

Added LazyBidirectionalCollection.first

Added LazyBidirectionalCollection.generate() -> S.Generator

Added LazyBidirectionalCollection.isEmpty

Added LazyBidirectionalCollection.last

Added LazyBidirectionalCollection.map((S.Generator.Element) -> U) -> LazyBidirectionalCollection<MapCollectionView<S, U>>

Added LazyBidirectionalCollection.reverse() -> LazyBidirectionalCollection<BidirectionalReverseView<S>>

Added LazyBidirectionalCollection.startIndex

Added LazyForwardCollection [struct]

Added LazyForwardCollection.init(_: S)

Added LazyForwardCollection.array

Added LazyForwardCollection.endIndex

Added LazyForwardCollection.filter((S.Generator.Element) -> Bool) -> LazySequence<FilterSequenceView<S>>

Added LazyForwardCollection.first

Added LazyForwardCollection.generate() -> S.Generator

Added LazyForwardCollection.isEmpty

Added LazyForwardCollection.map((S.Generator.Element) -> U) -> LazyForwardCollection<MapCollectionView<S, U>>

Added LazyForwardCollection.startIndex

Added LazyRandomAccessCollection [struct]

Added LazyRandomAccessCollection.init(_: S)

Added LazyRandomAccessCollection.array

Added LazyRandomAccessCollection.endIndex

Added LazyRandomAccessCollection.filter((S.Generator.Element) -> Bool) -> LazySequence<FilterSequenceView<S>>

Added LazyRandomAccessCollection.first

Added LazyRandomAccessCollection.generate() -> S.Generator

Added LazyRandomAccessCollection.isEmpty

Added LazyRandomAccessCollection.last

Added LazyRandomAccessCollection.map((S.Generator.Element) -> U) -> LazyRandomAccessCollection<MapCollectionView<S, U>>

Added LazyRandomAccessCollection.reverse() -> LazyBidirectionalCollection<RandomAccessReverseView<S>>

Added LazyRandomAccessCollection.startIndex

Added LazySequence [struct]

Added LazySequence.init(_: S)

Added LazySequence.array

Added LazySequence.filter((S.Generator.Element) -> Bool) -> LazySequence<FilterSequenceView<S>>

Added LazySequence.generate() -> S.Generator

Added LazySequence.map((S.Generator.Element) -> U) -> LazySequence<MapSequenceView<S, U>>

Added MapCollectionView [struct]

Added MapCollectionView.endIndex

Added MapCollectionView.generate() -> MapSequenceGenerator<Base.Generator, T>

Added MapCollectionView.startIndex

Added MapSequenceGenerator [struct]

Added MapSequenceGenerator.generate() -> MapSequenceGenerator<Base, T>

Added MapSequenceGenerator.next() -> T?

Added MapSequenceView [struct]

Added MapSequenceView.generate() -> MapSequenceGenerator<Base.Generator, T>

Added MirrorDisposition [enum]

Added MirrorDisposition.Aggregate

Added MirrorDisposition.Class

Added MirrorDisposition.Container

Added MirrorDisposition.Enum

Added MirrorDisposition.IndexContainer

Added MirrorDisposition.KeyContainer

Added MirrorDisposition.MembershipContainer

Added MirrorDisposition.ObjCObject

Added MirrorDisposition.Optional

Added MirrorDisposition.Struct

Added MirrorDisposition.Tuple

Added MirrorType

Added MirrorType.count

Added MirrorType.disposition

Added MirrorType.objectIdentifier

Added MirrorType.quickLookObject

Added MirrorType.summary

Added MirrorType.value

Added MirrorType.valueType

Added MutableCollectionType

Added MutableSliceable

Added NilLiteralConvertible

Added NilLiteralConvertible.init(nilLiteral: ())

Added ObjectIdentifier [struct]

Added ObjectIdentifier.init(_: AnyObject)

Added ObjectIdentifier.hashValue

Added ObjectIdentifier.uintValue() -> UInt

Added ObjectIdentifier.value

Added OnHeap [struct]

Added OnHeap.init(_: T)

Added Optional [enum]

Added Optional.init()

Added Optional.None

Added Optional.Some

Added Optional.init(_: T)

Added Optional.debugDescription

Added Optional.getMirror() -> MirrorType

Added Optional.map((T) -> U) -> U?

Added Optional.init(nilLiteral: ())

Added OutputStreamType

Added OutputStreamType.write(String)

Added PermutationGenerator [struct]

Added PermutationGenerator.init(elements: C, indices: Indices)

Added PermutationGenerator.generate() -> PermutationGenerator<C, Indices>

Added PermutationGenerator.indices

Added PermutationGenerator.next() -> Element?

Added PermutationGenerator.seq

Added Printable

Added Printable.description

Added QuickLookObject [enum]

Added QuickLookObject.AttributedString

Added QuickLookObject.BezierPath

Added QuickLookObject.Color

Added QuickLookObject.Float

Added QuickLookObject.Image

Added QuickLookObject.Int

Added QuickLookObject.Logical

Added QuickLookObject.Point

Added QuickLookObject.Range

Added QuickLookObject.Rectangle

Added QuickLookObject.Size

Added QuickLookObject.Sound

Added QuickLookObject.Sprite

Added QuickLookObject.Text

Added QuickLookObject.UInt

Added QuickLookObject.URL

Added QuickLookObject.View

Added RandomAccessIndexType

Added RandomAccessReverseView [struct]

Added RandomAccessReverseView.endIndex

Added RandomAccessReverseView.generate() -> IndexingGenerator<RandomAccessReverseView<T>>

Added RandomAccessReverseView.startIndex

Added Range [struct]

Added Range.init(_: Range<T>)

Added Range.debugDescription

Added Range.description

Added Range.endIndex

Added Range.generate() -> RangeGenerator<T>

Added Range.getMirror() -> MirrorType

Added Range.isEmpty

Added Range.map((T) -> U) -> [U]

Added Range.init(start: T, end: T)

Added Range.startIndex

Added RangeGenerator [struct]

Added RangeGenerator.init(_: Range<T>)

Added RangeGenerator.endIndex

Added RangeGenerator.generate() -> RangeGenerator<T>

Added RangeGenerator.next() -> T?

Added RangeGenerator.startIndex

Added RangeReplaceableCollectionType

Added RangeReplaceableCollectionType.insert(Self.Generator.Element, atIndex: Self.Index)

Added RangeReplaceableCollectionType.removeAll(Bool)

Added RangeReplaceableCollectionType.removeAtIndex(Self.Index) -> Self.Generator.Element

Added RangeReplaceableCollectionType.removeRange(Range<Self.Index>)

Added RangeReplaceableCollectionType.replaceRange(Range<Self.Index>, with: C)

Added RangeReplaceableCollectionType.splice(S, atIndex: Self.Index)

Added RawByte [struct]

Added RawOptionSetType

Added RawRepresentable

Added RawRepresentable.rawValue

Added RawRepresentable.init(rawValue: RawValue)

Added Reflectable

Added Reflectable.getMirror() -> MirrorType

Added Repeat [struct]

Added Repeat.count

Added Repeat.init(count: Int, repeatedValue: T)

Added Repeat.endIndex

Added Repeat.generate() -> IndexingGenerator<Repeat<T>>

Added Repeat.repeatedValue

Added Repeat.startIndex

Added ReverseBidirectionalIndex [struct]

Added ReverseBidirectionalIndex.predecessor() -> ReverseBidirectionalIndex

Added ReverseBidirectionalIndex.successor() -> ReverseBidirectionalIndex

Added ReverseRandomAccessIndex [struct]

Added ReverseRandomAccessIndex.advancedBy(I.Distance) -> ReverseRandomAccessIndex

Added ReverseRandomAccessIndex.distanceTo(ReverseRandomAccessIndex) -> I.Distance

Added ReverseRandomAccessIndex.predecessor() -> ReverseRandomAccessIndex

Added ReverseRandomAccessIndex.successor() -> ReverseRandomAccessIndex

Added SequenceOf [struct]

Added SequenceOf.init(_: () -> G)

Added SequenceOf.init(_: S)

Added SequenceOf.generate() -> GeneratorOf<T>

Added SequenceType

Added SequenceType.generate() -> Generator

Added SignedIntegerType

Added SignedNumberType

Added SignedNumberType.-(Self) -> Self [class]

Added SinkOf [struct]

Added SinkOf.init(_: (T) -> ())

Added SinkOf.init(_: S)

Added SinkOf.put(T)

Added SinkType

Added SinkType.put(Element)

Added Slice [struct]

Added Slice.init()

Added Slice.init(_: S)

Added Slice.init(_: _SliceBuffer<T>)

Added Slice.init(_uninitializedCount: Int)

Added Slice.append(T)

Added Slice.init(arrayLiteral: T)

Added Slice.capacity

Added Slice.count

Added Slice.init(count: Int, repeatedValue: T)

Added Slice.debugDescription

Added Slice.description

Added Slice.endIndex

Added Slice.extend(S)

Added Slice.filter((T) -> Bool) -> Slice<T>

Added Slice.first

Added Slice.generate() -> IndexingGenerator<Slice<T>>

Added Slice.getMirror() -> MirrorType

Added Slice.insert(T, atIndex: Int)

Added Slice.isEmpty

Added Slice.join(S) -> Slice<T>

Added Slice.last

Added Slice.map((T) -> U) -> Slice

Added Slice.reduce(U, combine:(U, T) -> U) -> U

Added Slice.removeAll(Bool)

Added Slice.removeAtIndex(Int) -> T

Added Slice.removeLast() -> T

Added Slice.removeRange(Range<Int>)

Added Slice.replaceRange(Range<Int>, with: C)

Added Slice.reserveCapacity(Int)

Added Slice.reverse() -> Slice<T>

Added Slice.sort((T, T) -> Bool)

Added Slice.sorted((T, T) -> Bool) -> Slice<T>

Added Slice.splice(S, atIndex: Int)

Added Slice.startIndex

Added Slice.withUnsafeBufferPointer((UnsafeBufferPointer<T>) -> R) -> R

Added Slice.withUnsafeMutableBufferPointer((inoutUnsafeMutableBufferPointer<T>) -> R) -> R

Added Sliceable

Added StaticString [struct]

Added StaticString.init()

Added StaticString.init(_builtinExtendedGraphemeClusterLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)

Added StaticString.init(_builtinStringLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)

Added StaticString.init(_builtinUnicodeScalarLiteral: Builtin.Int32)

Added StaticString.byteSize

Added StaticString.debugDescription

Added StaticString.description

Added StaticString.init(extendedGraphemeClusterLiteral: StaticString)

Added StaticString.hasPointerRepresentation

Added StaticString.isASCII

Added StaticString.init(start: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)

Added StaticString.init(stringLiteral: StaticString)

Added StaticString.stringValue

Added StaticString.unicodeScalar

Added StaticString.init(unicodeScalar: Builtin.Int32)

Added StaticString.init(unicodeScalarLiteral: StaticString)

Added StaticString.utf8Start

Added StaticString.withUTF8Buffer((UnsafeBufferPointer<UInt8>) -> R) -> R

Added Streamable

Added Streamable.writeTo(Target)

Added StrideThrough [struct]

Added StrideThrough.end

Added StrideThrough.generate() -> StrideThroughGenerator<T>

Added StrideThrough.getMirror() -> MirrorType

Added StrideThrough.start

Added StrideThrough.init(start: T, end: T, stride: T.Stride)

Added StrideThrough.stride

Added StrideThroughGenerator [struct]

Added StrideThroughGenerator.current

Added StrideThroughGenerator.done

Added StrideThroughGenerator.end

Added StrideThroughGenerator.next() -> T?

Added StrideThroughGenerator.stride

Added StrideTo [struct]

Added StrideTo.end

Added StrideTo.generate() -> StrideToGenerator<T>

Added StrideTo.getMirror() -> MirrorType

Added StrideTo.start

Added StrideTo.init(start: T, end: T, stride: T.Stride)

Added StrideTo.stride

Added StrideToGenerator [struct]

Added StrideToGenerator.current

Added StrideToGenerator.end

Added StrideToGenerator.next() -> T?

Added StrideToGenerator.stride

Added Strideable

Added String [struct]

Added String.init()

Added String.init(_: Character)

Added String.init(_: S)

Added String.init(_: String.UnicodeScalarView)

Added String.init(_: T)

Added String.init(_: T, radix: Int, uppercase: Bool)

Added String.init(_builtinExtendedGraphemeClusterLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)

Added String.init(_builtinStringLiteral: Builtin.RawPointer, byteSize: Builtin.Word, isASCII: Builtin.Int1)

Added String.init(_builtinUTF16StringLiteral: Builtin.RawPointer, numberOfCodeUnits: Builtin.Word)

Added String.init(_builtinUnicodeScalarLiteral: Builtin.Int32)

Added String.append(Character)

Added String.append(UnicodeScalar)

Added String.convertFromStringInterpolation(String) -> String [static]

Added String.convertFromStringInterpolationSegment(Bool) -> String [static]

Added String.convertFromStringInterpolationSegment(Character) -> String [static]

Added String.convertFromStringInterpolationSegment(Float32) -> String [static]

Added String.convertFromStringInterpolationSegment(Float64) -> String [static]

Added String.convertFromStringInterpolationSegment(Int) -> String [static]

Added String.convertFromStringInterpolationSegment(Int16) -> String [static]

Added String.convertFromStringInterpolationSegment(Int32) -> String [static]

Added String.convertFromStringInterpolationSegment(Int64) -> String [static]

Added String.convertFromStringInterpolationSegment(Int8) -> String [static]

Added String.convertFromStringInterpolationSegment(String) -> String [static]

Added String.convertFromStringInterpolationSegment(T) -> String [static]

Added String.convertFromStringInterpolationSegment(UInt) -> String [static]

Added String.convertFromStringInterpolationSegment(UInt16) -> String [static]

Added String.convertFromStringInterpolationSegment(UInt32) -> String [static]

Added String.convertFromStringInterpolationSegment(UInt64) -> String [static]

Added String.convertFromStringInterpolationSegment(UInt8) -> String [static]

Added String.convertFromStringInterpolationSegment(UnicodeScalar) -> String [static]

Added String.init(count: Int, repeatedValue: Character)

Added String.init(count: Int, repeatedValue: UnicodeScalar)

Added String.debugDescription

Added String.endIndex

Added String.extend(S)

Added String.extend(String)

Added String.init(extendedGraphemeClusterLiteral: String)

Added String.fromCString(UnsafePointer<CChar>) -> String? [static]

Added String.fromCStringRepairingIllFormedUTF8(UnsafePointer<CChar>) -> (String?, hadError: Bool) [static]

Added String.generate() -> IndexingGenerator<String>

Added String.getMirror() -> MirrorType

Added String.hasPrefix(String) -> Bool

Added String.hasSuffix(String) -> Bool

Added String.hashValue

Added String.insert(Character, atIndex: String.Index)

Added String.isEmpty

Added String.join(S) -> String

Added String.nulTerminatedUTF8

Added String.removeAll(Bool)

Added String.removeAtIndex(String.Index) -> Character

Added String.removeRange(Range<String.Index>)

Added String.replaceRange(Range<String.Index>, with: C)

Added String.reserveCapacity(Int)

Added String.splice(S, atIndex: String.Index)

Added String.startIndex

Added String.init(stringLiteral: String)

Added String.toInt() -> Int?

Added String.init(unicodeScalarLiteral: String)

Added String.unicodeScalars

Added String.utf16

Added String.utf8

Added String.withCString((UnsafePointer<Int8>) -> Result) -> Result

Added String.write(String)

Added String.writeTo(Target)

Added String.Index [struct]

Added String.Index.getMirror() -> MirrorType

Added String.Index.predecessor() -> String.Index

Added String.Index.successor() -> String.Index

Added String.UTF16View [struct]

Added String.UTF16View.endIndex

Added String.UTF16View.generate() -> Generator

Added String.UTF16View.getMirror() -> MirrorType

Added String.UTF16View.startIndex

Added String.UTF8View [struct]

Added String.UTF8View.endIndex

Added String.UTF8View.generate() -> IndexingGenerator<String.UTF8View>

Added String.UTF8View.getMirror() -> MirrorType

Added String.UTF8View.startIndex

Added String.UTF8View.Index [struct]

Added String.UTF8View.Index.successor() -> String.UTF8View.Index

Added String.UnicodeScalarView [struct]

Added String.UnicodeScalarView.endIndex

Added String.UnicodeScalarView.generate() -> String.UnicodeScalarView.Generator

Added String.UnicodeScalarView.getMirror() -> MirrorType

Added String.UnicodeScalarView.startIndex

Added String.UnicodeScalarView.Generator [struct]

Added String.UnicodeScalarView.Generator.next() -> UnicodeScalar?

Added String.UnicodeScalarView.Index [struct]

Added String.UnicodeScalarView.Index.predecessor() -> String.UnicodeScalarView.Index

Added String.UnicodeScalarView.Index.successor() -> String.UnicodeScalarView.Index

Added StringInterpolationConvertible

Added StringInterpolationConvertible.convertFromStringInterpolation(Self) -> Self [class]

Added StringInterpolationConvertible.convertFromStringInterpolationSegment(T) -> Self [class]

Added StringLiteralConvertible

Added StringLiteralConvertible.init(stringLiteral: StringLiteralType)

Added UInt [struct]

Added UInt.init()

Added UInt.init(_: Double)

Added UInt.init(_: Float)

Added UInt.init(_: Float80)

Added UInt.init(_: Int)

Added UInt.init(_: Int16)

Added UInt.init(_: Int32)

Added UInt.init(_: Int64)

Added UInt.init(_: Int8)

Added UInt.init(_: UInt)

Added UInt.init(_: UInt16)

Added UInt.init(_: UInt32)

Added UInt.init(_: UInt64)

Added UInt.init(_: UInt8)

Added UInt.init(_builtinIntegerLiteral: Builtin.Int2048)

Added UInt.addWithOverflow(UInt, _: UInt) -> (UInt, overflow: Bool) [static]

Added UInt.advancedBy(Distance) -> UInt

Added UInt.allZeros

Added UInt.bigEndian

Added UInt.init(bigEndian: UInt)

Added UInt.init(bitPattern: Int)

Added UInt.byteSwapped

Added UInt.description

Added UInt.distanceTo(UInt) -> Distance

Added UInt.divideWithOverflow(UInt, _: UInt) -> (UInt, overflow: Bool) [static]

Added UInt.encode() -> [Word]

Added UInt.getMirror() -> MirrorType

Added UInt.hashValue

Added UInt.init(integerLiteral: UInt)

Added UInt.littleEndian

Added UInt.init(littleEndian: UInt)

Added UInt.max

Added UInt.min

Added UInt.multiplyWithOverflow(UInt, _: UInt) -> (UInt, overflow: Bool) [static]

Added UInt.predecessor() -> UInt

Added UInt.remainderWithOverflow(UInt, _: UInt) -> (UInt, overflow: Bool) [static]

Added UInt.subtractWithOverflow(UInt, _: UInt) -> (UInt, overflow: Bool) [static]

Added UInt.successor() -> UInt

Added UInt.toIntMax() -> IntMax

Added UInt.toUIntMax() -> UIntMax

Added UInt.init(truncatingBitPattern: Int64)

Added UInt.init(truncatingBitPattern: UInt64)

Added UInt.value

Added UInt16 [struct]

Added UInt16.init()

Added UInt16.init(_: Double)

Added UInt16.init(_: Float)

Added UInt16.init(_: Float80)

Added UInt16.init(_: Int)

Added UInt16.init(_: Int16)

Added UInt16.init(_: Int32)

Added UInt16.init(_: Int64)

Added UInt16.init(_: Int8)

Added UInt16.init(_: UInt)

Added UInt16.init(_: UInt16)

Added UInt16.init(_: UInt32)

Added UInt16.init(_: UInt64)

Added UInt16.init(_: UInt8)

Added UInt16.init(_builtinIntegerLiteral: Builtin.Int2048)

Added UInt16.addWithOverflow(UInt16, _: UInt16) -> (UInt16, overflow: Bool) [static]

Added UInt16.advancedBy(Distance) -> UInt16

Added UInt16.allZeros

Added UInt16.bigEndian

Added UInt16.init(bigEndian: UInt16)

Added UInt16.init(bitPattern: Int16)

Added UInt16.byteSwapped

Added UInt16.description

Added UInt16.distanceTo(UInt16) -> Distance

Added UInt16.divideWithOverflow(UInt16, _: UInt16) -> (UInt16, overflow: Bool) [static]

Added UInt16.encode() -> [Word]

Added UInt16.getMirror() -> MirrorType

Added UInt16.hashValue

Added UInt16.init(integerLiteral: UInt16)

Added UInt16.littleEndian

Added UInt16.init(littleEndian: UInt16)

Added UInt16.max

Added UInt16.min

Added UInt16.multiplyWithOverflow(UInt16, _: UInt16) -> (UInt16, overflow: Bool) [static]

Added UInt16.predecessor() -> UInt16

Added UInt16.remainderWithOverflow(UInt16, _: UInt16) -> (UInt16, overflow: Bool) [static]

Added UInt16.subtractWithOverflow(UInt16, _: UInt16) -> (UInt16, overflow: Bool) [static]

Added UInt16.successor() -> UInt16

Added UInt16.toIntMax() -> IntMax

Added UInt16.toUIntMax() -> UIntMax

Added UInt16.init(truncatingBitPattern: Int)

Added UInt16.init(truncatingBitPattern: Int32)

Added UInt16.init(truncatingBitPattern: Int64)

Added UInt16.init(truncatingBitPattern: UInt)

Added UInt16.init(truncatingBitPattern: UInt32)

Added UInt16.init(truncatingBitPattern: UInt64)

Added UInt16.value

Added UInt32 [struct]

Added UInt32.init()

Added UInt32.init(_: Double)

Added UInt32.init(_: Float)

Added UInt32.init(_: Float80)

Added UInt32.init(_: Int)

Added UInt32.init(_: Int16)

Added UInt32.init(_: Int32)

Added UInt32.init(_: Int64)

Added UInt32.init(_: Int8)

Added UInt32.init(_: UInt)

Added UInt32.init(_: UInt16)

Added UInt32.init(_: UInt32)

Added UInt32.init(_: UInt64)

Added UInt32.init(_: UInt8)

Added UInt32.init(_: UnicodeScalar)

Added UInt32.init(_builtinIntegerLiteral: Builtin.Int2048)

Added UInt32.addWithOverflow(UInt32, _: UInt32) -> (UInt32, overflow: Bool) [static]

Added UInt32.advancedBy(Distance) -> UInt32

Added UInt32.allZeros

Added UInt32.bigEndian

Added UInt32.init(bigEndian: UInt32)

Added UInt32.init(bitPattern: Int32)

Added UInt32.byteSwapped

Added UInt32.description

Added UInt32.distanceTo(UInt32) -> Distance

Added UInt32.divideWithOverflow(UInt32, _: UInt32) -> (UInt32, overflow: Bool) [static]

Added UInt32.encode() -> [Word]

Added UInt32.getMirror() -> MirrorType

Added UInt32.hashValue

Added UInt32.init(integerLiteral: UInt32)

Added UInt32.littleEndian

Added UInt32.init(littleEndian: UInt32)

Added UInt32.max

Added UInt32.min

Added UInt32.multiplyWithOverflow(UInt32, _: UInt32) -> (UInt32, overflow: Bool) [static]

Added UInt32.predecessor() -> UInt32

Added UInt32.remainderWithOverflow(UInt32, _: UInt32) -> (UInt32, overflow: Bool) [static]

Added UInt32.subtractWithOverflow(UInt32, _: UInt32) -> (UInt32, overflow: Bool) [static]

Added UInt32.successor() -> UInt32

Added UInt32.toIntMax() -> IntMax

Added UInt32.toUIntMax() -> UIntMax

Added UInt32.init(truncatingBitPattern: Int)

Added UInt32.init(truncatingBitPattern: Int64)

Added UInt32.init(truncatingBitPattern: UInt)

Added UInt32.init(truncatingBitPattern: UInt64)

Added UInt32.value

Added UInt64 [struct]

Added UInt64.init()

Added UInt64.init(_: Double)

Added UInt64.init(_: Float)

Added UInt64.init(_: Float80)

Added UInt64.init(_: Int)

Added UInt64.init(_: Int16)

Added UInt64.init(_: Int32)

Added UInt64.init(_: Int64)

Added UInt64.init(_: Int8)

Added UInt64.init(_: UInt)

Added UInt64.init(_: UInt16)

Added UInt64.init(_: UInt32)

Added UInt64.init(_: UInt64)

Added UInt64.init(_: UInt8)

Added UInt64.init(_: UnicodeScalar)

Added UInt64.init(_builtinIntegerLiteral: Builtin.Int2048)

Added UInt64.addWithOverflow(UInt64, _: UInt64) -> (UInt64, overflow: Bool) [static]

Added UInt64.advancedBy(Distance) -> UInt64

Added UInt64.allZeros

Added UInt64.bigEndian

Added UInt64.init(bigEndian: UInt64)

Added UInt64.init(bitPattern: Int64)

Added UInt64.byteSwapped

Added UInt64.description

Added UInt64.distanceTo(UInt64) -> Distance

Added UInt64.divideWithOverflow(UInt64, _: UInt64) -> (UInt64, overflow: Bool) [static]

Added UInt64.encode() -> [Word]

Added UInt64.getMirror() -> MirrorType

Added UInt64.hashValue

Added UInt64.init(integerLiteral: UInt64)

Added UInt64.littleEndian

Added UInt64.init(littleEndian: UInt64)

Added UInt64.max

Added UInt64.min

Added UInt64.multiplyWithOverflow(UInt64, _: UInt64) -> (UInt64, overflow: Bool) [static]

Added UInt64.predecessor() -> UInt64

Added UInt64.remainderWithOverflow(UInt64, _: UInt64) -> (UInt64, overflow: Bool) [static]

Added UInt64.subtractWithOverflow(UInt64, _: UInt64) -> (UInt64, overflow: Bool) [static]

Added UInt64.successor() -> UInt64

Added UInt64.toIntMax() -> IntMax

Added UInt64.toUIntMax() -> UIntMax

Added UInt64.value

Added UInt8 [struct]

Added UInt8.init()

Added UInt8.init(_: Double)

Added UInt8.init(_: Float)

Added UInt8.init(_: Float80)

Added UInt8.init(_: Int)

Added UInt8.init(_: Int16)

Added UInt8.init(_: Int32)

Added UInt8.init(_: Int64)

Added UInt8.init(_: Int8)

Added UInt8.init(_: UInt)

Added UInt8.init(_: UInt16)

Added UInt8.init(_: UInt32)

Added UInt8.init(_: UInt64)

Added UInt8.init(_: UInt8)

Added UInt8.init(_: UnicodeScalar)

Added UInt8.init(_builtinIntegerLiteral: Builtin.Int2048)

Added UInt8.addWithOverflow(UInt8, _: UInt8) -> (UInt8, overflow: Bool) [static]

Added UInt8.advancedBy(Distance) -> UInt8

Added UInt8.allZeros

Added UInt8.init(bitPattern: Int8)

Added UInt8.description

Added UInt8.distanceTo(UInt8) -> Distance

Added UInt8.divideWithOverflow(UInt8, _: UInt8) -> (UInt8, overflow: Bool) [static]

Added UInt8.encode() -> [Word]

Added UInt8.getMirror() -> MirrorType

Added UInt8.hashValue

Added UInt8.init(integerLiteral: UInt8)

Added UInt8.max

Added UInt8.min

Added UInt8.multiplyWithOverflow(UInt8, _: UInt8) -> (UInt8, overflow: Bool) [static]

Added UInt8.predecessor() -> UInt8

Added UInt8.remainderWithOverflow(UInt8, _: UInt8) -> (UInt8, overflow: Bool) [static]

Added UInt8.subtractWithOverflow(UInt8, _: UInt8) -> (UInt8, overflow: Bool) [static]

Added UInt8.successor() -> UInt8

Added UInt8.toIntMax() -> IntMax

Added UInt8.toUIntMax() -> UIntMax

Added UInt8.init(truncatingBitPattern: Int)

Added UInt8.init(truncatingBitPattern: Int16)

Added UInt8.init(truncatingBitPattern: Int32)

Added UInt8.init(truncatingBitPattern: Int64)

Added UInt8.init(truncatingBitPattern: UInt)

Added UInt8.init(truncatingBitPattern: UInt16)

Added UInt8.init(truncatingBitPattern: UInt32)

Added UInt8.init(truncatingBitPattern: UInt64)

Added UInt8.value

Added UTF16 [struct]

Added UTF16.init()

Added UTF16.copy(UnsafeMutablePointer<T>, destination: UnsafeMutablePointer, count: Int) [static]

Added UTF16.decode(G) -> UnicodeDecodingResult

Added UTF16.encode(UnicodeScalar, output: S) [static]

Added UTF16.leadSurrogate(UnicodeScalar) -> CodeUnit [static]

Added UTF16.measure(Encoding.Type, input: Input, repairIllFormedSequences: Bool) -> (Int, Bool)? [static]

Added UTF16.trailSurrogate(UnicodeScalar) -> CodeUnit [static]

Added UTF16.width(UnicodeScalar) -> Int [static]

Added UTF32 [struct]

Added UTF32.init()

Added UTF32.decode(G) -> UnicodeDecodingResult

Added UTF32.encode(UnicodeScalar, output: S) [static]

Added UTF8 [struct]

Added UTF8.init()

Added UTF8.decode(G) -> UnicodeDecodingResult

Added UTF8.encode(UnicodeScalar, output: S) [static]

Added UnicodeCodecType

Added UnicodeCodecType.init()

Added UnicodeCodecType.decode(G) -> UnicodeDecodingResult

Added UnicodeCodecType.encode(UnicodeScalar, output: S) [class]

Added UnicodeDecodingResult [enum]

Added UnicodeDecodingResult.EmptyInput

Added UnicodeDecodingResult.Error

Added UnicodeDecodingResult.Result

Added UnicodeDecodingResult.isEmptyInput() -> Bool

Added UnicodeScalar [struct]

Added UnicodeScalar.init()

Added UnicodeScalar.init(_: Builtin.Int32)

Added UnicodeScalar.init(_: Int)

Added UnicodeScalar.init(_: UInt16)

Added UnicodeScalar.init(_: UInt32)

Added UnicodeScalar.init(_: UInt8)

Added UnicodeScalar.init(_: UnicodeScalar)

Added UnicodeScalar.init(_builtinUnicodeScalarLiteral: Builtin.Int32)

Added UnicodeScalar.debugDescription

Added UnicodeScalar.description

Added UnicodeScalar.escape(Bool) -> String

Added UnicodeScalar.getMirror() -> MirrorType

Added UnicodeScalar.hashValue

Added UnicodeScalar.isASCII() -> Bool

Added UnicodeScalar.init(unicodeScalarLiteral: UnicodeScalar)

Added UnicodeScalar.utf16

Added UnicodeScalar.value

Added UnicodeScalar.writeTo(Target)

Added UnicodeScalar.UTF16View [struct]

Added UnicodeScalar.UTF16View.value

Added UnicodeScalarLiteralConvertible

Added UnicodeScalarLiteralConvertible.init(unicodeScalarLiteral: UnicodeScalarLiteralType)

Added Unmanaged [struct]

Added Unmanaged.autorelease() -> Unmanaged<T>

Added Unmanaged.fromOpaque(COpaquePointer) -> Unmanaged<T> [static]

Added Unmanaged.passRetained(T) -> Unmanaged<T> [static]

Added Unmanaged.passUnretained(T) -> Unmanaged<T> [static]

Added Unmanaged.release()

Added Unmanaged.retain() -> Unmanaged<T>

Added Unmanaged.takeRetainedValue() -> T

Added Unmanaged.takeUnretainedValue() -> T

Added Unmanaged.toOpaque() -> COpaquePointer

Added UnsafeBufferPointer [struct]

Added UnsafeBufferPointer.baseAddress

Added UnsafeBufferPointer.count

Added UnsafeBufferPointer.debugDescription

Added UnsafeBufferPointer.endIndex

Added UnsafeBufferPointer.generate() -> UnsafeBufferPointerGenerator<T>

Added UnsafeBufferPointer.init(start: UnsafePointer<T>, count: Int)

Added UnsafeBufferPointer.startIndex

Added UnsafeBufferPointerGenerator [struct]

Added UnsafeBufferPointerGenerator.end

Added UnsafeBufferPointerGenerator.generate() -> UnsafeBufferPointerGenerator<T>

Added UnsafeBufferPointerGenerator.next() -> T?

Added UnsafeBufferPointerGenerator.position

Added UnsafeMutableBufferPointer [struct]

Added UnsafeMutableBufferPointer.baseAddress

Added UnsafeMutableBufferPointer.count

Added UnsafeMutableBufferPointer.debugDescription

Added UnsafeMutableBufferPointer.endIndex

Added UnsafeMutableBufferPointer.generate() -> UnsafeBufferPointerGenerator<T>

Added UnsafeMutableBufferPointer.init(start: UnsafeMutablePointer<T>, count: Int)

Added UnsafeMutableBufferPointer.startIndex

Added UnsafeMutablePointer [struct]

Added UnsafeMutablePointer.init()

Added UnsafeMutablePointer.init(_: Builtin.RawPointer)

Added UnsafeMutablePointer.init(_: COpaquePointer)

Added UnsafeMutablePointer.init(_: UnsafeMutablePointer)

Added UnsafeMutablePointer.init(_: UnsafePointer)

Added UnsafeMutablePointer.advancedBy(Int) -> UnsafeMutablePointer<T>

Added UnsafeMutablePointer.alloc(Int) -> UnsafeMutablePointer<T> [static]

Added UnsafeMutablePointer.assignBackwardFrom(UnsafeMutablePointer<T>, count: Int)

Added UnsafeMutablePointer.assignFrom(UnsafeMutablePointer<T>, count: Int)

Added UnsafeMutablePointer.init(bitPattern: UWord)

Added UnsafeMutablePointer.init(bitPattern: Word)

Added UnsafeMutablePointer.dealloc(Int)

Added UnsafeMutablePointer.debugDescription

Added UnsafeMutablePointer.destroy()

Added UnsafeMutablePointer.destroy(Int)

Added UnsafeMutablePointer.distanceTo(UnsafeMutablePointer<T>) -> Int

Added UnsafeMutablePointer.getMirror() -> MirrorType

Added UnsafeMutablePointer.hashValue

Added UnsafeMutablePointer.initialize(T)

Added UnsafeMutablePointer.initializeFrom(C)

Added UnsafeMutablePointer.initializeFrom(UnsafeMutablePointer<T>, count: Int)

Added UnsafeMutablePointer.memory

Added UnsafeMutablePointer.move() -> T

Added UnsafeMutablePointer.moveAssignFrom(UnsafeMutablePointer<T>, count: Int)

Added UnsafeMutablePointer.moveInitializeBackwardFrom(UnsafeMutablePointer<T>, count: Int)

Added UnsafeMutablePointer.moveInitializeFrom(UnsafeMutablePointer<T>, count: Int)

Added UnsafeMutablePointer.init(nilLiteral: ())

Added UnsafeMutablePointer.null() -> UnsafeMutablePointer<T> [static]

Added UnsafeMutablePointer.predecessor() -> UnsafeMutablePointer<T>

Added UnsafeMutablePointer.put(T)

Added UnsafeMutablePointer.successor() -> UnsafeMutablePointer<T>

Added UnsafeMutablePointer.value

Added UnsafePointer [struct]

Added UnsafePointer.init()

Added UnsafePointer.init(_: Builtin.RawPointer)

Added UnsafePointer.init(_: COpaquePointer)

Added UnsafePointer.init(_: UnsafeMutablePointer)

Added UnsafePointer.init(_: UnsafePointer)

Added UnsafePointer.advancedBy(Int) -> UnsafePointer<T>

Added UnsafePointer.init(bitPattern: UWord)

Added UnsafePointer.init(bitPattern: Word)

Added UnsafePointer.debugDescription

Added UnsafePointer.distanceTo(UnsafePointer<T>) -> Int

Added UnsafePointer.getMirror() -> MirrorType

Added UnsafePointer.hashValue

Added UnsafePointer.memory

Added UnsafePointer.init(nilLiteral: ())

Added UnsafePointer.null() -> UnsafePointer<T> [static]

Added UnsafePointer.predecessor() -> UnsafePointer<T>

Added UnsafePointer.successor() -> UnsafePointer<T>

Added UnsafePointer.value

Added UnsignedIntegerType

Added VaListBuilder

Added VaListBuilder.init()

Added VaListBuilder.append(CVarArgType)

Added VaListBuilder.gpRegistersUsed

Added VaListBuilder.header

Added VaListBuilder.sseRegistersUsed

Added VaListBuilder.storage

Added VaListBuilder.va_list() -> CVaListPointer

Added VaListBuilder.Header [struct]

Added VaListBuilder.Header.fp_offset

Added VaListBuilder.Header.gp_offset

Added VaListBuilder.Header.overflow_arg_area

Added VaListBuilder.Header.reg_save_area

Added Zip2 [struct]

Added Zip2.init(_: S0, _: S1)

Added Zip2.generate() -> Generator

Added Zip2.sequences

Added ZipGenerator2 [struct]

Added ZipGenerator2.init(_: E0, _: E1)

Added ZipGenerator2.baseStreams

Added ZipGenerator2.next() -> Element?

Added Any

Added AnyClass

Added Array.Element

Added Array.SubSlice

Added ArrayLiteralConvertible.Element

Added BidirectionalReverseView.Generator

Added BidirectionalReverseView.Index

Added BooleanLiteralConvertible.BooleanLiteralType

Added BooleanLiteralType

Added CBool

Added CChar

Added CChar16

Added CChar32

Added CDouble

Added CFloat

Added CInt

Added CLong

Added CLongLong

Added CShort

Added CSignedChar

Added CUnsignedChar

Added CUnsignedInt

Added CUnsignedLong

Added CUnsignedLongLong

Added CUnsignedShort

Added CWideChar

Added C_ARGC

Added C_ARGV

Added Character.UTF16View

Added CharacterLiteralConvertible.CharacterLiteralType

Added ClosedInterval.Bound

Added CollectionOfOne.Index

Added ContiguousArray.Element

Added ContiguousArray.SubSlice

Added Dictionary.Element

Added Dictionary.Index

Added DictionaryIndex.Index

Added DictionaryLiteralConvertible.Key

Added DictionaryLiteralConvertible.Value

Added EmptyCollection.Index

Added EnumerateGenerator.Element

Added EnumerateGenerator.Generator

Added ExtendedGraphemeClusterLiteralConvertible.ExtendedGraphemeClusterLiteralType

Added ExtendedGraphemeClusterType

Added FilterCollectionView.Index

Added Float32

Added Float64

Added FloatLiteralConvertible.FloatLiteralType

Added FloatLiteralType

Added GeneratorType.Element

Added HalfOpenInterval.Bound

Added HeapBuffer.Storage

Added HeapBufferStorage.Buffer

Added Int.Distance

Added Int16.Distance

Added Int32.Distance

Added Int64.Distance

Added Int8.Distance

Added IntMax

Added IntegerLiteralConvertible.IntegerLiteralType

Added IntegerLiteralType

Added IntervalType.Bound

Added OnHeap.Buffer

Added PermutationGenerator.Element

Added PermutationGenerator.Generator

Added Process

Added RandomAccessReverseView.Generator

Added RandomAccessReverseView.Index

Added Range.Generator

Added Range.Index

Added Range.Slice

Added RangeGenerator.Element

Added RangeGenerator.Generator

Added RawRepresentable.RawValue

Added Repeat.Index

Added ReverseBidirectionalIndex.Distance

Added ReverseRandomAccessIndex.Distance

Added SequenceType.Generator

Added SinkType.Element

Added Slice.Element

Added Slice.SubSlice

Added Sliceable.SubSlice

Added String.UTF16View.Generator

Added StringLiteralConvertible.StringLiteralType

Added StringLiteralType

Added UInt.Distance

Added UInt16.Distance

Added UInt32.Distance

Added UInt64.Distance

Added UInt8.Distance

Added UIntMax

Added UTF16.CodeUnit

Added UTF32.CodeUnit

Added UTF8.CodeUnit

Added UWord

Added UnicodeCodecType.CodeUnit

Added UnicodeScalarLiteralConvertible.UnicodeScalarLiteralType

Added UnicodeScalarType

Added Void

Added Word

Added Zip2.Generator

Added Zip2.Stream1

Added Zip2.Stream2

Added ZipGenerator2.Element

Added abs(T) -> T

Added advance(T, T.Distance) -> T

Added advance(T, T.Distance, T) -> T

Added alignof() -> Int

Added alignofValue() -> Int

Added assert(() -> Bool,() -> String, StaticString, UWord)

Added assertionFailure(() -> String, StaticString, UWord)

Added contains(S,(S.Generator.Element) -> L) -> Bool

Added contains(S, S.Generator.Element) -> Bool

Added count(Range) -> I.Distance

Added countElements(T) -> T.Index.Distance

Added debugPrint(T)

Added debugPrint(T, TargetStream)

Added debugPrintln(T)

Added debugPrintln(T, TargetStream)

Added distance(T, T) -> T.Distance

Added dropFirst(Seq) -> Seq.SubSlice

Added dropLast(S) -> S.SubSlice

Added dump(T, String?, Int, Int, Int) -> T

Added dump(T, TargetStream, String?, Int, Int, Int) -> T

Added enumerate(Seq) -> EnumerateSequence<Seq>

Added equal(S1, S2) -> Bool

Added equal(S1, S2,(S1.Generator.Element, S1.Generator.Element) -> Bool) -> Bool

Added extend(C, S)

Added fatalError(() -> String, StaticString, UWord)

Added filter(S,(S.Generator.Element) -> Bool) -> [S.Generator.Element]

Added find(C, C.Generator.Element) -> C.Index?

Added first(C) -> C.Generator.Element?

Added getVaList([CVarArgType]) -> CVaListPointer

Added indices(C) -> Range<C.Index>

Added insert(C, C.Generator.Element, C.Index)

Added isEmpty(C) -> Bool

Added join(C, S) -> C

Added last(C) -> C.Generator.Element?

Added lazy(S) -> LazyBidirectionalCollection<S>

Added lazy(S) -> LazyForwardCollection<S>

Added lazy(S) -> LazyRandomAccessCollection<S>

Added lazy(S) -> LazySequence<S>

Added lexicographicalCompare(S1, S2) -> Bool

Added lexicographicalCompare(S1, S2,(S1.Generator.Element, S1.Generator.Element) -> Bool) -> Bool

Added map(C,(C.Generator.Element) -> T) -> [T]

Added map(S,(S.Generator.Element) -> T) -> [T]

Added map(T?,(T) -> U) -> U?

Added max(T, T) -> T

Added max(T, T, T, T) -> T

Added maxElement(R) -> R.Generator.Element

Added min(T, T) -> T

Added min(T, T, T, T) -> T

Added minElement(R) -> R.Generator.Element

Added numericCast(T) -> U

Added overlaps(I0, I1) -> Bool

Added partition(C, Range<C.Index>) -> C.Index

Added partition(C, Range<C.Index>,(C.Generator.Element, C.Generator.Element) -> Bool) -> C.Index

Added precondition(() -> Bool,() -> String, StaticString, UWord)

Added preconditionFailure(() -> String, StaticString, UWord)

Added prefix(S, Int) -> S.SubSlice

Added print(T)

Added print(T, TargetStream)

Added println()

Added println(T)

Added println(T, TargetStream)

Added reduce(S, U,(U, S.Generator.Element) -> U) -> U

Added reflect(T) -> MirrorType

Added removeAll(C, Bool)

Added removeAtIndex(C, C.Index) -> C.Generator.Element

Added removeLast(C) -> C.Generator.Element

Added removeRange(C, Range<C.Index>)

Added reverse(C) -> [C.Generator.Element]

Added sizeof() -> Int

Added sizeofValue() -> Int

Added sort(C)

Added sort(C,(C.Generator.Element, C.Generator.Element) -> Bool)

Added sort(ContiguousArray<T>)

Added sort(ContiguousArray<T>,(T, T) -> Bool)

Added sort([T])

Added sort([T],(T, T) -> Bool)

Added sorted(C) -> [C.Generator.Element]

Added sorted(C,(C.Generator.Element, C.Generator.Element) -> Bool) -> [C.Generator.Element]

Added splice(C, S, C.Index)

Added split(S,(S.Generator.Element) -> R, Int, Bool) -> [S.SubSlice]

Added startsWith(S0, S1) -> Bool

Added startsWith(S0, S1,(S0.Generator.Element, S0.Generator.Element) -> Bool) -> Bool

Added stride(T, T, T.Stride) -> StrideThrough<T>

Added stride(T, T, T.Stride) -> StrideTo<T>

Added strideof() -> Int

Added strideofValue() -> Int

Added suffix(S, Int) -> S.SubSlice

Added swap(T, T)

Added toDebugString(T) -> String

Added toString(T) -> String

Added transcode(InputEncoding.Type, OutputEncoding.Type, Input, Output, Bool) -> (Bool)

Added underestimateCount(T) -> Int

Added unsafeAddressOf(AnyObject) -> UnsafePointer<Void>

Added unsafeBitCast(T, U.Type) -> U

Added unsafeDowncast(AnyObject) -> T

Added unsafeReflect(Builtin.NativeObject, UnsafeMutablePointer<T>) -> MirrorType

Added withExtendedLifetime(T,() -> Result) -> Result

Added withExtendedLifetime(T,(T) -> Result) -> Result

Added withUnsafeMutablePointer(T,(UnsafeMutablePointer<T>) -> Result) -> Result

Added withUnsafeMutablePointers(A0, A1,(UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>) -> Result) -> Result

Added withUnsafeMutablePointers(A0, A1, A2,(UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>, UnsafeMutablePointer<A2>) -> Result) -> Result

Added withUnsafePointer(T,(UnsafePointer<T>) -> Result) -> Result

Added withUnsafePointers(A0, A1,(UnsafePointer<A0>, UnsafePointer<A1>) -> Result) -> Result

Added withUnsafePointers(A0, A1, A2,(UnsafePointer<A0>, UnsafePointer<A1>, UnsafePointer<A2>) -> Result) -> Result

Added withVaList(VaListBuilder,(CVaListPointer) -> R) -> R

Added withVaList([CVarArgType],(CVaListPointer) -> R) -> R