Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
------------
Conformances
------------
protocol AbsoluteValuable
Conformances:
Comparable
IntegerLiteralConvertible
SignedNumberType
protocol AnyCollectionType
Conformances:
CollectionType
Indexable
SequenceType
protocol AnyObject <ObjC>
protocol ArrayLiteralConvertible
Associated types:
Element
protocol BidirectionalIndexType
Conformances:
ForwardIndexType
_Incrementable
protocol BitwiseOperationsType
protocol BooleanLiteralConvertible
Associated types:
BooleanLiteralType
protocol BooleanType
protocol CVarArgType
protocol CollectionType
Conformances:
Indexable
SequenceType
Associated types:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
protocol Comparable
Conformances:
Equatable
protocol CustomDebugStringConvertible
protocol CustomLeafReflectable
Conformances:
CustomReflectable
protocol CustomPlaygroundQuickLookable
protocol CustomReflectable
protocol CustomStringConvertible
protocol DictionaryLiteralConvertible
Associated types:
Key
Value
protocol Equatable
protocol ErrorType
protocol ExtendedGraphemeClusterLiteralConvertible
Conformances:
UnicodeScalarLiteralConvertible
Associated types:
ExtendedGraphemeClusterLiteralType
UnicodeScalarLiteralType [UnicodeScalarLiteralConvertible]
protocol FloatLiteralConvertible
Associated types:
FloatLiteralType
protocol FloatingPointType
Conformances:
Comparable
Equatable
Strideable
_Strideable
protocol ForwardIndexType
Conformances:
Equatable
_Incrementable
Associated types:
Distance : _SignedIntegerType = Int
protocol GeneratorType
Associated types:
Element
protocol Hashable
Conformances:
Equatable
protocol Indexable
Associated types:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Index : ForwardIndexType
protocol IntegerArithmeticType
Conformances:
Comparable
Equatable
_IntegerArithmeticType
protocol IntegerLiteralConvertible
Associated types:
IntegerLiteralType
protocol IntegerType
Conformances:
BidirectionalIndexType
BitwiseOperationsType
Comparable
CustomStringConvertible
ForwardIndexType
Hashable
IntegerArithmeticType
IntegerLiteralConvertible
RandomAccessIndexType
Strideable
_Incrementable
_IntegerType
_Strideable
protocol IntervalType
Associated types:
Bound : Comparable
protocol MirrorPathType
protocol MutableCollectionType
Conformances:
CollectionType
Indexable
SequenceType
protocol MutableSliceable
Conformances:
CollectionType
Indexable
MutableCollectionType
SequenceType
protocol NilLiteralConvertible
protocol OptionSetType
Conformances:
ArrayLiteralConvertible
Equatable
RawRepresentable
SetAlgebraType
Associated types:
Element = Self
Element [ArrayLiteralConvertible]
Element [SetAlgebraType]
RawValue [RawRepresentable]
protocol OutputStreamType
protocol RandomAccessIndexType
Conformances:
BidirectionalIndexType
Comparable
ForwardIndexType
Strideable
_Incrementable
_Strideable
protocol RangeReplaceableCollectionType
Conformances:
CollectionType
Indexable
SequenceType
protocol RawRepresentable
Associated types:
RawValue
protocol SequenceType
Associated types:
Element [GeneratorType]
Generator : GeneratorType
protocol SetAlgebraType
Conformances:
ArrayLiteralConvertible
Equatable
Associated types:
Element
Element [ArrayLiteralConvertible]
protocol SignedIntegerType
Conformances:
BidirectionalIndexType
BitwiseOperationsType
Comparable
CustomStringConvertible
Equatable
ForwardIndexType
Hashable
IntegerArithmeticType
IntegerLiteralConvertible
IntegerType
RandomAccessIndexType
SignedNumberType
Strideable
_Incrementable
_IntegerType
_SignedIntegerType
_Strideable
protocol SignedNumberType
Conformances:
Comparable
Equatable
IntegerLiteralConvertible
protocol Streamable
protocol Strideable
Conformances:
Comparable
Equatable
_Strideable
Associated types:
Stride : SignedNumberType
Stride : SignedNumberType [_Strideable]
protocol StringInterpolationConvertible
protocol StringLiteralConvertible
Conformances:
ExtendedGraphemeClusterLiteralConvertible
UnicodeScalarLiteralConvertible
Associated types:
ExtendedGraphemeClusterLiteralType [ExtendedGraphemeClusterLiteralConvertible]
StringLiteralType
UnicodeScalarLiteralType [UnicodeScalarLiteralConvertible]
protocol UnicodeCodecType
Associated types:
CodeUnit
protocol UnicodeScalarLiteralConvertible
Associated types:
UnicodeScalarLiteralType
protocol UnsignedIntegerType
Conformances:
BidirectionalIndexType
BitwiseOperationsType
Comparable
CustomStringConvertible
ForwardIndexType
Hashable
IntegerArithmeticType
IntegerLiteralConvertible
IntegerType
RandomAccessIndexType
Strideable
_DisallowMixedSignArithmetic
_Incrementable
_IntegerType
_Strideable
protocol _ArrayBufferType
Conformances:
CollectionType
MutableCollectionType
Associated types:
Element
protocol _ArrayType
Conformances:
ArrayLiteralConvertible
CollectionType
Indexable
MutableCollectionType
MutableSliceable
RangeReplaceableCollectionType
SequenceType
protocol _CVarArgAlignedType
Conformances:
CVarArgType
protocol _CVarArgPassedAsDouble
Conformances:
CVarArgType
protocol _CocoaStringType <ObjC>
protocol _CollectionWrapperType
Conformances:
_SequenceWrapperType
Associated types:
Base : CollectionType, SequenceType
Base : SequenceType [_SequenceWrapperType]
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType = Self.Base.Generator [_SequenceWrapperType]
Index : ForwardIndexType = Self.Base.Index
protocol _ColorLiteralConvertible
protocol _DestructorSafeContainer
protocol _DisallowMixedSignArithmetic
Conformances:
BitwiseOperationsType
CustomStringConvertible
Hashable
IntegerArithmeticType
IntegerLiteralConvertible
_Incrementable
_IntegerType
protocol _ImageLiteralConvertible
protocol _Incrementable
Conformances:
Equatable
protocol _IntegerArithmeticType
protocol _IntegerType
Conformances:
BitwiseOperationsType
Comparable
CustomStringConvertible
Equatable
Hashable
IntegerArithmeticType
IntegerLiteralConvertible
_Incrementable
_IntegerArithmeticType
protocol _MirrorType
protocol _NSArrayCoreType <ObjC>
Conformances:
_NSCopyingType
_NSFastEnumerationType
_ShadowProtocol
protocol _NSCopyingType <ObjC>
Conformances:
_ShadowProtocol
protocol _NSDictionaryCoreType <ObjC>
Conformances:
_NSCopyingType
_NSFastEnumerationType
_ShadowProtocol
protocol _NSDictionaryType <ObjC>
Conformances:
_NSCopyingType
_NSDictionaryCoreType
_NSFastEnumerationType
protocol _NSEnumeratorType <ObjC>
Conformances:
_ShadowProtocol
protocol _NSFastEnumerationType <ObjC>
Conformances:
_ShadowProtocol
protocol _NSSetCoreType <ObjC>
Conformances:
_NSCopyingType
_NSFastEnumerationType
_ShadowProtocol
protocol _NSSetType <ObjC>
Conformances:
_NSCopyingType
_NSFastEnumerationType
_NSSetCoreType
protocol _NSStringCoreType <ObjC>
Conformances:
_NSCopyingType
_NSFastEnumerationType
_ShadowProtocol
protocol _ObjectiveCBridgeable
protocol _PointerType
protocol _Reflectable
protocol _SequenceWrapperType
Associated types:
Base : SequenceType
Element [GeneratorType]
Generator : GeneratorType = Self.Base.Generator
protocol _ShadowProtocol <ObjC>
protocol _SignedIntegerType
Conformances:
BitwiseOperationsType
Comparable
CustomStringConvertible
Equatable
Hashable
IntegerArithmeticType
IntegerLiteralConvertible
SignedNumberType
_Incrementable
_IntegerType
protocol _SinkType
protocol _Strideable
Associated types:
Stride : SignedNumberType
protocol _StringElementType
---------------
Type Parameters
---------------
struct AnyBidirectionalCollection
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
AnyCollectionType
CollectionType
Indexable
SequenceType
struct AnyBidirectionalIndex
Conformances:
struct AnyBidirectionalIndex : ForwardIndexType
_Incrementable
Equatable
BidirectionalIndexType
struct AnyForwardCollection
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
AnyCollectionType
CollectionType
Indexable
SequenceType
struct AnyForwardIndex
Conformances:
struct AnyForwardIndex : ForwardIndexType
_Incrementable
Equatable
class AnyGenerator
Type Parameters
Element
Inherited Type Parameters:
Element
Conformances:
GeneratorType
struct AnyRandomAccessCollection
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
AnyCollectionType
CollectionType
Indexable
SequenceType
struct AnyRandomAccessIndex
Inherited Type Parameters:
Stride : SignedNumberType
Stride : SignedNumberType [_Strideable]
Conformances:
struct AnyRandomAccessIndex : ForwardIndexType
_Incrementable
Equatable
RandomAccessIndexType
BidirectionalIndexType
Strideable
Comparable
_Strideable
struct AnySequence
Type Parameters
Element
Inherited Type Parameters:
Element [GeneratorType]
Generator : GeneratorType
Conformances:
SequenceType
struct Array
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
MutableCollectionType
_DestructorSafeContainer
struct ArraySlice
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
Indexable
SequenceType
CollectionType
MutableCollectionType
_DestructorSafeContainer
struct AutoreleasingUnsafeMutablePointer
Type Parameters
Memory
Conformances:
Equatable
NilLiteralConvertible
_PointerType
enum Bit
Inherited Type Parameters:
Distance : _SignedIntegerType = Int
Stride : SignedNumberType
Stride : SignedNumberType [_Strideable]
Conformances:
enum Bit : Int
Comparable
RandomAccessIndexType
BidirectionalIndexType
ForwardIndexType
_Incrementable
Strideable
_Strideable
_Reflectable
struct COpaquePointer
Conformances:
struct COpaquePointer : Equatable
Hashable
NilLiteralConvertible
struct Character
Inherited Type Parameters:
UnicodeScalarLiteralType
Conformances:
struct Character : ExtendedGraphemeClusterLiteralConvertible
UnicodeScalarLiteralConvertible
Equatable
Hashable
Comparable
struct ClosedInterval
Type Parameters
Bound : Comparable
Inherited Type Parameters:
Bound : Comparable
Conformances:
IntervalType
Equatable
CustomStringConvertible
CustomDebugStringConvertible
_Reflectable
struct CollectionOfOne
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct ContiguousArray
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
MutableCollectionType
_DestructorSafeContainer
struct Dictionary
Type Parameters
Key : Hashable
Value
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
Key
SubSequence : Indexable, SequenceType = Slice<Self>
Value
Conformances:
CollectionType
Indexable
SequenceType
DictionaryLiteralConvertible
struct DictionaryGenerator
Type Parameters
Key : Hashable
Value
Inherited Type Parameters:
Element
Conformances:
GeneratorType
struct DictionaryIndex
Type Parameters
Key : Hashable
Value
Inherited Type Parameters:
Distance : _SignedIntegerType = Int
Conformances:
ForwardIndexType
_Incrementable
Equatable
Comparable
struct DictionaryLiteral
Type Parameters
Key
Value
Inherited Type Parameters:
Key
Value
Conformances:
DictionaryLiteralConvertible
struct EmptyCollection
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct EmptyGenerator
Type Parameters
Element
Inherited Type Parameters:
Element
Element [GeneratorType]
Generator : GeneratorType
Conformances:
GeneratorType
SequenceType
struct EnumerateGenerator
Type Parameters
Base : GeneratorType
Inherited Type Parameters:
Element
Element [GeneratorType]
Generator : GeneratorType
Conformances:
GeneratorType
SequenceType
struct EnumerateSequence
Type Parameters
Base : SequenceType
Inherited Type Parameters:
Element [GeneratorType]
Generator : GeneratorType
Conformances:
SequenceType
struct FilterCollection
Type Parameters
Base : CollectionType
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct FilterCollectionIndex
Type Parameters
Base : CollectionType
Inherited Type Parameters:
Distance : _SignedIntegerType = Int
Conformances:
ForwardIndexType
_Incrementable
Equatable
struct FilterGenerator
Type Parameters
Base : GeneratorType
Inherited Type Parameters:
Element
Element [GeneratorType]
Generator : GeneratorType
Conformances:
GeneratorType
SequenceType
struct FilterSequence
Type Parameters
Base : SequenceType
Inherited Type Parameters:
Element [GeneratorType]
Generator : GeneratorType
Conformances:
SequenceType
struct GeneratorOfOne
Type Parameters
Element
Inherited Type Parameters:
Element
Element [GeneratorType]
Generator : GeneratorType
Conformances:
GeneratorType
SequenceType
struct GeneratorSequence
Type Parameters
Base : GeneratorType
Inherited Type Parameters:
Element
Element [GeneratorType]
Generator : GeneratorType
Conformances:
GeneratorType
SequenceType
struct HalfOpenInterval
Type Parameters
Bound : Comparable
Inherited Type Parameters:
Bound : Comparable
Conformances:
IntervalType
Equatable
CustomStringConvertible
CustomDebugStringConvertible
_Reflectable
enum ImplicitlyUnwrappedOptional
Type Parameters
T
Conformances:
_Reflectable
NilLiteralConvertible
struct IndexingGenerator
Type Parameters
Elements : Indexable
Inherited Type Parameters:
Element
Element [GeneratorType]
Generator : GeneratorType
Conformances:
GeneratorType
SequenceType
struct Int
Conformances:
struct Int : Equatable
_SignedIntegerType
Comparable
_IntegerType
IntegerArithmeticType
_IntegerArithmeticType
SignedIntegerType
IntegerType
struct Int16
Conformances:
struct Int16 : SignedIntegerType
IntegerType
Equatable
Comparable
_IntegerType
IntegerArithmeticType
_IntegerArithmeticType
_SignedIntegerType
struct Int32
Conformances:
struct Int32 : SignedIntegerType
IntegerType
Equatable
Comparable
_IntegerType
IntegerArithmeticType
_IntegerArithmeticType
_SignedIntegerType
struct Int64
Conformances:
struct Int64 : _SignedIntegerType
Comparable
Equatable
_IntegerType
IntegerArithmeticType
_IntegerArithmeticType
SignedIntegerType
IntegerType
struct Int8
Conformances:
struct Int8 : SignedIntegerType
IntegerType
Equatable
Comparable
_IntegerType
IntegerArithmeticType
_IntegerArithmeticType
_SignedIntegerType
struct LazyBidirectionalCollection
Type Parameters
Base : CollectionType where Base.Index : BidirectionalIndexType
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct LazyForwardCollection
Type Parameters
Base : CollectionType where Base.Index : ForwardIndexType
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct LazyRandomAccessCollection
Type Parameters
Base : CollectionType where Base.Index : RandomAccessIndexType
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct LazySequence
Type Parameters
Base : SequenceType
Inherited Type Parameters:
Element [GeneratorType]
Generator : GeneratorType
Conformances:
SequenceType
class ManagedBuffer
Type Parameters
Value
Element
Conformances:
ManagedProtoBuffer<Value
Element>
struct ManagedBufferPointer
Type Parameters
Value
Element
Conformances:
Equatable
class ManagedProtoBuffer
Type Parameters
Value
Element
Conformances:
NonObjectiveCBase
struct MapCollection
Type Parameters
Base : CollectionType
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct MapGenerator
Type Parameters
Base : GeneratorType
Element
Inherited Type Parameters:
Element
Element [GeneratorType]
Generator : GeneratorType
Conformances:
GeneratorType
SequenceType
struct MapSequence
Type Parameters
Base : SequenceType
Element
Inherited Type Parameters:
Element [GeneratorType]
Generator : GeneratorType
Conformances:
SequenceType
struct ObjectIdentifier
Conformances:
struct ObjectIdentifier : Hashable
Equatable
Comparable
enum Optional
Type Parameters
T
Conformances:
_Reflectable
NilLiteralConvertible
struct PermutationGenerator
Type Parameters
C : CollectionType
Indices : SequenceType where C.Index == Indices.Generator.Element
Inherited Type Parameters:
Element
Element [GeneratorType]
Generator : GeneratorType
Conformances:
GeneratorType
SequenceType
struct Range
Type Parameters
Element : ForwardIndexType
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
Equatable
CollectionType
Indexable
SequenceType
CustomStringConvertible
CustomDebugStringConvertible
struct RangeGenerator
Type Parameters
Element : ForwardIndexType
Inherited Type Parameters:
Element
Element [GeneratorType]
Generator : GeneratorType
Conformances:
GeneratorType
SequenceType
struct Repeat
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct ReverseCollection
Type Parameters
Base : CollectionType where Base.Index : BidirectionalIndexType
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct ReverseIndex
Type Parameters
Base : BidirectionalIndexType
Inherited Type Parameters:
Distance : _SignedIntegerType = Int
Conformances:
ForwardIndexType
_Incrementable
Equatable
BidirectionalIndexType
struct ReverseRandomAccessCollection
Type Parameters
Base : CollectionType where Base.Index : RandomAccessIndexType
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct ReverseRandomAccessIndex
Type Parameters
Base : RandomAccessIndexType
Inherited Type Parameters:
Distance : _SignedIntegerType = Int
Stride : SignedNumberType
Stride : SignedNumberType [_Strideable]
Conformances:
ForwardIndexType
_Incrementable
Equatable
RandomAccessIndexType
BidirectionalIndexType
Strideable
Comparable
_Strideable
struct Set
Type Parameters
Element : Hashable
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
Hashable
Equatable
CollectionType
Indexable
SequenceType
ArrayLiteralConvertible
struct SetGenerator
Type Parameters
Element : Hashable
Inherited Type Parameters:
Element
Conformances:
GeneratorType
struct SetIndex
Type Parameters
Element : Hashable
Inherited Type Parameters:
Distance : _SignedIntegerType = Int
Conformances:
ForwardIndexType
_Incrementable
Equatable
Comparable
struct Slice
Type Parameters
Base : Indexable
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
Indexable
SequenceType
CollectionType
struct StaticString
Inherited Type Parameters:
ExtendedGraphemeClusterLiteralType
ExtendedGraphemeClusterLiteralType [ExtendedGraphemeClusterLiteralConvertible]
StringLiteralType
UnicodeScalarLiteralType [UnicodeScalarLiteralConvertible]
Conformances:
struct StaticString : UnicodeScalarLiteralConvertible
ExtendedGraphemeClusterLiteralConvertible
StringLiteralConvertible
CustomStringConvertible
CustomDebugStringConvertible
_Reflectable
struct StrideThrough
Type Parameters
Element : Strideable
Inherited Type Parameters:
Element [GeneratorType]
Generator : GeneratorType
Conformances:
SequenceType
struct StrideThroughGenerator
Type Parameters
Element : Strideable
Inherited Type Parameters:
Element
Conformances:
GeneratorType
struct StrideTo
Type Parameters
Element : Strideable
Inherited Type Parameters:
Element [GeneratorType]
Generator : GeneratorType
Conformances:
SequenceType
struct StrideToGenerator
Type Parameters
Element : Strideable
Inherited Type Parameters:
Element
Conformances:
GeneratorType
struct UInt
Inherited Type Parameters:
IntegerLiteralType
Conformances:
struct UInt : UnsignedIntegerType
IntegerType
Equatable
Comparable
_IntegerType
IntegerArithmeticType
_IntegerArithmeticType
IntegerLiteralConvertible
_DisallowMixedSignArithmetic
struct UInt16
Inherited Type Parameters:
IntegerLiteralType
Conformances:
struct UInt16 : UnsignedIntegerType
IntegerType
Equatable
Comparable
_IntegerType
IntegerArithmeticType
_IntegerArithmeticType
IntegerLiteralConvertible
_DisallowMixedSignArithmetic
struct UInt32
Inherited Type Parameters:
IntegerLiteralType
Conformances:
struct UInt32 : UnsignedIntegerType
IntegerType
Equatable
Comparable
_IntegerType
IntegerArithmeticType
_IntegerArithmeticType
IntegerLiteralConvertible
_DisallowMixedSignArithmetic
struct UInt64
Inherited Type Parameters:
IntegerLiteralType
Conformances:
struct UInt64 : UnsignedIntegerType
IntegerType
Equatable
Comparable
_IntegerType
IntegerArithmeticType
_IntegerArithmeticType
IntegerLiteralConvertible
_DisallowMixedSignArithmetic
struct UInt8
Inherited Type Parameters:
IntegerLiteralType
Conformances:
struct UInt8 : UnsignedIntegerType
IntegerType
Equatable
Comparable
_IntegerType
IntegerArithmeticType
_IntegerArithmeticType
IntegerLiteralConvertible
_DisallowMixedSignArithmetic
struct UTF16
Conformances:
struct UTF16 : UnicodeCodecType
struct UTF32
Conformances:
struct UTF32 : UnicodeCodecType
struct UTF8
Conformances:
struct UTF8 : UnicodeCodecType
struct UnicodeScalar
Conformances:
struct UnicodeScalar : UnicodeScalarLiteralConvertible
struct Unmanaged
Type Parameters
Instance
struct UnsafeBufferPointer
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
CollectionType
Indexable
SequenceType
struct UnsafeBufferPointerGenerator
Type Parameters
Element
Inherited Type Parameters:
Element
Element [GeneratorType]
Generator : GeneratorType
Conformances:
GeneratorType
SequenceType
struct UnsafeMutableBufferPointer
Type Parameters
Element
Inherited Type Parameters:
Distance : _SignedIntegerType = Int [ForwardIndexType]
Element [GeneratorType]
Generator : GeneratorType
Generator : GeneratorType = IndexingGenerator<Self>
Generator : GeneratorType [SequenceType]
Index : ForwardIndexType
Index : ForwardIndexType [Indexable]
SubSequence : Indexable, SequenceType = Slice<Self>
Conformances:
MutableCollectionType
CollectionType
Indexable
SequenceType
struct UnsafeMutablePointer
Type Parameters
Memory
Inherited Type Parameters:
Distance : _SignedIntegerType = Int
Stride : SignedNumberType
Stride : SignedNumberType [_Strideable]
Conformances:
RandomAccessIndexType
BidirectionalIndexType
ForwardIndexType
_Incrementable
Equatable
Strideable
Comparable
_Strideable
Hashable
NilLiteralConvertible
_PointerType
struct UnsafePointer
Type Parameters
Memory
Inherited Type Parameters:
Distance : _SignedIntegerType = Int
Stride : SignedNumberType
Stride : SignedNumberType [_Strideable]
Conformances:
RandomAccessIndexType
BidirectionalIndexType
ForwardIndexType
_Incrementable
Equatable
Strideable
Comparable
_Strideable
Hashable
NilLiteralConvertible
_PointerType
struct Zip2Generator
Type Parameters
Generator1 : GeneratorType
Generator2 : GeneratorType
Inherited Type Parameters:
Element
Conformances:
GeneratorType
struct Zip2Sequence
Type Parameters
Sequence1 : SequenceType
Sequence2 : SequenceType
Inherited Type Parameters:
Element [GeneratorType]
Generator : GeneratorType
Conformances:
SequenceType
/*
http://ericasadun.com
*/
import Foundation
// Replace this with a path to the standard library on your system
//public let stdlpath = NSBundle.mainBundle().pathForResource("stdl", ofType: "txt")!
public let stdlpath = "/Users/ericasadun/Desktop/Playgrounds/Cookbook Playgrounds/0 - C05/FetchProtocolTypes/FetchProtocolTypes/stdl.txt"
public let contents = try! String(contentsOfFile: stdlpath)
// Storage for the items of interest
var conformanceDictionary = [String:[String]]()
var associatedConformanceDictionary = [String:[String]]()
var typeDictionary = [String:[String]]()
var fullAssociatedTypes = [String:[String]]()
var objc = Set<String>()
func ProtocolReport() {
/// Fetch a full protocol declaration from the library
func FetchProtocol(contents: String) -> Range<String.Index>? {
return FetchScope(contents, prefixRex: "\n(@objc\\s)?protocol[^\\{]*\\{")
}
/// Return the name of a protocol
func FetchProtocolName(protocolString: String) -> String {
return ExtractStringContent(protocolString, startRex: "\n(@objc\\s+)?protocol\\s*", endRex: "[\\s:]")
}
/// Return a list of ancestor protocols that are conformed to
func FetchProtocolConformance(protocolString: String) -> [String] {
var p = protocolString
p = SubstringToEndOfRex(p, rex:"protocol[^\\{]*\\{")
if RexRange(p, ":") == nil {return []}
p = SubstringToEndOfRex(p, rex: ":.*\\{")
p = SubstringFromStartOfRex(p, rex: ":.*\\{")
p = (p.butFirst?.butLast)!
return ArrayFromCommaDelineatedString(p)
}
/// Locate associated types for the protocol
func FetchAssociatedTypes(protocolString: String) -> [String] {
var p = protocolString
var types = [String]()
repeat {
if var typealiasRange = RexRange(p, "typealias .*\n") {
typealiasRange.startIndex = advance(typealiasRange.startIndex, "typealias ".characters.count)
types.append(p.substringWithRange(typealiasRange).trimmed)
p = p.substringFromIndex(typealiasRange.endIndex)
} else {
p = ""
}
} while !p.isEmpty
return types
}
/// Find conformances for associated types
func FetchAssociatedConformances(associatedString: String) -> [String] {
var a = associatedString
if let matchRange = RexRange(a, ":") {
a = a.substringFromIndex(matchRange.endIndex)
} else {
return [String]()
}
if let matchRange = RexRange(a, "=") {
a = a.substringToIndex(matchRange.startIndex)
}
return ArrayFromCommaDelineatedString(a)
}
PrintHeading("Conformances", first: true)
// Iteratively fetch each protocol, log the conformances, types, and objc-compliance
var c = contents
repeat {
if let protocolRange = FetchProtocol(c) {
// Consume a protocol
let protocolString = c.substringWithRange(protocolRange)
c = c.substringFromIndex(protocolRange.endIndex)
// Fetch the protocol's name
let name = FetchProtocolName(protocolString)
// Is it objc-conformant?
if protocolString.hasPrefix("\n@objc") {objc.insert(name)}
// Fetch direct conformances
let conformants = FetchProtocolConformance(protocolString)
conformanceDictionary[name] = conformants
// Fetch associated types
let associatedTypes = FetchAssociatedTypes(protocolString)
typeDictionary[name] = associatedTypes
// Fetch associated conformances and add to associated dictionary
for associatedType in associatedTypes {
let associatedConformances = FetchAssociatedConformances(associatedType)
associatedConformanceDictionary[name] = conformanceDictionary[name]! + associatedConformances
}
} else {
c = ""
}
} while !c.isEmpty
// Integrate ancestor details into child protocol lists until stable
var unchanged = true
repeat {
unchanged = true
for (key, conformances) in conformanceDictionary {
let current = conformances // fetch current conformances
for item in current {
if let inheritedConformances = conformanceDictionary[item] {
for inherited in inheritedConformances {
if !current.contains(inherited) {
unchanged = false
conformanceDictionary[key]!.append(inherited)
}
}
}
}
}
} while unchanged
// Repeat for associated conformances (from associated types)
unchanged = true
repeat {
unchanged = true
for (key, conformances) in associatedConformanceDictionary {
let current = conformances
for item in current {
if let inheritedConformances = associatedConformanceDictionary[item] {
for inherited in inheritedConformances {
if !current.contains(inherited) {
unchanged = false
associatedConformanceDictionary[key]!.append(inherited)
}
}
}
}
}
} while unchanged
// Unique and sort the protocol names
var keys = Array(conformanceDictionary.keys)
keys = uniq(keys)
keys.sortInPlace()
// List protocols
for key in keys {
var conformances = conformanceDictionary[key]!
print("protocol \(key)", appendNewline:false)
if objc.contains(key) {
print(" <ObjC>", appendNewline:false)
}
print("")
// List conformances
if !conformances.isEmpty {
conformances = uniq(conformances)
conformances.sortInPlace()
print(String.pattern(4, " ")+"Conformances:")
for conformance in conformances {
print(String.pattern(8, " ") + "\(conformance)")
}
}
// Find associated types both directly and for ancestors
var aTypes = [String]()
if let types = typeDictionary[key] {
for associatedType in types {
aTypes.append(associatedType)
}
}
// Now uses associated conformances over conformances
if let conformances = associatedConformanceDictionary[key] {
for conformance in conformances {
if let types = typeDictionary[conformance] {
for associatedType in types {
aTypes.append(associatedType + " [\(conformance)]")
}
}
}
}
// List associated types
if !aTypes.isEmpty {
aTypes = uniq(aTypes)
aTypes.sortInPlace()
fullAssociatedTypes[key] = aTypes
print(String.pattern(4, " ") + "Associated types:")
for aType in aTypes {
print(String.pattern(8, " ") + "\(aType)")
}
}
// Add space between protocol listings
print("")
}
}
func TypeParameterReport() {
/// Fetch a full construct declaration from the library
func FetchConstruct(contents: String) -> Range<String.Index>? {
return FetchScope(contents, prefixRex: "\n(@objc\\s)?(class|struct|enum)[^\\{]*\\{")
}
/// Return the name of a construct
func FetchConstructName(constructString: String) -> String {
return ExtractStringContent(constructString, startRex: "\n(@objc\\s+)?(class|struct|enum)\\s*", endRex: "[<\\s:]")
}
/// Return a list of ancestor protocols that are conformed to
func FetchConstructConformance(constructString: String) -> [String] {
var c = constructString
c = SubstringToEndOfRex(c, rex:"(class|struct|enum)[^\\{]*\\{")
if RexRange(c, ">\\s*:\\s*") != nil {
c = SubstringFromEndOfRex(c, rex: ">\\s*:\\s*")
} else if RexRange(c, ":") == nil {
return []
}
c = (c.butLast)!
return ArrayFromCommaDelineatedString(c)
}
/// Find type parameters for structs, enums, classes
PrintHeading("Type Parameters")
var c = contents
repeat {
if let range = FetchConstruct(c) {
// Consume a construct
let constructString = c.substringWithRange(range)
c = c.substringFromIndex(range.endIndex)
// Fetch the construct's name
let name = FetchConstructName(constructString)
// Anything to report?
let conformances = FetchConstructConformance(constructString)
let usesParameters = RexRange(constructString, "\(name)<") != nil
var associatedTypes = Set<String>()
for conformance in conformances {
if let t = fullAssociatedTypes[conformance] {
associatedTypes = associatedTypes.union(t)
}
}
if conformances.isEmpty && associatedTypes.isEmpty && !usesParameters {continue}
if let typeRange = RexRange(constructString, "(class|struct|enum)") {
let typeString = constructString.substringWithRange(typeRange)
print("\(typeString) ", appendNewline: false)
}
print(name)
// Does the type use parameters?
if usesParameters {
// Fetch the construct's type parameters
let typeParameterString = ExtractStringContent(constructString, startRex: "<", endRex: ">")
let items = ArrayFromCommaDelineatedString(typeParameterString)
print(String.pattern(4, " ") + "Type Parameters")
for item in items {print(String.pattern(8, " "), appendNewline: false); print(item)}
print("")
}
// Type Aliases...
if !associatedTypes.isEmpty {
print(String.pattern(4, " ") + "Inherited Type Parameters:")
for associatedType in Array(associatedTypes).sort() {
print(String.pattern(8, " "), appendNewline: false)
print(associatedType)
}
print("")
}
// Conforms to...
if !conformances.isEmpty {
print(String.pattern(4, " ") + "Conformances:")
for conformance in conformances {
print(String.pattern(8, " "), appendNewline: false)
print(conformance)
}
}
} else {
c = ""
}
print("")
} while !c.isEmpty
}
/// MARK: Main
ProtocolReport()
TypeParameterReport()
/*
http://ericasadun.com
*/
import Foundation
/// Remove duplicate elements from an array
/// There are better ways to do this (see Chapter 5) but this will do for now
public func uniq<S: SequenceType, T: Hashable where S.Generator.Element == T>(source: S) -> [T] {
var uniqueItems = Set<T>()
for element in source {uniqueItems.insert(element)}
return Array(uniqueItems)
}
/// Print a heading for a section
public func PrintHeading(string: String, first: Bool = false) {
let highlightCharacter = Character("-")
if !first {print("")}
print(String(count:string.characters.count, repeatedValue:highlightCharacter))
print(string)
print(String(count:string.characters.count, repeatedValue:highlightCharacter))
print("")
}
/*
http://ericasadun.com
*/
import Foundation
extension String {
public var first: String? {return isEmpty ? nil : self[startIndex..<startIndex.successor()]}
public var last: String? {return isEmpty ? nil : self[endIndex.predecessor()..<endIndex]}
public var butFirst: String? {return isEmpty ? nil : String(dropFirst(self.characters))}
public var butLast: String? {return isEmpty ? nil : String(dropLast(self.characters))}
public var trimmed: String {return stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())}
public static func pattern(count: Int, _ s: String) -> String {
if let c = s.characters.first {
return String(count: count, repeatedValue: c)
} else { fatalError("Character not supplied to String.pattern")}
}
}
/// Returns an optional range where a regular expression is first matched within a string
public func RexRange(s: String, _ rex: String) -> Range<String.Index>? {
return s.rangeOfString(rex,
options: [.RegularExpressionSearch],
range: s.startIndex..<s.endIndex,
locale: nil)
}
/// Extract an entire scope from a match point by pairing braces
public func FetchScope(contents: String, prefixRex: String) -> Range<String.Index>? {
if let matchRange = RexRange(contents, prefixRex) {
var index = matchRange.endIndex; var count = 1; var ii = 0
let chars = Array(contents.substringFromIndex(index).characters)
while count > 0 {
if ii < chars.count {
let testChar = chars[ii++]
if testChar == "{" {count++}
if testChar == "}" {count--}
index = advance(index, 1)
} else {
print("Ran out of characters")
return nil
}
}
return matchRange.startIndex..<index
}
return nil
}
/// Substring from start of Rex
public func SubstringFromStartOfRex(string: String, rex: String) -> String {
if let matchRange = RexRange(string, rex) {
return string.substringFromIndex(matchRange.startIndex)
} else {fatalError()}
// } else {return string} // previously fatal
}
/// Substring to start of Rex
public func SubstringToStartOfRex(string: String, rex: String) -> String {
if let matchRange = RexRange(string, rex) {
return string.substringToIndex(matchRange.startIndex)
} else {fatalError()}
// } else {return string} // previously fatal
}
/// Substring from end of Rex
public func SubstringFromEndOfRex(string: String, rex: String) -> String {
if let matchRange = RexRange(string, rex) {
return string.substringFromIndex(matchRange.endIndex)
} else {fatalError()}
// } else {return string} // previously fatal
}
/// Substring to end of Rex
public func SubstringToEndOfRex(string: String, rex: String) -> String {
if let matchRange = RexRange(string, rex) {
return string.substringToIndex(matchRange.endIndex)
} else {fatalError()}
// } else {return string} // previously fatal
}
/// Extract string between starting.end and ending.start rexes
public func ExtractStringContent(string: String, startRex: String, endRex: String) -> String {
var s = string
s = SubstringFromEndOfRex(s, rex: startRex)
s = SubstringToStartOfRex(s, rex: endRex)
return s
}
/// Transform comma-delineated string to trimmed string array
public func ArrayFromCommaDelineatedString(string: String) -> [String] {
let members = string.componentsSeparatedByString(",")
return members.map({$0.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())})
}
@damianesteban

This comment has been minimized.

Copy link

@damianesteban damianesteban commented Aug 3, 2015

I'll be keeping these nearby for reference. Thank you :)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment