Protocol

Protocol.md

Protocol List

★ 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 {
}