★ AbsoluteValuable
public protocol AbsoluteValuable : SignedNumberType {
/// Returns the absolute value of `x`.
@warn_unused_result
public static func abs(x: Self) -> Self
}
★ AnyCollectionType
public protocol AnyCollectionType : CollectionType {
}
★ AnyObject
@objc public protocol AnyObject {
}
★ ArrayLiteralConvertible
public protocol ArrayLiteralConvertible {
typealias Element
/// Create an instance initialized with `elements`.
public init(arrayLiteral elements: Self.Element...)
}
★ BidirectionalIndexType
public protocol BidirectionalIndexType : ForwardIndexType {
@warn_unused_result
public func predecessor() -> Self
}
★ BitwiseOperationsType
public protocol BitwiseOperationsType {
@warn_unused_result
public func &(lhs: Self, rhs: Self) -> Self
@warn_unused_result
public func |(lhs: Self, rhs: Self) -> Self
@warn_unused_result
public func ^(lhs: Self, rhs: Self) -> Self
@warn_unused_result
prefix public func ~(x: Self) -> Self
public static var allZeros: Self { get }
}
★ BooleanLiteralConvertible
public protocol BooleanLiteralConvertible {
typealias BooleanLiteralType
public init(booleanLiteral value: Self.BooleanLiteralType)
}
★ BooleanType
public protocol BooleanType {
public var boolValue: Bool { get }
}
★ CVarArgType
public protocol CVarArgType {
}
★ CollectionType
public protocol CollectionType : Indexable, SequenceType {
typealias Generator : GeneratorType = IndexingGenerator<Self>
public func generate() -> Self.Generator
typealias SubSequence : Indexable, SequenceType = Slice<Self>
public subscript (position: Self.Index) -> Self.Generator.Element { get }
public subscript (bounds: Range<Self.Index>) -> Self.SubSequence { get }
@warn_unused_result
public func prefixUpTo(end: Self.Index) -> Self.SubSequence
@warn_unused_result
public func suffixFrom(start: Self.Index) -> Self.SubSequence
@warn_unused_result
public func prefixThrough(position: Self.Index) -> Self.SubSequence
public var isEmpty: Bool { get }
public var count: Self.Index.Distance { get }
public var first: Self.Generator.Element? { get }
}
★ Comparable
public protocol Comparable : Equatable {
@warn_unused_result
public func <(lhs: Self, rhs: Self) -> Bool
@warn_unused_result
public func <=(lhs: Self, rhs: Self) -> Bool
@warn_unused_result
public func >=(lhs: Self, rhs: Self) -> Bool
@warn_unused_result
public func >(lhs: Self, rhs: Self) -> Bool
}
★ CustomDebugStringConvertible
public protocol CustomDebugStringConvertible {
public var debugDescription: String { get }
}
★ CustomLeafReflectable
public protocol CustomLeafReflectable : CustomReflectable {
}
★ CustomPlaygroundQuickLookable
public protocol CustomPlaygroundQuickLookable {
@warn_unused_result
public func customPlaygroundQuickLook() -> PlaygroundQuickLook
}
★ CustomReflectable
public protocol CustomReflectable {
@warn_unused_result
public func customMirror() -> Mirror
}
★ CustomStringConvertible
public protocol CustomStringConvertible {
public var description: String { get }
}
★ DictionaryLiteralConvertible
public protocol DictionaryLiteralConvertible {
typealias Key
typealias Value
public init(dictionaryLiteral elements: (Self.Key, Self.Value)...)
}
★ Equatable
public protocol Equatable {
@warn_unused_result
public func ==(lhs: Self, rhs: Self) -> Bool
}
★ ErrorType
public protocol ErrorType {
}
★ ErrorType
public protocol ExtendedGraphemeClusterLiteralConvertible : UnicodeScalarLiteralConvertible {
typealias ExtendedGraphemeClusterLiteralType
public init(extendedGraphemeClusterLiteral value: Self.ExtendedGraphemeClusterLiteralType)
}
★ FloatLiteralConvertible
public protocol FloatLiteralConvertible {
typealias FloatLiteralType
public init(floatLiteral value: Self.FloatLiteralType)
}
★ FloatingPointType
public protocol FloatingPointType : Strideable {
public init(_ value: UInt8)
public init(_ value: Int8)
public init(_ value: UInt16)
public init(_ value: Int16)
public init(_ value: UInt32)
public init(_ value: Int32)
public init(_ value: UInt64)
public init(_ value: Int64)
public init(_ value: UInt)
public init(_ value: Int)
public static var infinity: Self { get }
public static var NaN: Self { get }
public static var quietNaN: Self { get }
public var floatingPointClass: FloatingPointClassification { get }
public var isSignMinus: Bool { get }
public var isNormal: Bool { get }
public var isFinite: Bool { get }
public var isZero: Bool { get }
public var isSubnormal: Bool { get }
public var isInfinite: Bool { get }
public var isNaN: Bool { get }
public var isSignaling: Bool { get }
}
★ ForwardIndexType
public protocol ForwardIndexType : _Incrementable {
typealias Distance : _SignedIntegerType = Int
@warn_unused_result
public func advancedBy(n: Self.Distance) -> Self
@warn_unused_result
public func advancedBy(n: Self.Distance, limit: Self) -> Self
@warn_unused_result
public func distanceTo(end: Self) -> Self.Distance
}
★ GeneratorType
public protocol GeneratorType {
typealias Element
@warn_unused_result
public mutating func next() -> Self.Element?
}
★ Hashable
public protocol Hashable : Equatable {
public var hashValue: Int { get }
}
★ Indexable
public protocol Indexable {
typealias Index : ForwardIndexType
public var startIndex: Self.Index { get }
public var endIndex: Self.Index { get }
public subscript (position: Self.Index) -> Self._Element { get }
}
★ IntegerArithmeticType
public protocol IntegerArithmeticType : _IntegerArithmeticType, Comparable {
@warn_unused_result
public func +(lhs: Self, rhs: Self) -> Self
@warn_unused_result
public func -(lhs: Self, rhs: Self) -> Self
@warn_unused_result
public func *(lhs: Self, rhs: Self) -> Self
@warn_unused_result
public func /(lhs: Self, rhs: Self) -> Self
@warn_unused_result
public func %(lhs: Self, rhs: Self) -> Self
@warn_unused_result
public func toIntMax() -> IntMax
}
★ IntegerLiteralConvertible
public protocol IntegerLiteralConvertible {
typealias IntegerLiteralType
public init(integerLiteral value: Self.IntegerLiteralType)
}
★ IntegerType
public protocol IntegerType : _IntegerType, RandomAccessIndexType {
}
★ IntervalType
public protocol IntervalType {
typealias Bound : Comparable
@warn_unused_result
public func contains(value: Self.Bound) -> Bool
@warn_unused_result
public func clamp(intervalToClamp: Self) -> Self
public var isEmpty: Bool { get }
public var start: Self.Bound { get }
public var end: Self.Bound { get }
}
★ LazyCollectionType
public protocol LazyCollectionType : CollectionType, LazySequenceType {
typealias Elements : CollectionType = Self
}
★ LazySequenceType
public protocol LazySequenceType : SequenceType {
typealias Elements : SequenceType = Self
public var elements: Self.Elements { get }
public var array: [Self.Generator.Element] { get }
}
★ MirrorPathType
public protocol MirrorPathType {
}
★ MutableCollectionType
public protocol MutableCollectionType : MutableIndexable, CollectionType {
typealias SubSequence = MutableSlice<Self>
public subscript (position: Self.Index) -> Self.Generator.Element { get set }
public subscript (bounds: Range<Self.Index>) -> Self.SubSequence { get set }
}
★ MutableIndexable
public protocol MutableIndexable {
typealias Index : ForwardIndexType
public var startIndex: Self.Index { get }
public var endIndex: Self.Index { get }
public subscript (position: Self.Index) -> Self._Element { get set }
}
★ MutableSliceable
public protocol MutableSliceable : CollectionType, MutableCollectionType {
public subscript (_: Range<Self.Index>) -> Self.SubSequence { get set }
}
★ NilLiteralConvertible
public protocol NilLiteralConvertible {
public init(nilLiteral: ())
}
★ OptionSetType
public protocol OptionSetType : SetAlgebraType, RawRepresentable {
typealias Element = Self
public init(rawValue: Self.RawValue)
}
★ OutputStreamType
public protocol OutputStreamType {
public mutating func write(string: String)
}
★ RandomAccessIndexType
public protocol RandomAccessIndexType : BidirectionalIndexType, Strideable, _RandomAccessAmbiguity {
@warn_unused_result
public func distanceTo(other: Self) -> Self.Distance
@warn_unused_result
public func advancedBy(n: Self.Distance) -> Self
@warn_unused_result
public func advancedBy(n: Self.Distance, limit: Self) -> Self
}
★ RangeReplaceableCollectionType
public protocol RangeReplaceableCollectionType : CollectionType {
public init()
public mutating func replaceRange<C : CollectionType where C.Generator.Element == Generator.Element>(subRange: Range<Self.Index>, with newElements: C)
public mutating func reserveCapacity(n: Self.Index.Distance)
public mutating func append(x: Self.Generator.Element)
public mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(newElements: S)
public mutating func insert(newElement: Self.Generator.Element, atIndex i: Self.Index)
public mutating func insertContentsOf<S : CollectionType where S.Generator.Element == Generator.Element>(newElements: S, at i: Self.Index)
public mutating func removeAtIndex(i: Self.Index) -> Self.Generator.Element
public mutating func removeFirst() -> Self.Generator.Element
public mutating func removeFirst(n: Int)
public mutating func removeRange(subRange: Range<Self.Index>)
public mutating func removeAll(keepCapacity keepCapacity: Bool)
}
★ RawRepresentable
public protocol RawRepresentable {
typealias RawValue
public init?(rawValue: Self.RawValue)
public var rawValue: Self.RawValue { get }
}
★ ReverseIndexType
public protocol ReverseIndexType : BidirectionalIndexType {
typealias Base : BidirectionalIndexType
typealias Distance : _SignedIntegerType = Self.Base.Distance
public var base: Self.Base { get }
public init(_ base: Self.Base)
}
★ SequenceType
public protocol SequenceType {
typealias Generator : GeneratorType
typealias SubSequence
@warn_unused_result
public func generate() -> Self.Generator
@warn_unused_result
public func underestimateCount() -> Int
@warn_unused_result
public func map<T>(@noescape transform: (Self.Generator.Element) throws -> T) rethrows -> [T]
@warn_unused_result
public func filter(@noescape includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
public func forEach(@noescape body: (Self.Generator.Element) throws -> ()) rethrows
@warn_unused_result
public func dropFirst(n: Int) -> Self.SubSequence
@warn_unused_result
public func dropLast(n: Int) -> Self.SubSequence
@warn_unused_result
public func prefix(maxLength: Int) -> Self.SubSequence
@warn_unused_result
public func suffix(maxLength: Int) -> Self.SubSequence
@warn_unused_result
public func split(maxSplit: Int, allowEmptySlices: Bool, @noescape isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
}
★ SetAlgebraType
public protocol SetAlgebraType : Equatable, ArrayLiteralConvertible {
typealias Element
public init()
@warn_unused_result
public func contains(member: Self.Element) -> Bool
@warn_unused_result
public func union(other: Self) -> Self
@warn_unused_result
public func intersect(other: Self) -> Self
@warn_unused_result
public func exclusiveOr(other: Self) -> Self
public mutating func insert(member: Self.Element)
public mutating func remove(member: Self.Element) -> Self.Element?
public mutating func unionInPlace(other: Self)
public mutating func intersectInPlace(other: Self)
public mutating func exclusiveOrInPlace(other: Self)
@warn_unused_result
public func subtract(other: Self) -> Self
@warn_unused_result
public func isSubsetOf(other: Self) -> Bool
@warn_unused_result
public func isDisjointWith(other: Self) -> Bool
@warn_unused_result
public func isSupersetOf(other: Self) -> Bool
public var isEmpty: Bool { get }
public init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
public mutating func subtractInPlace(other: Self)
@warn_unused_result
public static func element(a: Self.Element, subsumes b: Self.Element) -> Bool
@warn_unused_result
public static func element(a: Self.Element, isDisjointWith b: Self.Element) -> Bool
}
★ SignedIntegerType
public protocol SignedIntegerType : _SignedIntegerType, IntegerType {
public func toIntMax() -> IntMax
public init(_: IntMax)
}
★ SignedNumberType
public protocol SignedNumberType : Comparable, IntegerLiteralConvertible {
@warn_unused_result
prefix public func -(x: Self) -> Self
@warn_unused_result
public func -(lhs: Self, rhs: Self) -> Self
}
★ Streamable
public protocol Streamable {
public func writeTo<Target : OutputStreamType>(inout target: Target)
}
★ Strideable
public protocol Strideable : Comparable, _Strideable {
typealias Stride : SignedNumberType
@warn_unused_result
public func distanceTo(other: Self) -> Self.Stride
@warn_unused_result
public func advancedBy(n: Self.Stride) -> Self
}
★ StringInterpolationConvertible
public protocol StringInterpolationConvertible {
public init(stringInterpolation strings: Self...)
public init<T>(stringInterpolationSegment expr: T)
}
★ StringLiteralConvertible
public protocol StringLiteralConvertible : ExtendedGraphemeClusterLiteralConvertible {
typealias StringLiteralType
public init(stringLiteral value: Self.StringLiteralType)
}
★ UnicodeCodecType
public protocol UnicodeCodecType {
typealias CodeUnit
public init()
public mutating func decode<G : GeneratorType where G.Element == CodeUnit>(inout next: G) -> UnicodeDecodingResult
public static func encode(input: UnicodeScalar, output: (Self.CodeUnit) -> ())
}
★ UnicodeScalarLiteralConvertible
public protocol UnicodeScalarLiteralConvertible {
typealias UnicodeScalarLiteralType
public init(unicodeScalarLiteral value: Self.UnicodeScalarLiteralType)
}
★ UnsignedIntegerType
public protocol UnsignedIntegerType : _DisallowMixedSignArithmetic, IntegerType {
@warn_unused_result
public func toUIntMax() -> UIntMax
public init(_: UIntMax)
}
★ _ArrayBufferType
public protocol _ArrayBufferType : MutableCollectionType {
typealias Element
public init()
public init(_ buffer: _ContiguousArrayBuffer<Self.Element>, shiftedToStartIndex: Int)
public subscript (index: Int) -> Self.Element { get nonmutating set }
@warn_unused_result
public mutating func requestUniqueMutableBackingBuffer(minimumCapacity: Int) -> _ContiguousArrayBuffer<Self.Element>?
@warn_unused_result
public mutating func isMutableAndUniquelyReferenced() -> Bool
@warn_unused_result
public func requestNativeBuffer() -> _ContiguousArrayBuffer<Self.Element>?
public mutating func replace<C : CollectionType where C.Generator.Element == Element>(subRange subRange: Range<Int>, with newCount: Int, elementsOf newValues: C)
public subscript (subRange: Range<Int>) -> _SliceBuffer<Self.Element> { get }
public func withUnsafeBufferPointer<R>(@noescape body: (UnsafeBufferPointer<Self.Element>) throws -> R) rethrows -> R
public mutating func withUnsafeMutableBufferPointer<R>(@noescape body: (UnsafeMutableBufferPointer<Self.Element>) throws -> R) rethrows -> R
public var count: Int { get set }
public var capacity: Int { get }
public var owner: AnyObject { get }
public var firstElementAddress: UnsafeMutablePointer<Self.Element> { get }
public var subscriptBaseAddress: UnsafeMutablePointer<Self.Element> { get }
public var identity: UnsafePointer<Void> { get }
public var startIndex: Int { get }
}
★ _ArrayType
public protocol _ArrayType : RangeReplaceableCollectionType, MutableSliceable, ArrayLiteralConvertible {
public init(count: Int, repeatedValue: Self.Generator.Element)
public var count: Int { get }
public var capacity: Int { get }
public var isEmpty: Bool { get }
public subscript (index: Int) -> Self.Generator.Element { get set }
public mutating func reserveCapacity(minimumCapacity: Int)
public func +=<S : SequenceType where S.Generator.Element == Generator.Element>(inout lhs: Self, rhs: S)
public mutating func insert(newElement: Self.Generator.Element, atIndex i: Int)
public mutating func removeAtIndex(index: Int) -> Self.Generator.Element
public init(_ buffer: Self._Buffer)
}
★ _CVarArgAlignedType
public protocol _CVarArgAlignedType : CVarArgType {
}
★ _CVarArgPassedAsDouble
public protocol _CVarArgPassedAsDouble : CVarArgType {
}
★ _CocoaStringType
@objc public protocol _CocoaStringType {
}
★ _CollectionWrapperType
public protocol _CollectionWrapperType : _SequenceWrapperType {
typealias Base : CollectionType
typealias Index : ForwardIndexType = Self.Base.Index
}
★ _ColorLiteralConvertible
public protocol _ColorLiteralConvertible {
public init(colorLiteralRed: Float, green: Float, blue: Float, alpha: Float)
}
★ _DestructorSafeContainer
public protocol _DestructorSafeContainer {
}
★ _DisallowMixedSignArithmetic
public protocol _DisallowMixedSignArithmetic : _IntegerType {
}
★ _FileReferenceLiteralConvertible
public protocol _FileReferenceLiteralConvertible {
public init(fileReferenceLiteral: String)
}
★ _ImageLiteralConvertible
public protocol _ImageLiteralConvertible {
public init(imageLiteral: String)
}
★ _Incrementable
public protocol _Incrementable : Equatable {
@warn_unused_result
public func successor() -> Self
}
★ _IntegerArithmeticType
public protocol _IntegerArithmeticType {
public static func addWithOverflow(lhs: Self, _ rhs: Self) -> (Self, overflow: Bool)
public static func subtractWithOverflow(lhs: Self, _ rhs: Self) -> (Self, overflow: Bool)
public static func multiplyWithOverflow(lhs: Self, _ rhs: Self) -> (Self, overflow: Bool)
public static func divideWithOverflow(lhs: Self, _ rhs: Self) -> (Self, overflow: Bool)
public static func remainderWithOverflow(lhs: Self, _ rhs: Self) -> (Self, overflow: Bool)
}
★ _IntegerType
public protocol _IntegerType : IntegerLiteralConvertible, CustomStringConvertible, Hashable, IntegerArithmeticType, BitwiseOperationsType, _Incrementable {
}
★ _MirrorType
public protocol _MirrorType {
public var value: Any { get }
public var valueType: Any.Type { get }
public var objectIdentifier: ObjectIdentifier? { get }
public var count: Int { get }
public subscript (i: Int) -> (String, _MirrorType) { get }
public var summary: String { get }
public var quickLookObject: PlaygroundQuickLook? { get }
public var disposition: _MirrorDisposition { get }
}
★ _NSArrayCoreType
@objc public protocol _NSArrayCoreType : _NSCopyingType, _NSFastEnumerationType {
public func objectAtIndex(index: Int) -> AnyObject
public func getObjects(_: UnsafeMutablePointer<AnyObject>, range: _SwiftNSRange)
public func countByEnumeratingWithState(state: UnsafeMutablePointer<_SwiftNSFastEnumerationState>, objects: UnsafeMutablePointer<AnyObject>, count: Int) -> Int
public var count: Int { get }
}
★ _NSCopyingType
@objc public protocol _NSCopyingType : _ShadowProtocol {
public func copyWithZone(zone: _SwiftNSZone) -> AnyObject
}
★ _NSDictionaryCoreType
@objc public protocol _NSDictionaryCoreType : _NSCopyingType, _NSFastEnumerationType {
public init(objects: UnsafePointer<AnyObject?>, forKeys: UnsafePointer<Void>, count: Int)
public var count: Int { get }
public func objectForKey(aKey: AnyObject) -> AnyObject?
public func keyEnumerator() -> _NSEnumeratorType
public func copyWithZone(zone: _SwiftNSZone) -> AnyObject
public func getObjects(objects: UnsafeMutablePointer<AnyObject>, andKeys keys: UnsafeMutablePointer<AnyObject>)
public func countByEnumeratingWithState(state: UnsafeMutablePointer<_SwiftNSFastEnumerationState>, objects: UnsafeMutablePointer<AnyObject>, count: Int) -> Int
}
★ _NSDictionaryType
@objc public protocol _NSDictionaryType : _NSDictionaryCoreType {
public func getObjects(objects: UnsafeMutablePointer<AnyObject>, andKeys keys: UnsafeMutablePointer<AnyObject>)
}
★ _NSEnumeratorType
@objc public protocol _NSEnumeratorType : _ShadowProtocol {
public init()
public func nextObject() -> AnyObject?
}
★ _NSFastEnumerationType
@objc public protocol _NSFastEnumerationType : _ShadowProtocol {
public func countByEnumeratingWithState(state: UnsafeMutablePointer<_SwiftNSFastEnumerationState>, objects: UnsafeMutablePointer<AnyObject>, count: Int) -> Int
}
★ _NSSetCoreType
@objc public protocol _NSSetCoreType : _NSCopyingType, _NSFastEnumerationType {
public init(objects: UnsafePointer<AnyObject?>, count: Int)
public var count: Int { get }
public func member(object: AnyObject) -> AnyObject?
public func objectEnumerator() -> _NSEnumeratorType
public func copyWithZone(zone: _SwiftNSZone) -> AnyObject
public func countByEnumeratingWithState(state: UnsafeMutablePointer<_SwiftNSFastEnumerationState>, objects: UnsafeMutablePointer<AnyObject>, count: Int) -> Int
}
★ _NSSetType
@objc public protocol _NSSetType : _NSSetCoreType {
}
★ _NSStringCoreType
@objc public protocol _NSStringCoreType : _NSCopyingType, _NSFastEnumerationType {
public func length() -> Int
public func characterAtIndex(index: Int) -> UInt16
}
★ _ObjectiveCBridgeable
public protocol _ObjectiveCBridgeable {
}
★ _PointerType
public protocol _PointerType {
}
★ _RandomAccessAmbiguity
public protocol _RandomAccessAmbiguity {
typealias Distance : _SignedIntegerType = Int
}
★ _Reflectable
public protocol _Reflectable {
}
★ _ReverseCollectionType
public protocol _ReverseCollectionType : CollectionType {
typealias Index : ReverseIndexType
typealias Base : CollectionType
}
★ _SequenceWrapperType
public protocol _SequenceWrapperType {
typealias Base : SequenceType
typealias Generator : GeneratorType = Self.Base.Generator
}
★ _ShadowProtocol
@objc public protocol _ShadowProtocol {
}
★ _SignedIntegerType
public protocol _SignedIntegerType : _IntegerType, SignedNumberType {
@warn_unused_result
public func toIntMax() -> IntMax
public init(_: IntMax)
}
★ _SinkType
public protocol _SinkType {
}
★ _Strideable
public protocol _Strideable {
typealias Stride : SignedNumberType
@warn_unused_result
public func distanceTo(other: Self) -> Self.Stride
@warn_unused_result
public func advancedBy(n: Self.Stride) -> Self
}
★ _StringElementType
public protocol _StringElementType {
}