Swift API Manual
Function
Section
Alias
- Any = protocol<>
- AnyClass = AnyObject.Type
- BooleanLiteralType = Bool
- CBool = Bool
- CChar = Int8
- CChar16 = UInt16
- CChar32 = UnicodeScalar
- CDouble = Double
- CFloat = Float
- CInt = Int32
- CLong = Int
- CLongLong = Int64
- CShort = Int16
- CSignedChar = Int8
- CUnsignedChar = UInt8
- CUnsignedInt = UInt32
- CUnsignedLong = UInt
- CUnsignedLongLong = UInt64
- CUnsignedShort = UInt16
- CWideChar = UnicodeScalar
- ExtendedGraphemeClusterType = String
- Float32 = Float
- Float64 = Double
- FloatLiteralType = Double
- IntMax = Int64
- IntegerLiteralType = Int
- StringLiteralType = String
- UIntMax = UInt64
- UnicodeScalarType = String
- Void = ()
- _ArrayBufferType.Element
- _ArrayBufferType.Generator : GeneratorType = IndexingGenerator<Self>
- _ArrayBufferType.SubSequence : Indexable, SequenceType = Slice<Self>
- _ArrayBufferType.Index : ForwardIndexType
- _ArrayType.Element
- _ArrayType.Generator : GeneratorType = IndexingGenerator<Self>
- _ArrayType.SubSequence : Indexable, SequenceType = Slice<Self>
- _ArrayType.Index : ForwardIndexType
- _CollectionWrapperType.Base : CollectionType
- _CollectionWrapperType.Index : ForwardIndexType = Self.Base.Index
- _CollectionWrapperType.Generator : GeneratorType = Self.Base.Generator
- _DisallowMixedSignArithmetic.IntegerLiteralType
- _IntegerType.IntegerLiteralType
- _RandomAccessAmbiguity.Distance : _SignedIntegerType = Int
- _ReverseCollectionType.Index : ReverseIndexType
- _ReverseCollectionType.Base : CollectionType
- _ReverseCollectionType.Generator : GeneratorType = IndexingGenerator<Self>
- _ReverseCollectionType.SubSequence : Indexable, SequenceType = Slice<Self>
- _SequenceWrapperType.Base : SequenceType
- _SequenceWrapperType.Generator : GeneratorType = Self.Base.Generator
- _SignedIntegerType.IntegerLiteralType
- AbsoluteValuable.IntegerLiteralType
- AnyCollectionType.Generator : GeneratorType = IndexingGenerator<Self>
- AnyCollectionType.SubSequence : Indexable, SequenceType = Slice<Self>
- AnyCollectionType.Index : ForwardIndexType
- ArrayLiteralConvertible.Element
- BidirectionalIndexType.Distance : _SignedIntegerType = Int
- BooleanLiteralConvertible.BooleanLiteralType
- CollectionType.Generator : GeneratorType = IndexingGenerator<Self>
- CollectionType.SubSequence : Indexable, SequenceType = Slice<Self>
- CollectionType.Index : ForwardIndexType
- DictionaryLiteralConvertible.Key
- DictionaryLiteralConvertible.Value
- ExtendedGraphemeClusterLiteralConvertible.ExtendedGraphemeClusterLiteralType
- ExtendedGraphemeClusterLiteralConvertible.UnicodeScalarLiteralType
- FloatingPointType.Stride : SignedNumberType
- FloatLiteralConvertible.FloatLiteralType
- ForwardIndexType.Distance : _SignedIntegerType = Int
- GeneratorType.Element
- Indexable.Index : ForwardIndexType
- IntegerLiteralConvertible.IntegerLiteralType
- IntegerType.Distance : _SignedIntegerType = Int
- IntegerType.IntegerLiteralType
- IntegerType.Stride : SignedNumberType
- IntervalType.Bound : Comparable
- LazyCollectionType.Elements : CollectionType = Self
- LazyCollectionType.Generator : GeneratorType = IndexingGenerator<Self>
- LazyCollectionType.SubSequence : Indexable, SequenceType = Slice<Self>
- LazyCollectionType.Index : ForwardIndexType
- LazySequenceType.Elements : SequenceType = Self
- LazySequenceType.Generator : GeneratorType
- LazySequenceType.SubSequence
- MutableCollectionType.SubSequence : CollectionType = MutableSlice<Self>
- MutableCollectionType.Generator : GeneratorType = IndexingGenerator<Self>
- MutableCollectionType.Index : ForwardIndexType
- MutableIndexable.Index : ForwardIndexType
- MutableSliceable.Generator : GeneratorType = IndexingGenerator<Self>
- MutableSliceable.SubSequence : Indexable, SequenceType = Slice<Self>
- MutableSliceable.Index : ForwardIndexType
- OptionSetType.Element = Self
- OptionSetType.RawValue
- RandomAccessIndexType.Distance : _SignedIntegerType = Int
- RandomAccessIndexType.Stride : SignedNumberType
- RangeReplaceableCollectionType.Generator : GeneratorType = IndexingGenerator<Self>
- RangeReplaceableCollectionType.SubSequence : Indexable, SequenceType = Slice<Self>
- RangeReplaceableCollectionType.Index : ForwardIndexType
- RawRepresentable.RawValue
- ReverseIndexType.Base : BidirectionalIndexType
- ReverseIndexType.Distance : _SignedIntegerType = Self.Base.Distance
- SequenceType.Generator : GeneratorType
- SequenceType.SubSequence
- SetAlgebraType.Element
- SignedIntegerType.Distance : _SignedIntegerType = Int
- SignedIntegerType.IntegerLiteralType
- SignedIntegerType.Stride : SignedNumberType
- SignedNumberType.IntegerLiteralType
- Strideable.Stride : SignedNumberType
- StringLiteralConvertible.StringLiteralType
- StringLiteralConvertible.ExtendedGraphemeClusterLiteralType
- StringLiteralConvertible.UnicodeScalarLiteralType
- UnicodeCodecType.CodeUnit
- UnicodeScalarLiteralConvertible.UnicodeScalarLiteralType
- UnsignedIntegerType.Distance : _SignedIntegerType = Int
- UnsignedIntegerType.IntegerLiteralType
- UnsignedIntegerType.Stride : SignedNumberType
- AnyBidirectionalCollection.Generator = AnyGenerator<Element>
- AnyBidirectionalCollection.Element = Element
- AnyBidirectionalCollection.Index = AnyBidirectionalIndex
- AnyBidirectionalCollection.SubSequence = Slice<AnyBidirectionalCollection<Element>>
- AnyBidirectionalIndex.Distance = IntMax
- AnyForwardCollection.Generator = AnyGenerator<Element>
- AnyForwardCollection.Element = Element
- AnyForwardCollection.Index = AnyForwardIndex
- AnyForwardCollection.SubSequence = Slice<AnyForwardCollection<Element>>
- AnyForwardIndex.Distance = IntMax
- AnyGenerator.Element = Generator.Element
- AnyRandomAccessCollection.Generator = AnyGenerator<Element>
- AnyRandomAccessCollection.Element = Element
- AnyRandomAccessCollection.Index = AnyRandomAccessIndex
- AnyRandomAccessCollection.SubSequence = Slice<AnyRandomAccessCollection<Element>>
- AnyRandomAccessIndex.Distance = IntMax
- AnySequence.Generator = AnyGenerator<Element>
- AnySequence.Element = Generator.Element
- Array.Generator = IndexingGenerator<Array<Element>>
- Array.Element = Element
- Array.Index = Int
- Array.SubSequence = ArraySlice<Element>
- ArraySlice.Generator = IndexingGenerator<ArraySlice<Element>>
- ArraySlice.Element = Element
- ArraySlice.Index = Int
- ArraySlice.SubSequence = ArraySlice<Element>
- Bit.Distance = Int
- CollectionOfOne.Index = Bit
- CollectionOfOne.Generator = GeneratorOfOne<Element>
- CollectionOfOne.Element = Element
- CollectionOfOne.Index = Index
- CollectionOfOne.SubSequence = Slice<CollectionOfOne<Element>>
- ContiguousArray.Generator = IndexingGenerator<ContiguousArray<Element>>
- ContiguousArray.Element = Element
- ContiguousArray.Index = Int
- ContiguousArray.SubSequence = ArraySlice<Element>
- Dictionary.Element = (Key, Value)
- Dictionary.Index = DictionaryIndex<Key, Value>
- Dictionary.Generator = DictionaryGenerator<Key, Value>
- Dictionary.SubSequence = Slice<Dictionary<Key, Value>>
- DictionaryLiteral.Element = (Key, Value)
- DictionaryLiteral.Generator = IndexingGenerator<DictionaryLiteral<Key, Value>>
- DictionaryLiteral.Index = Int
- DictionaryLiteral.SubSequence = Slice<DictionaryLiteral<Key, Value>>
- EmptyCollection.Index = Int
- EmptyCollection.Generator = EmptyGenerator<Element>
- EmptyCollection.Element = Element
- EmptyCollection.Index = Index
- EmptyCollection.SubSequence = Slice<EmptyCollection<Element>>
- EmptyGenerator.Element = Generator.Element
- EnumerateGenerator.Element = (index: Int, element: Base.Element)
- EnumerateSequence.Generator = EnumerateGenerator<Base.Generator>
- EnumerateSequence.Element = Generator.Element
- FlattenBidirectionalCollection.Index = FlattenBidirectionalCollectionIndex<Base>
- FlattenBidirectionalCollection.Generator = FlattenGenerator<Base.Generator>
- FlattenBidirectionalCollection.Element = Base.Generator.Element.Generator.Element
- FlattenBidirectionalCollection.SubSequence = Slice<FlattenBidirectionalCollection<Base>>
- FlattenCollection.Index = FlattenCollectionIndex<Base>
- FlattenCollection.Generator = FlattenGenerator<Base.Generator>
- FlattenCollection.Element = Base.Generator.Element.Generator.Element
- FlattenCollection.SubSequence = Slice<FlattenCollection<Base>>
- FlattenGenerator.Element = Generator.Element
- FlattenSequence.Generator = FlattenGenerator<Base.Generator>
- FlattenSequence.Element = Generator.Element
- GeneratorOfOne.Element = Generator.Element
- GeneratorSequence.Element = Generator.Element
- IndexingGenerator.Element = Generator.Element
- Int.Distance = Int
- Int16.Distance = Int
- Int32.Distance = Int
- Int64.Distance = Int
- Int8.Distance = Int
- JoinSequence.Generator = JoinGenerator<Base.Generator>
- JoinSequence.Element = Generator.Element
- LazyCollection.Elements = Base
- LazyCollection.Index = Base.Index
- LazyCollection.Generator = Base.Generator
- LazyCollection.Element = Base.Generator.Element
- LazyCollection.SubSequence = LazyCollection<Slice<Base>>
- LazyFilterCollection.Index = LazyFilterIndex<Base>
- LazyFilterCollection.Generator = LazyFilterGenerator<Base.Generator>
- LazyFilterCollection.Element = Base.Generator.Element
- LazyFilterCollection.SubSequence = Slice<LazyFilterCollection<Base>>
- LazyFilterGenerator.Element = Generator.Element
- LazyFilterSequence.Generator = LazyFilterGenerator<Base.Generator>
- LazyFilterSequence.Element = Generator.Element
- LazyMapCollection.Index = Base.Index
- LazyMapCollection.Generator = LazyMapGenerator<Base.Generator, Element>
- LazyMapCollection.Element = Element
- LazyMapCollection.SubSequence = Slice<LazyMapCollection<Base, Element>>
- LazyMapGenerator.Element = Generator.Element
- LazyMapSequence.Elements = LazyMapSequence<Base, Element>
- LazyMapSequence.Generator = LazyMapGenerator<Base.Generator, Element>
- LazyMapSequence.Element = Generator.Element
- LazySequence.Generator = Self.Base.Generator
- LazySequence.Element = Generator.Element
- Mirror.Child = (label: String?, value: Any)
- Mirror.Children = AnyForwardCollection<Child>
- MutableSlice.Index = Base.Index
- MutableSlice.Generator = IndexingGenerator<MutableSlice<Base>>
- MutableSlice.Element = Base._Element
- MutableSlice.SubSequence = MutableSlice<Base>
- PermutationGenerator.Element = C.Generator.Element
- Range.Generator = RangeGenerator<Element>
- Range.Element = Element
- Range.Index = Element
- Range.SubSequence = Slice<Range<Element>>
- RangeGenerator.Element = ForwardIndexType
- Repeat.Index = Int
- Repeat.Generator = IndexingGenerator<Repeat<Element>>
- Repeat.Element = Element
- Repeat.SubSequence = Slice<Repeat<Element>>
- ReverseCollection.Index = ReverseIndex<Base.Index>
- ReverseCollection.Generator = IndexingGenerator<ReverseCollection<Base>>
- ReverseCollection.Element = Generator.Element
- ReverseCollection.SubSequence = Slice<ReverseCollection<Base>>
- ReverseIndex.Distance = Base.Distance
- ReverseRandomAccessCollection.Index = ReverseRandomAccessIndex<Base.Index>
- ReverseRandomAccessCollection.Generator = IndexingGenerator<ReverseRandomAccessCollection<Base>>
- ReverseRandomAccessCollection.Element = Generator.Element
- ReverseRandomAccessCollection.SubSequence = Slice<ReverseRandomAccessCollection<Base>>
- ReverseRandomAccessIndex.Distance = Base.Distance
- Set.Index = SetIndex<Element>
- Set.Generator = SetGenerator<Element>
- Set.Element = Element
- Set.SubSequence = Slice<Set<Element>>
- Slice.Index = Base.Index
- Slice.Generator = IndexingGenerator<Slice<Base>>
- Slice.Element = Base._Element
- Slice.SubSequence = Slice<Base>
- StrideThrough.Generator = StrideThroughGenerator<Element>
- StrideThrough.Element = Strideable
- StrideTo.Generator = StrideToGenerator<Element>
- StrideTo.Element = Strideable
- String.Index = String.CharacterView.Index
- String.UnicodeScalarIndex = String.UnicodeScalarView.Index
- String.UTF16Index = String.UTF16View.Index
- String.UTF8Index = String.UTF8View.Index
- String.CharacterView.Generator = IndexingGenerator<String.CharacterView>
- String.CharacterView.Element = Character
- String.CharacterView.Index = String.CharacterView.Index
- String.CharacterView.SubSequence = String.CharacterView
- String.UnicodeScalarView.Generator = String.UnicodeScalarView.Generator
- String.UnicodeScalarView.Element = UnicodeScalar
- String.UnicodeScalarView.Index = String.UnicodeScalarView.Index
- String.UnicodeScalarView.SubSequence = String.UnicodeScalarView
- String.UTF16View.Generator = IndexingGenerator<String.UTF16View>
- String.UTF16View.Element = CodeUnit
- String.UTF16View.Index = String.UTF16View.Index
- String.UTF16View.SubSequence = String.UTF16View
- String.UTF16View.Index.Distance = Int
- String.UTF8View.Generator = IndexingGenerator<String.UTF8View>
- String.UTF8View.Element = CodeUnit
- String.UTF8View.Index = String.UTF8View.Index
- String.UTF8View.SubSequence = String.UTF8View
- UInt.Distance = Int
- UInt16.Distance = Int
- UInt32.Distance = Int
- UInt64.Distance = Int
- UInt8.Distance = Int
- UnsafeBufferPointer.Generator = UnsafeBufferPointerGenerator<Element>
- UnsafeBufferPointer.Element = Element
- UnsafeBufferPointer.Index = Int
- UnsafeBufferPointer.SubSequence = Slice<UnsafeBufferPointer<Element>>
- UnsafeBufferPointerGenerator.Element = Generator.Element
- UnsafeMutableBufferPointer.Generator = UnsafeBufferPointerGenerator<Element>
- UnsafeMutableBufferPointer.Element = Element
- UnsafeMutableBufferPointer.Index = Int
- UnsafeMutableBufferPointer.SubSequence = MutableSlice<UnsafeMutableBufferPointer<Element>>
- UnsafeMutablePointer.Distance = Int
- UnsafePointer.Distance = Int
- UTF16.CodeUnit = UInt16
- UTF32.CodeUnit = UInt32
- UTF8.CodeUnit = UInt8
- Zip2Generator.Element = (Generator1.Element, Generator2.Element)
- Zip2Sequence.Stream1 = Sequence1.Generator
- Zip2Sequence.Stream2 = Sequence2.Generator
- Zip2Sequence.Generator = Zip2Generator<Sequence1.Generator, Sequence2.Generator>
- Zip2Sequence.Element = Generator.Element
Operator
Protocol
Method
- _ArrayBufferType.init()
- _ArrayBufferType.init(_:shiftedToStartIndex:)
- _ArrayBufferType.subscript(_: Int)
- _ArrayBufferType.subscript(_: Range<Int>)
- _ArrayBufferType.subscript(_: Range<Self.Index>)
- _ArrayBufferType.subscript(_: Self.Index)
- _ArrayBufferType.dropFirst(_:)
- _ArrayBufferType.dropLast(_:)
- _ArrayBufferType.filter(_:)
- _ArrayBufferType.forEach(_:)
- _ArrayBufferType.generate()
- _ArrayBufferType.isMutableAndUniquelyReferenced()
- _ArrayBufferType.map(_:)
- _ArrayBufferType.prefix(_:)
- _ArrayBufferType.prefixThrough(_:)
- _ArrayBufferType.prefixUpTo(_:)
- _ArrayBufferType.replace(subRange:with:elementsOf:)
- _ArrayBufferType.requestNativeBuffer()
- _ArrayBufferType.requestUniqueMutableBackingBuffer(_:)
- _ArrayBufferType.split(_:allowEmptySlices:isSeparator:)
- _ArrayBufferType.suffix(_:)
- _ArrayBufferType.suffixFrom(_:)
- _ArrayBufferType.underestimateCount()
- _ArrayBufferType.withUnsafeBufferPointer(_:)
- _ArrayBufferType.withUnsafeMutableBufferPointer(_:)
- _ArrayBufferType.contains(_:)
- _ArrayBufferType.dropFirst()
- _ArrayBufferType.dropLast()
- _ArrayBufferType.elementsEqual(_:isEquivalent:)
- _ArrayBufferType.enumerate()
- _ArrayBufferType.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- _ArrayBufferType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- _ArrayBufferType.indexOf(_:)
- _ArrayBufferType.lexicographicalCompare(_:isOrderedBefore:)
- _ArrayBufferType.maxElement(_:)
- _ArrayBufferType.minElement(_:)
- _ArrayBufferType.reduce(_:combine:)
- _ArrayBufferType.reverse()
- _ArrayBufferType.sort(_:)
- _ArrayBufferType.startsWith(_:isEquivalent:)
- _ArrayBufferType.flatten()
- _ArrayBufferType.lexicographicalCompare(_:)
- _ArrayBufferType.maxElement()
- _ArrayBufferType.minElement()
- _ArrayBufferType.sort()
- _ArrayBufferType.elementsEqual(_:)
- _ArrayBufferType.split(_:maxSplit:allowEmptySlices:)
- _ArrayBufferType.startsWith(_:)
- _ArrayBufferType.joinWithSeparator(_:)
- _ArrayBufferType.partition(_:isOrderedBefore:)
- _ArrayBufferType.sortInPlace(_:)
- _ArrayBufferType.partition(_:)
- _ArrayBufferType.sortInPlace()
- _ArrayBufferType.popFirst()
- _ArrayBufferType.popLast()
- _ArrayBufferType.removeFirst()
- _ArrayBufferType.removeFirst(_:)
- _ArrayBufferType.removeLast()
- _ArrayBufferType.removeLast(_:)
- _ArrayType.init(_:)
- _ArrayType.init(count:repeatedValue:)
- _ArrayType.init(arrayLiteral:)
- _ArrayType.init()
- _ArrayType.subscript(_: Int)
- _ArrayType.subscript(_: Range<Self.Index>)
- _ArrayType.subscript(_: Self.Index)
- _ArrayType.+=(inout:rhs:)
- _ArrayType.append(_:)
- _ArrayType.appendContentsOf(_:)
- _ArrayType.dropFirst(_:)
- _ArrayType.dropLast(_:)
- _ArrayType.filter(_:)
- _ArrayType.forEach(_:)
- _ArrayType.generate()
- _ArrayType.insert(_:atIndex:)
- _ArrayType.insertContentsOf(_:at:)
- _ArrayType.map(_:)
- _ArrayType.prefix(_:)
- _ArrayType.prefixThrough(_:)
- _ArrayType.prefixUpTo(_:)
- _ArrayType.removeAll(keepCapacity:)
- _ArrayType.removeAtIndex(_:)
- _ArrayType.removeFirst()
- _ArrayType.removeFirst(_:)
- _ArrayType.removeRange(_:)
- _ArrayType.replaceRange(_:with:)
- _ArrayType.reserveCapacity(_:)
- _ArrayType.split(_:allowEmptySlices:isSeparator:)
- _ArrayType.suffix(_:)
- _ArrayType.suffixFrom(_:)
- _ArrayType.underestimateCount()
- _ArrayType.contains(_:)
- _ArrayType.dropFirst()
- _ArrayType.dropLast()
- _ArrayType.elementsEqual(_:isEquivalent:)
- _ArrayType.enumerate()
- _ArrayType.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- _ArrayType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- _ArrayType.indexOf(_:)
- _ArrayType.lexicographicalCompare(_:isOrderedBefore:)
- _ArrayType.maxElement(_:)
- _ArrayType.minElement(_:)
- _ArrayType.reduce(_:combine:)
- _ArrayType.reverse()
- _ArrayType.sort(_:)
- _ArrayType.startsWith(_:isEquivalent:)
- _ArrayType.flatten()
- _ArrayType.lexicographicalCompare(_:)
- _ArrayType.maxElement()
- _ArrayType.minElement()
- _ArrayType.sort()
- _ArrayType.elementsEqual(_:)
- _ArrayType.split(_:maxSplit:allowEmptySlices:)
- _ArrayType.startsWith(_:)
- _ArrayType.joinWithSeparator(_:)
- _ArrayType.removeLast()
- _ArrayType.removeLast(_:)
- _ArrayType.partition(_:isOrderedBefore:)
- _ArrayType.sortInPlace(_:)
- _ArrayType.partition(_:)
- _ArrayType.sortInPlace()
- _ArrayType.popFirst()
- _ArrayType.popLast()
- _DisallowMixedSignArithmetic.init(integerLiteral:)
- _DisallowMixedSignArithmetic.addWithOverflow(_:_:)
- _DisallowMixedSignArithmetic.divideWithOverflow(_:_:)
- _DisallowMixedSignArithmetic.multiplyWithOverflow(_:_:)
- _DisallowMixedSignArithmetic.remainderWithOverflow(_:_:)
- _DisallowMixedSignArithmetic.subtractWithOverflow(_:_:)
- _DisallowMixedSignArithmetic.%(_:rhs:)
- _DisallowMixedSignArithmetic.&(_:rhs:)
- _DisallowMixedSignArithmetic.*(_:rhs:)
- _DisallowMixedSignArithmetic.+(_:rhs:)
- _DisallowMixedSignArithmetic./(_:rhs:)
- _DisallowMixedSignArithmetic.<(_:rhs:)
- _DisallowMixedSignArithmetic.<=(_:rhs:)
- _DisallowMixedSignArithmetic.==(_:rhs:)
- _DisallowMixedSignArithmetic.>(_:rhs:)
- _DisallowMixedSignArithmetic.>=(_:rhs:)
- _DisallowMixedSignArithmetic.^(_:rhs:)
- _DisallowMixedSignArithmetic.|(_:rhs:)
- _DisallowMixedSignArithmetic.~(_:)
- _DisallowMixedSignArithmetic.-(_:rhs:)
- _DisallowMixedSignArithmetic.successor()
- _DisallowMixedSignArithmetic.toIntMax()
- _Incrementable.==(_:rhs:)
- _Incrementable.successor()
- _IntegerArithmeticType.addWithOverflow(_:_:)
- _IntegerArithmeticType.divideWithOverflow(_:_:)
- _IntegerArithmeticType.multiplyWithOverflow(_:_:)
- _IntegerArithmeticType.remainderWithOverflow(_:_:)
- _IntegerArithmeticType.subtractWithOverflow(_:_:)
- _IntegerType.init(integerLiteral:)
- _IntegerType.addWithOverflow(_:_:)
- _IntegerType.divideWithOverflow(_:_:)
- _IntegerType.multiplyWithOverflow(_:_:)
- _IntegerType.remainderWithOverflow(_:_:)
- _IntegerType.subtractWithOverflow(_:_:)
- _IntegerType.%(_:rhs:)
- _IntegerType.&(_:rhs:)
- _IntegerType.*(_:rhs:)
- _IntegerType.+(_:rhs:)
- _IntegerType./(_:rhs:)
- _IntegerType.<(_:rhs:)
- _IntegerType.<=(_:rhs:)
- _IntegerType.==(_:rhs:)
- _IntegerType.>(_:rhs:)
- _IntegerType.>=(_:rhs:)
- _IntegerType.^(_:rhs:)
- _IntegerType.|(_:rhs:)
- _IntegerType.~(_:)
- _IntegerType.-(_:rhs:)
- _IntegerType.successor()
- _IntegerType.toIntMax()
- _MirrorType.subscript(_: Int)
- _NSArrayCoreType.copyWithZone(_:)
- _NSArrayCoreType.countByEnumeratingWithState(_:objects:count:)
- _NSArrayCoreType.getObjects(_:range:)
- _NSArrayCoreType.objectAtIndex(_:)
- _NSCopyingType.copyWithZone(_:)
- _NSDictionaryCoreType.init(objects:forKeys:count:)
- _NSDictionaryCoreType.copyWithZone(_:)
- _NSDictionaryCoreType.countByEnumeratingWithState(_:objects:count:)
- _NSDictionaryCoreType.getObjects(_:andKeys:)
- _NSDictionaryCoreType.keyEnumerator()
- _NSDictionaryCoreType.objectForKey(_:)
- _NSDictionaryType.init(objects:forKeys:count:)
- _NSDictionaryType.copyWithZone(_:)
- _NSDictionaryType.countByEnumeratingWithState(_:objects:count:)
- _NSDictionaryType.getObjects(_:andKeys:)
- _NSDictionaryType.keyEnumerator()
- _NSDictionaryType.objectForKey(_:)
- _NSEnumeratorType.init()
- _NSEnumeratorType.nextObject()
- _NSFastEnumerationType.countByEnumeratingWithState(_:objects:count:)
- _NSSetCoreType.init(objects:count:)
- _NSSetCoreType.copyWithZone(_:)
- _NSSetCoreType.countByEnumeratingWithState(_:objects:count:)
- _NSSetCoreType.member(_:)
- _NSSetCoreType.objectEnumerator()
- _NSSetType.init(objects:count:)
- _NSSetType.copyWithZone(_:)
- _NSSetType.countByEnumeratingWithState(_:objects:count:)
- _NSSetType.member(_:)
- _NSSetType.objectEnumerator()
- _NSStringCoreType.characterAtIndex(_:)
- _NSStringCoreType.copyWithZone(_:)
- _NSStringCoreType.countByEnumeratingWithState(_:objects:count:)
- _NSStringCoreType.length()
- _RandomAccessAmbiguity.advancedBy(_:)
- _ReverseCollectionType.subscript(_: Range<Self.Index>)
- _ReverseCollectionType.subscript(_: Self.Index)
- _ReverseCollectionType.dropFirst(_:)
- _ReverseCollectionType.dropLast(_:)
- _ReverseCollectionType.filter(_:)
- _ReverseCollectionType.forEach(_:)
- _ReverseCollectionType.generate()
- _ReverseCollectionType.map(_:)
- _ReverseCollectionType.prefix(_:)
- _ReverseCollectionType.prefixThrough(_:)
- _ReverseCollectionType.prefixUpTo(_:)
- _ReverseCollectionType.split(_:allowEmptySlices:isSeparator:)
- _ReverseCollectionType.suffix(_:)
- _ReverseCollectionType.suffixFrom(_:)
- _ReverseCollectionType.underestimateCount()
- _ReverseCollectionType.contains(_:)
- _ReverseCollectionType.dropFirst()
- _ReverseCollectionType.dropLast()
- _ReverseCollectionType.elementsEqual(_:isEquivalent:)
- _ReverseCollectionType.enumerate()
- _ReverseCollectionType.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- _ReverseCollectionType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- _ReverseCollectionType.indexOf(_:)
- _ReverseCollectionType.lexicographicalCompare(_:isOrderedBefore:)
- _ReverseCollectionType.maxElement(_:)
- _ReverseCollectionType.minElement(_:)
- _ReverseCollectionType.reduce(_:combine:)
- _ReverseCollectionType.reverse()
- _ReverseCollectionType.sort(_:)
- _ReverseCollectionType.startsWith(_:isEquivalent:)
- _ReverseCollectionType.flatten()
- _ReverseCollectionType.lexicographicalCompare(_:)
- _ReverseCollectionType.maxElement()
- _ReverseCollectionType.minElement()
- _ReverseCollectionType.sort()
- _ReverseCollectionType.elementsEqual(_:)
- _ReverseCollectionType.split(_:maxSplit:allowEmptySlices:)
- _ReverseCollectionType.startsWith(_:)
- _ReverseCollectionType.joinWithSeparator(_:)
- _ReverseCollectionType.popFirst()
- _ReverseCollectionType.popLast()
- _ReverseCollectionType.removeFirst()
- _ReverseCollectionType.removeFirst(_:)
- _ReverseCollectionType.removeLast()
- _ReverseCollectionType.removeLast(_:)
- _SignedIntegerType.init(_:)
- _SignedIntegerType.init(integerLiteral:)
- _SignedIntegerType.addWithOverflow(_:_:)
- _SignedIntegerType.divideWithOverflow(_:_:)
- _SignedIntegerType.multiplyWithOverflow(_:_:)
- _SignedIntegerType.remainderWithOverflow(_:_:)
- _SignedIntegerType.subtractWithOverflow(_:_:)
- _SignedIntegerType.%(_:rhs:)
- _SignedIntegerType.&(_:rhs:)
- _SignedIntegerType.*(_:rhs:)
- _SignedIntegerType.+(_:rhs:)
- _SignedIntegerType./(_:rhs:)
- _SignedIntegerType.<(_:rhs:)
- _SignedIntegerType.<=(_:rhs:)
- _SignedIntegerType.==(_:rhs:)
- _SignedIntegerType.>(_:rhs:)
- _SignedIntegerType.>=(_:rhs:)
- _SignedIntegerType.^(_:rhs:)
- _SignedIntegerType.|(_:rhs:)
- _SignedIntegerType.~(_:)
- _SignedIntegerType.-(_:)
- _SignedIntegerType.-(_:rhs:)
- _SignedIntegerType.successor()
- _SignedIntegerType.toIntMax()
- AbsoluteValuable.init(integerLiteral:)
- AbsoluteValuable.abs(_:)
- AbsoluteValuable.<(_:rhs:)
- AbsoluteValuable.<=(_:rhs:)
- AbsoluteValuable.==(_:rhs:)
- AbsoluteValuable.>(_:rhs:)
- AbsoluteValuable.>=(_:rhs:)
- AbsoluteValuable.-(_:)
- AbsoluteValuable.-(_:rhs:)
- AnyCollectionType.subscript(_: Range<Self.Index>)
- AnyCollectionType.subscript(_: Self.Index)
- AnyCollectionType.dropFirst(_:)
- AnyCollectionType.dropLast(_:)
- AnyCollectionType.filter(_:)
- AnyCollectionType.forEach(_:)
- AnyCollectionType.generate()
- AnyCollectionType.map(_:)
- AnyCollectionType.prefix(_:)
- AnyCollectionType.prefixThrough(_:)
- AnyCollectionType.prefixUpTo(_:)
- AnyCollectionType.split(_:allowEmptySlices:isSeparator:)
- AnyCollectionType.suffix(_:)
- AnyCollectionType.suffixFrom(_:)
- AnyCollectionType.underestimateCount()
- AnyCollectionType.contains(_:)
- AnyCollectionType.dropFirst()
- AnyCollectionType.dropLast()
- AnyCollectionType.elementsEqual(_:isEquivalent:)
- AnyCollectionType.enumerate()
- AnyCollectionType.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- AnyCollectionType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- AnyCollectionType.indexOf(_:)
- AnyCollectionType.lexicographicalCompare(_:isOrderedBefore:)
- AnyCollectionType.maxElement(_:)
- AnyCollectionType.minElement(_:)
- AnyCollectionType.reduce(_:combine:)
- AnyCollectionType.reverse()
- AnyCollectionType.sort(_:)
- AnyCollectionType.startsWith(_:isEquivalent:)
- AnyCollectionType.flatten()
- AnyCollectionType.lexicographicalCompare(_:)
- AnyCollectionType.maxElement()
- AnyCollectionType.minElement()
- AnyCollectionType.sort()
- AnyCollectionType.elementsEqual(_:)
- AnyCollectionType.split(_:maxSplit:allowEmptySlices:)
- AnyCollectionType.startsWith(_:)
- AnyCollectionType.joinWithSeparator(_:)
- AnyCollectionType.popFirst()
- AnyCollectionType.popLast()
- AnyCollectionType.removeFirst()
- AnyCollectionType.removeFirst(_:)
- AnyCollectionType.removeLast()
- AnyCollectionType.removeLast(_:)
- ArrayLiteralConvertible.init(arrayLiteral:)
- BidirectionalIndexType.==(_:rhs:)
- BidirectionalIndexType.advancedBy(_:)
- BidirectionalIndexType.advancedBy(_:limit:)
- BidirectionalIndexType.distanceTo(_:)
- BidirectionalIndexType.predecessor()
- BidirectionalIndexType.successor()
- BitwiseOperationsType.&(_:rhs:)
- BitwiseOperationsType.^(_:rhs:)
- BitwiseOperationsType.|(_:rhs:)
- BitwiseOperationsType.~(_:)
- BooleanLiteralConvertible.init(booleanLiteral:)
- CollectionType.subscript(_: Range<Self.Index>)
- CollectionType.subscript(_: Self.Index)
- CollectionType.dropFirst(_:)
- CollectionType.dropLast(_:)
- CollectionType.filter(_:)
- CollectionType.forEach(_:)
- CollectionType.generate()
- CollectionType.map(_:)
- CollectionType.prefix(_:)
- CollectionType.prefixThrough(_:)
- CollectionType.prefixUpTo(_:)
- CollectionType.split(_:allowEmptySlices:isSeparator:)
- CollectionType.suffix(_:)
- CollectionType.suffixFrom(_:)
- CollectionType.underestimateCount()
- CollectionType.contains(_:)
- CollectionType.dropFirst()
- CollectionType.dropLast()
- CollectionType.elementsEqual(_:isEquivalent:)
- CollectionType.enumerate()
- CollectionType.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- CollectionType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- CollectionType.indexOf(_:)
- CollectionType.lexicographicalCompare(_:isOrderedBefore:)
- CollectionType.maxElement(_:)
- CollectionType.minElement(_:)
- CollectionType.reduce(_:combine:)
- CollectionType.reverse()
- CollectionType.sort(_:)
- CollectionType.startsWith(_:isEquivalent:)
- CollectionType.flatten()
- CollectionType.lexicographicalCompare(_:)
- CollectionType.maxElement()
- CollectionType.minElement()
- CollectionType.sort()
- CollectionType.elementsEqual(_:)
- CollectionType.split(_:maxSplit:allowEmptySlices:)
- CollectionType.startsWith(_:)
- CollectionType.joinWithSeparator(_:)
- CollectionType.popFirst()
- CollectionType.popLast()
- CollectionType.removeFirst()
- CollectionType.removeFirst(_:)
- CollectionType.removeLast()
- CollectionType.removeLast(_:)
- Comparable.<(_:rhs:)
- Comparable.<=(_:rhs:)
- Comparable.==(_:rhs:)
- Comparable.>(_:rhs:)
- Comparable.>=(_:rhs:)
- CustomLeafReflectable.customMirror()
- CustomPlaygroundQuickLookable.customPlaygroundQuickLook()
- CustomReflectable.customMirror()
- DictionaryLiteralConvertible.init(dictionaryLiteral:)
- Equatable.==(_:rhs:)
- ExtendedGraphemeClusterLiteralConvertible.init(extendedGraphemeClusterLiteral:)
- ExtendedGraphemeClusterLiteralConvertible.init(unicodeScalarLiteral:)
- FloatingPointType.init(_: Int)
- FloatingPointType.init(_: Int8)
- FloatingPointType.init(_: Int16)
- FloatingPointType.init(_: Int32)
- FloatingPointType.init(_: Int64)
- FloatingPointType.init(_: UInt)
- FloatingPointType.init(_: UInt8)
- FloatingPointType.init(_: UInt16)
- FloatingPointType.init(_: UInt32)
- FloatingPointType.init(_: UInt64)
- FloatingPointType.<(_:rhs:)
- FloatingPointType.<=(_:rhs:)
- FloatingPointType.==(_:rhs:)
- FloatingPointType.>(_:rhs:)
- FloatingPointType.>=(_:rhs:)
- FloatingPointType.advancedBy(_:)
- FloatingPointType.distanceTo(_:)
- FloatingPointType.stride(through:by:)
- FloatingPointType.stride(to:by:)
- FloatLiteralConvertible.init(floatLiteral:)
- ForwardIndexType.==(_:rhs:)
- ForwardIndexType.advancedBy(_:)
- ForwardIndexType.advancedBy(_:limit:)
- ForwardIndexType.distanceTo(_:)
- ForwardIndexType.successor()
- GeneratorType.next()
- Hashable.==(_:rhs:)
- Indexable.subscript(_: Self.Index)
- IntegerArithmeticType.addWithOverflow(_:_:)
- IntegerArithmeticType.divideWithOverflow(_:_:)
- IntegerArithmeticType.multiplyWithOverflow(_:_:)
- IntegerArithmeticType.remainderWithOverflow(_:_:)
- IntegerArithmeticType.subtractWithOverflow(_:_:)
- IntegerArithmeticType.%(_:rhs:)
- IntegerArithmeticType.*(_:rhs:)
- IntegerArithmeticType.+(_:rhs:)
- IntegerArithmeticType./(_:rhs:)
- IntegerArithmeticType.<(_:rhs:)
- IntegerArithmeticType.<=(_:rhs:)
- IntegerArithmeticType.==(_:rhs:)
- IntegerArithmeticType.>(_:rhs:)
- IntegerArithmeticType.>=(_:rhs:)
- IntegerArithmeticType.-(_:rhs:)
- IntegerArithmeticType.toIntMax()
- IntegerLiteralConvertible.init(integerLiteral:)
- IntegerType.init(integerLiteral:)
- IntegerType.addWithOverflow(_:_:)
- IntegerType.divideWithOverflow(_:_:)
- IntegerType.multiplyWithOverflow(_:_:)
- IntegerType.remainderWithOverflow(_:_:)
- IntegerType.subtractWithOverflow(_:_:)
- IntegerType.%(_:rhs:)
- IntegerType.&(_:rhs:)
- IntegerType.*(_:rhs:)
- IntegerType.+(_:rhs:)
- IntegerType./(_:rhs:)
- IntegerType.<(_:rhs:)
- IntegerType.<=(_:rhs:)
- IntegerType.==(_:rhs:)
- IntegerType.>(_:rhs:)
- IntegerType.>=(_:rhs:)
- IntegerType.^(_:rhs:)
- IntegerType.|(_:rhs:)
- IntegerType.~(_:)
- IntegerType.-(_:rhs:)
- IntegerType.advancedBy(_:)
- IntegerType.advancedBy(_:limit:)
- IntegerType.distanceTo(_:)
- IntegerType.predecessor()
- IntegerType.successor()
- IntegerType.toIntMax()
- IntegerType.stride(through:by:)
- IntegerType.stride(to:by:)
- IntervalType.clamp(_:)
- IntervalType.contains(_:)
- IntervalType.overlaps(_:)
- LazyCollectionType.subscript(_: Range<Self.Index>)
- LazyCollectionType.subscript(_: Self.Index)
- LazyCollectionType.dropFirst(_:)
- LazyCollectionType.dropLast(_:)
- LazyCollectionType.filter(_:)
- LazyCollectionType.forEach(_:)
- LazyCollectionType.generate()
- LazyCollectionType.map(_:)
- LazyCollectionType.prefix(_:)
- LazyCollectionType.prefixThrough(_:)
- LazyCollectionType.prefixUpTo(_:)
- LazyCollectionType.split(_:allowEmptySlices:isSeparator:)
- LazyCollectionType.suffix(_:)
- LazyCollectionType.suffixFrom(_:)
- LazyCollectionType.underestimateCount()
- LazyCollectionType.contains(_:)
- LazyCollectionType.dropFirst()
- LazyCollectionType.dropLast()
- LazyCollectionType.elementsEqual(_:isEquivalent:)
- LazyCollectionType.enumerate()
- LazyCollectionType.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- LazyCollectionType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- LazyCollectionType.flatMap(_:)
- LazyCollectionType.indexOf(_:)
- LazyCollectionType.lexicographicalCompare(_:isOrderedBefore:)
- LazyCollectionType.maxElement(_:)
- LazyCollectionType.minElement(_:)
- LazyCollectionType.reduce(_:combine:)
- LazyCollectionType.reverse()
- LazyCollectionType.sort(_:)
- LazyCollectionType.startsWith(_:isEquivalent:)
- LazyCollectionType.flatten()
- LazyCollectionType.lexicographicalCompare(_:)
- LazyCollectionType.maxElement()
- LazyCollectionType.minElement()
- LazyCollectionType.sort()
- LazyCollectionType.elementsEqual(_:)
- LazyCollectionType.split(_:maxSplit:allowEmptySlices:)
- LazyCollectionType.startsWith(_:)
- LazyCollectionType.joinWithSeparator(_:)
- LazyCollectionType.popFirst()
- LazyCollectionType.popLast()
- LazyCollectionType.removeFirst()
- LazyCollectionType.removeFirst(_:)
- LazyCollectionType.removeLast()
- LazyCollectionType.removeLast(_:)
- LazySequenceType.dropFirst(_:)
- LazySequenceType.dropLast(_:)
- LazySequenceType.filter(_:)
- LazySequenceType.forEach(_:)
- LazySequenceType.generate()
- LazySequenceType.map(_:)
- LazySequenceType.prefix(_:)
- LazySequenceType.split(_:allowEmptySlices:isSeparator:)
- LazySequenceType.suffix(_:)
- LazySequenceType.underestimateCount()
- LazySequenceType.contains(_:)
- LazySequenceType.dropFirst()
- LazySequenceType.dropLast()
- LazySequenceType.elementsEqual(_:isEquivalent:)
- LazySequenceType.enumerate()
- LazySequenceType.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- LazySequenceType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- LazySequenceType.flatMap(_:)
- LazySequenceType.lexicographicalCompare(_:isOrderedBefore:)
- LazySequenceType.maxElement(_:)
- LazySequenceType.minElement(_:)
- LazySequenceType.reduce(_:combine:)
- LazySequenceType.reverse()
- LazySequenceType.sort(_:)
- LazySequenceType.startsWith(_:isEquivalent:)
- LazySequenceType.flatten()
- LazySequenceType.lexicographicalCompare(_:)
- LazySequenceType.maxElement()
- LazySequenceType.minElement()
- LazySequenceType.sort()
- LazySequenceType.elementsEqual(_:)
- LazySequenceType.split(_:maxSplit:allowEmptySlices:)
- LazySequenceType.startsWith(_:)
- LazySequenceType.joinWithSeparator(_:)
- MutableCollectionType.subscript(_: Range<Self.Index>)
- MutableCollectionType.subscript(_: Self.Index)
- MutableCollectionType.dropFirst(_:)
- MutableCollectionType.dropLast(_:)
- MutableCollectionType.filter(_:)
- MutableCollectionType.forEach(_:)
- MutableCollectionType.generate()
- MutableCollectionType.map(_:)
- MutableCollectionType.prefix(_:)
- MutableCollectionType.prefixThrough(_:)
- MutableCollectionType.prefixUpTo(_:)
- MutableCollectionType.split(_:allowEmptySlices:isSeparator:)
- MutableCollectionType.suffix(_:)
- MutableCollectionType.suffixFrom(_:)
- MutableCollectionType.underestimateCount()
- MutableCollectionType.contains(_:)
- MutableCollectionType.dropFirst()
- MutableCollectionType.dropLast()
- MutableCollectionType.elementsEqual(_:isEquivalent:)
- MutableCollectionType.enumerate()
- MutableCollectionType.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- MutableCollectionType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- MutableCollectionType.indexOf(_:)
- MutableCollectionType.lexicographicalCompare(_:isOrderedBefore:)
- MutableCollectionType.maxElement(_:)
- MutableCollectionType.minElement(_:)
- MutableCollectionType.reduce(_:combine:)
- MutableCollectionType.reverse()
- MutableCollectionType.sort(_:)
- MutableCollectionType.startsWith(_:isEquivalent:)
- MutableCollectionType.flatten()
- MutableCollectionType.lexicographicalCompare(_:)
- MutableCollectionType.maxElement()
- MutableCollectionType.minElement()
- MutableCollectionType.sort()
- MutableCollectionType.elementsEqual(_:)
- MutableCollectionType.split(_:maxSplit:allowEmptySlices:)
- MutableCollectionType.startsWith(_:)
- MutableCollectionType.joinWithSeparator(_:)
- MutableCollectionType.partition(_:isOrderedBefore:)
- MutableCollectionType.sortInPlace(_:)
- MutableCollectionType.partition(_:)
- MutableCollectionType.sortInPlace()
- MutableCollectionType.popFirst()
- MutableCollectionType.popLast()
- MutableCollectionType.removeFirst()
- MutableCollectionType.removeFirst(_:)
- MutableCollectionType.removeLast()
- MutableCollectionType.removeLast(_:)
- MutableIndexable.subscript(_: Self.Index)
- MutableSliceable.subscript(_: Range<Self.Index>)
- MutableSliceable.subscript(_: Self.Index)
- MutableSliceable.dropFirst(_:)
- MutableSliceable.dropLast(_:)
- MutableSliceable.filter(_:)
- MutableSliceable.forEach(_:)
- MutableSliceable.generate()
- MutableSliceable.map(_:)
- MutableSliceable.prefix(_:)
- MutableSliceable.prefixThrough(_:)
- MutableSliceable.prefixUpTo(_:)
- MutableSliceable.split(_:allowEmptySlices:isSeparator:)
- MutableSliceable.suffix(_:)
- MutableSliceable.suffixFrom(_:)
- MutableSliceable.underestimateCount()
- MutableSliceable.contains(_:)
- MutableSliceable.dropFirst()
- MutableSliceable.dropLast()
- MutableSliceable.elementsEqual(_:isEquivalent:)
- MutableSliceable.enumerate()
- MutableSliceable.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- MutableSliceable.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- MutableSliceable.indexOf(_:)
- MutableSliceable.lexicographicalCompare(_:isOrderedBefore:)
- MutableSliceable.maxElement(_:)
- MutableSliceable.minElement(_:)
- MutableSliceable.reduce(_:combine:)
- MutableSliceable.reverse()
- MutableSliceable.sort(_:)
- MutableSliceable.startsWith(_:isEquivalent:)
- MutableSliceable.flatten()
- MutableSliceable.lexicographicalCompare(_:)
- MutableSliceable.maxElement()
- MutableSliceable.minElement()
- MutableSliceable.sort()
- MutableSliceable.elementsEqual(_:)
- MutableSliceable.split(_:maxSplit:allowEmptySlices:)
- MutableSliceable.startsWith(_:)
- MutableSliceable.joinWithSeparator(_:)
- MutableSliceable.partition(_:isOrderedBefore:)
- MutableSliceable.sortInPlace(_:)
- MutableSliceable.partition(_:)
- MutableSliceable.sortInPlace()
- MutableSliceable.popFirst()
- MutableSliceable.popLast()
- MutableSliceable.removeFirst()
- MutableSliceable.removeFirst(_:)
- MutableSliceable.removeLast()
- MutableSliceable.removeLast(_:)
- NilLiteralConvertible.init(nilLiteral:)
- OptionSetType.init(rawValue:)
- OptionSetType.init(arrayLiteral:)
- OptionSetType.init()
- OptionSetType.init(_:)
- OptionSetType.element(_:isDisjointWith:)
- OptionSetType.element(_:subsumes:)
- OptionSetType.==(_:rhs:)
- OptionSetType.contains(_:)
- OptionSetType.exclusiveOr(_:)
- OptionSetType.exclusiveOrInPlace(_:)
- OptionSetType.insert(_:)
- OptionSetType.intersect(_:)
- OptionSetType.intersectInPlace(_:)
- OptionSetType.isDisjointWith(_:)
- OptionSetType.isSubsetOf(_:)
- OptionSetType.isSupersetOf(_:)
- OptionSetType.remove(_:)
- OptionSetType.subtract(_:)
- OptionSetType.subtractInPlace(_:)
- OptionSetType.union(_:)
- OptionSetType.unionInPlace(_:)
- OptionSetType.isStrictSubsetOf(_:)
- OptionSetType.isStrictSupersetOf(_:)
- OutputStreamType.write(_:)
- RandomAccessIndexType.<(_:rhs:)
- RandomAccessIndexType.<=(_:rhs:)
- RandomAccessIndexType.==(_:rhs:)
- RandomAccessIndexType.>(_:rhs:)
- RandomAccessIndexType.>=(_:rhs:)
- RandomAccessIndexType.advancedBy(_:)
- RandomAccessIndexType.advancedBy(_:limit:)
- RandomAccessIndexType.distanceTo(_:)
- RandomAccessIndexType.predecessor()
- RandomAccessIndexType.successor()
- RandomAccessIndexType.stride(through:by:)
- RandomAccessIndexType.stride(to:by:)
- RangeReplaceableCollectionType.init()
- RangeReplaceableCollectionType.init(_:)
- RangeReplaceableCollectionType.subscript(_: Range<Self.Index>)
- RangeReplaceableCollectionType.subscript(_: Self.Index)
- RangeReplaceableCollectionType.append(_:)
- RangeReplaceableCollectionType.appendContentsOf(_:)
- RangeReplaceableCollectionType.dropFirst(_:)
- RangeReplaceableCollectionType.dropLast(_:)
- RangeReplaceableCollectionType.filter(_:)
- RangeReplaceableCollectionType.forEach(_:)
- RangeReplaceableCollectionType.generate()
- RangeReplaceableCollectionType.insert(_:atIndex:)
- RangeReplaceableCollectionType.insertContentsOf(_:at:)
- RangeReplaceableCollectionType.map(_:)
- RangeReplaceableCollectionType.prefix(_:)
- RangeReplaceableCollectionType.prefixThrough(_:)
- RangeReplaceableCollectionType.prefixUpTo(_:)
- RangeReplaceableCollectionType.removeAll(keepCapacity:)
- RangeReplaceableCollectionType.removeAtIndex(_:)
- RangeReplaceableCollectionType.removeFirst()
- RangeReplaceableCollectionType.removeFirst(_:)
- RangeReplaceableCollectionType.removeRange(_:)
- RangeReplaceableCollectionType.replaceRange(_:with:)
- RangeReplaceableCollectionType.reserveCapacity(_:)
- RangeReplaceableCollectionType.split(_:allowEmptySlices:isSeparator:)
- RangeReplaceableCollectionType.suffix(_:)
- RangeReplaceableCollectionType.suffixFrom(_:)
- RangeReplaceableCollectionType.underestimateCount()
- RangeReplaceableCollectionType.contains(_:)
- RangeReplaceableCollectionType.dropFirst()
- RangeReplaceableCollectionType.dropLast()
- RangeReplaceableCollectionType.elementsEqual(_:isEquivalent:)
- RangeReplaceableCollectionType.enumerate()
- RangeReplaceableCollectionType.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- RangeReplaceableCollectionType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- RangeReplaceableCollectionType.indexOf(_:)
- RangeReplaceableCollectionType.lexicographicalCompare(_:isOrderedBefore:)
- RangeReplaceableCollectionType.maxElement(_:)
- RangeReplaceableCollectionType.minElement(_:)
- RangeReplaceableCollectionType.reduce(_:combine:)
- RangeReplaceableCollectionType.reverse()
- RangeReplaceableCollectionType.sort(_:)
- RangeReplaceableCollectionType.startsWith(_:isEquivalent:)
- RangeReplaceableCollectionType.flatten()
- RangeReplaceableCollectionType.lexicographicalCompare(_:)
- RangeReplaceableCollectionType.maxElement()
- RangeReplaceableCollectionType.minElement()
- RangeReplaceableCollectionType.sort()
- RangeReplaceableCollectionType.elementsEqual(_:)
- RangeReplaceableCollectionType.split(_:maxSplit:allowEmptySlices:)
- RangeReplaceableCollectionType.startsWith(_:)
- RangeReplaceableCollectionType.joinWithSeparator(_:)
- RangeReplaceableCollectionType.removeLast()
- RangeReplaceableCollectionType.removeLast(_:)
- RangeReplaceableCollectionType.popFirst()
- RangeReplaceableCollectionType.popLast()
- RawRepresentable.init?(rawValue:)
- ReverseIndexType.init(_:)
- ReverseIndexType.==(_:rhs:)
- ReverseIndexType.advancedBy(_:)
- ReverseIndexType.advancedBy(_:limit:)
- ReverseIndexType.distanceTo(_:)
- ReverseIndexType.predecessor()
- ReverseIndexType.successor()
- SequenceType.dropFirst(_:)
- SequenceType.dropLast(_:)
- SequenceType.filter(_:)
- SequenceType.forEach(_:)
- SequenceType.generate()
- SequenceType.map(_:)
- SequenceType.prefix(_:)
- SequenceType.split(_:allowEmptySlices:isSeparator:)
- SequenceType.suffix(_:)
- SequenceType.underestimateCount()
- SequenceType.contains(_:)
- SequenceType.dropFirst()
- SequenceType.dropLast()
- SequenceType.elementsEqual(_:isEquivalent:)
- SequenceType.enumerate()
- SequenceType.flatMap<T>(_: (Self.Generator.Element) throws -> T?)
- SequenceType.flatMap<S : SequenceType>(_: (Self.Generator.Element) throws -> S)
- SequenceType.lexicographicalCompare(_:isOrderedBefore:)
- SequenceType.maxElement(_:)
- SequenceType.minElement(_:)
- SequenceType.reduce(_:combine:)
- SequenceType.reverse()
- SequenceType.sort(_:)
- SequenceType.startsWith(_:isEquivalent:)
- SequenceType.lexicographicalCompare(_:)
- SequenceType.maxElement()
- SequenceType.minElement()
- SequenceType.sort()
- SequenceType.elementsEqual(_:)
- SequenceType.split(_:maxSplit:allowEmptySlices:)
- SequenceType.startsWith(_:)
- SequenceType.flatten()
- SequenceType.joinWithSeparator(_:)
- SetAlgebraType.init()
- SetAlgebraType.init(_:)
- SetAlgebraType.init(arrayLiteral:)
- SetAlgebraType.element(_:isDisjointWith:)
- SetAlgebraType.element(_:subsumes:)
- SetAlgebraType.==(_:rhs:)
- SetAlgebraType.contains(_:)
- SetAlgebraType.exclusiveOr(_:)
- SetAlgebraType.exclusiveOrInPlace(_:)
- SetAlgebraType.insert(_:)
- SetAlgebraType.intersect(_:)
- SetAlgebraType.intersectInPlace(_:)
- SetAlgebraType.isDisjointWith(_:)
- SetAlgebraType.isSubsetOf(_:)
- SetAlgebraType.isSupersetOf(_:)
- SetAlgebraType.remove(_:)
- SetAlgebraType.subtract(_:)
- SetAlgebraType.subtractInPlace(_:)
- SetAlgebraType.union(_:)
- SetAlgebraType.unionInPlace(_:)
- SetAlgebraType.isStrictSubsetOf(_:)
- SetAlgebraType.isStrictSupersetOf(_:)
- SignedIntegerType.init(_:)
- SignedIntegerType.init(integerLiteral:)
- SignedIntegerType.addWithOverflow(_:_:)
- SignedIntegerType.divideWithOverflow(_:_:)
- SignedIntegerType.multiplyWithOverflow(_:_:)
- SignedIntegerType.remainderWithOverflow(_:_:)
- SignedIntegerType.subtractWithOverflow(_:_:)
- SignedIntegerType.%(_:rhs:)
- SignedIntegerType.&(_:rhs:)
- SignedIntegerType.*(_:rhs:)
- SignedIntegerType.+(_:rhs:)
- SignedIntegerType./(_:rhs:)
- SignedIntegerType.<(_:rhs:)
- SignedIntegerType.<=(_:rhs:)
- SignedIntegerType.==(_:rhs:)
- SignedIntegerType.>(_:rhs:)
- SignedIntegerType.>=(_:rhs:)
- SignedIntegerType.^(_:rhs:)
- SignedIntegerType.|(_:rhs:)
- SignedIntegerType.~(_:)
- SignedIntegerType.-(_:)
- SignedIntegerType.-(_:rhs:)
- SignedIntegerType.advancedBy(_:)
- SignedIntegerType.advancedBy(_:limit:)
- SignedIntegerType.distanceTo(_:)
- SignedIntegerType.predecessor()
- SignedIntegerType.successor()
- SignedIntegerType.toIntMax()
- SignedIntegerType.stride(through:by:)
- SignedIntegerType.stride(to:by:)
- SignedNumberType.init(integerLiteral:)
- SignedNumberType.<(_:rhs:)
- SignedNumberType.<=(_:rhs:)
- SignedNumberType.==(_:rhs:)
- SignedNumberType.>(_:rhs:)
- SignedNumberType.>=(_:rhs:)
- SignedNumberType.-(_:)
- SignedNumberType.-(_:rhs:)
- Streamable.writeTo(inout:)
- Strideable.<(_:rhs:)
- Strideable.<=(_:rhs:)
- Strideable.==(_:rhs:)
- Strideable.>(_:rhs:)
- Strideable.>=(_:rhs:)
- Strideable.advancedBy(_:)
- Strideable.distanceTo(_:)
- Strideable.stride(through:by:)
- Strideable.stride(to:by:)
- StringInterpolationConvertible.init(stringInterpolation:)
- StringInterpolationConvertible.init(stringInterpolationSegment:)
- StringLiteralConvertible.init(stringLiteral:)
- StringLiteralConvertible.init(extendedGraphemeClusterLiteral:)
- StringLiteralConvertible.init(unicodeScalarLiteral:)
- UnicodeCodecType.init()
- UnicodeCodecType.encode(_:output:)
- UnicodeCodecType.decode(inout:)
- UnicodeScalarLiteralConvertible.init(unicodeScalarLiteral:)
- UnsignedIntegerType.init(_:)
- UnsignedIntegerType.init(integerLiteral:)
- UnsignedIntegerType.addWithOverflow(_:_:)
- UnsignedIntegerType.divideWithOverflow(_:_:)
- UnsignedIntegerType.multiplyWithOverflow(_:_:)
- UnsignedIntegerType.remainderWithOverflow(_:_:)
- UnsignedIntegerType.subtractWithOverflow(_:_:)
- UnsignedIntegerType.%(_:rhs:)
- UnsignedIntegerType.&(_:rhs:)
- UnsignedIntegerType.*(_:rhs:)
- UnsignedIntegerType.+(_:rhs:)
- UnsignedIntegerType./(_:rhs:)
- UnsignedIntegerType.<(_:rhs:)
- UnsignedIntegerType.<=(_:rhs:)
- UnsignedIntegerType.==(_:rhs:)
- UnsignedIntegerType.>(_:rhs:)
- UnsignedIntegerType.>=(_:rhs:)
- UnsignedIntegerType.^(_:rhs:)
- UnsignedIntegerType.|(_:rhs:)
- UnsignedIntegerType.~(_:)
- UnsignedIntegerType.-(_:rhs:)
- UnsignedIntegerType.advancedBy(_:)
- UnsignedIntegerType.advancedBy(_:limit:)
- UnsignedIntegerType.distanceTo(_:)
- UnsignedIntegerType.predecessor()
- UnsignedIntegerType.successor()
- UnsignedIntegerType.toIntMax()
- UnsignedIntegerType.toUIntMax()
- UnsignedIntegerType.stride(through:by:)
- UnsignedIntegerType.stride(to:by:)
- AnyBidirectionalCollection.init(_: AnyBidirectionalCollection<Element>)
- AnyBidirectionalCollection.init(_: AnyRandomAccessCollection<Element>)
- AnyBidirectionalCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
- AnyBidirectionalCollection.init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_: C)
- AnyBidirectionalCollection.init?(_:)
- AnyBidirectionalCollection.subscript(_: AnyBidirectionalIndex)
- AnyBidirectionalCollection.subscript(_: Range<AnyBidirectionalIndex>)
- AnyBidirectionalCollection.contains(_:)
- AnyBidirectionalCollection.dropFirst()
- AnyBidirectionalCollection.dropFirst(_:)
- AnyBidirectionalCollection.dropLast()
- AnyBidirectionalCollection.dropLast(_:)
- AnyBidirectionalCollection.elementsEqual(_:isEquivalent:)
- AnyBidirectionalCollection.enumerate()
- AnyBidirectionalCollection.filter(_:)
- AnyBidirectionalCollection.flatMap<T>(_: (Element) throws -> T?)
- AnyBidirectionalCollection.flatMap<S : SequenceType>(_: (Element) throws -> S)
- AnyBidirectionalCollection.forEach(_:)
- AnyBidirectionalCollection.generate()
- AnyBidirectionalCollection.indexOf(_:)
- AnyBidirectionalCollection.lexicographicalCompare(_:isOrderedBefore:)
- AnyBidirectionalCollection.map(_:)
- AnyBidirectionalCollection.maxElement(_:)
- AnyBidirectionalCollection.minElement(_:)
- AnyBidirectionalCollection.prefix(_:)
- AnyBidirectionalCollection.prefixThrough(_:)
- AnyBidirectionalCollection.prefixUpTo(_:)
- AnyBidirectionalCollection.reduce(_:combine:)
- AnyBidirectionalCollection.reverse()
- AnyBidirectionalCollection.sort(_:)
- AnyBidirectionalCollection.split(_:allowEmptySlices:isSeparator:)
- AnyBidirectionalCollection.startsWith(_:isEquivalent:)
- AnyBidirectionalCollection.suffix(_:)
- AnyBidirectionalCollection.suffixFrom(_:)
- AnyBidirectionalCollection.underestimateCount()
- AnyBidirectionalCollection.flatten()
- AnyBidirectionalCollection.lexicographicalCompare(_:)
- AnyBidirectionalCollection.maxElement()
- AnyBidirectionalCollection.minElement()
- AnyBidirectionalCollection.sort()
- AnyBidirectionalCollection.elementsEqual(_:)
- AnyBidirectionalCollection.split(_:maxSplit:allowEmptySlices:)
- AnyBidirectionalCollection.startsWith(_:)
- AnyBidirectionalCollection.joinWithSeparator(_:)
- AnyBidirectionalIndex.init(_:)
- AnyBidirectionalIndex.advancedBy(_:)
- AnyBidirectionalIndex.advancedBy(_:limit:)
- AnyBidirectionalIndex.distanceTo(_:)
- AnyBidirectionalIndex.predecessor()
- AnyBidirectionalIndex.successor()
- AnyForwardCollection.init(_: AnyBidirectionalCollection<Element>)
- AnyForwardCollection.init(_: AnyForwardCollection<Element>)
- AnyForwardCollection.init(_: AnyRandomAccessCollection<Element>)
- AnyForwardCollection.init<C : CollectionType where C.Index : ForwardIndexType, C.Generator.Element == Element>(_: C)
- AnyForwardCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
- AnyForwardCollection.init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_: C)
- AnyForwardCollection.subscript(_: AnyForwardIndex)
- AnyForwardCollection.subscript(_: Range<AnyForwardIndex>)
- AnyForwardCollection.contains(_:)
- AnyForwardCollection.dropFirst()
- AnyForwardCollection.dropFirst(_:)
- AnyForwardCollection.dropLast()
- AnyForwardCollection.dropLast(_:)
- AnyForwardCollection.elementsEqual(_:isEquivalent:)
- AnyForwardCollection.enumerate()
- AnyForwardCollection.filter(_:)
- AnyForwardCollection.flatMap<T>(_: (Element) throws -> T?)
- AnyForwardCollection.flatMap<S : SequenceType>(_: (Element) throws -> S)
- AnyForwardCollection.forEach(_:)
- AnyForwardCollection.generate()
- AnyForwardCollection.indexOf(_:)
- AnyForwardCollection.lexicographicalCompare(_:isOrderedBefore:)
- AnyForwardCollection.map(_:)
- AnyForwardCollection.maxElement(_:)
- AnyForwardCollection.minElement(_:)
- AnyForwardCollection.prefix(_:)
- AnyForwardCollection.prefixThrough(_:)
- AnyForwardCollection.prefixUpTo(_:)
- AnyForwardCollection.reduce(_:combine:)
- AnyForwardCollection.reverse()
- AnyForwardCollection.sort(_:)
- AnyForwardCollection.split(_:allowEmptySlices:isSeparator:)
- AnyForwardCollection.startsWith(_:isEquivalent:)
- AnyForwardCollection.suffix(_:)
- AnyForwardCollection.suffixFrom(_:)
- AnyForwardCollection.underestimateCount()
- AnyForwardCollection.flatten()
- AnyForwardCollection.lexicographicalCompare(_:)
- AnyForwardCollection.maxElement()
- AnyForwardCollection.minElement()
- AnyForwardCollection.sort()
- AnyForwardCollection.elementsEqual(_:)
- AnyForwardCollection.split(_:maxSplit:allowEmptySlices:)
- AnyForwardCollection.startsWith(_:)
- AnyForwardCollection.joinWithSeparator(_:)
- AnyForwardIndex.init(_:)
- AnyForwardIndex.advancedBy(_:)
- AnyForwardIndex.advancedBy(_:limit:)
- AnyForwardIndex.distanceTo(_:)
- AnyForwardIndex.successor()
- AnyGenerator.init(_:)
- AnyGenerator.init(body:)
- AnyGenerator.contains(_:)
- AnyGenerator.dropFirst()
- AnyGenerator.dropFirst(_:)
- AnyGenerator.dropLast()
- AnyGenerator.dropLast(_:)
- AnyGenerator.elementsEqual(_:isEquivalent:)
- AnyGenerator.enumerate()
- AnyGenerator.filter(_:)
- AnyGenerator.flatMap<T>(_: (Generator.Element) throws -> T?)
- AnyGenerator.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- AnyGenerator.forEach(_:)
- AnyGenerator.lexicographicalCompare(_:isOrderedBefore:)
- AnyGenerator.map(_:)
- AnyGenerator.maxElement(_:)
- AnyGenerator.minElement(_:)
- AnyGenerator.next()
- AnyGenerator.prefix(_:)
- AnyGenerator.reduce(_:combine:)
- AnyGenerator.reverse()
- AnyGenerator.sort(_:)
- AnyGenerator.split(_:allowEmptySlices:isSeparator:)
- AnyGenerator.startsWith(_:isEquivalent:)
- AnyGenerator.suffix(_:)
- AnyGenerator.underestimateCount()
- AnyGenerator.generate()
- AnyGenerator.lexicographicalCompare(_:)
- AnyGenerator.maxElement()
- AnyGenerator.minElement()
- AnyGenerator.sort()
- AnyGenerator.elementsEqual(_:)
- AnyGenerator.split(_:maxSplit:allowEmptySlices:)
- AnyGenerator.startsWith(_:)
- AnyGenerator.flatten()
- AnyGenerator.joinWithSeparator(_:)
- AnyRandomAccessCollection.init(_: AnyRandomAccessCollection<Element>)
- AnyRandomAccessCollection.init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_: C)
- AnyRandomAccessCollection.init?(_: AnyBidirectionalCollection<Element>)
- AnyRandomAccessCollection.init?(_: AnyForwardCollection<Element>)
- AnyRandomAccessCollection.subscript(_: AnyRandomAccessIndex)
- AnyRandomAccessCollection.subscript(_: Range<AnyRandomAccessIndex>)
- AnyRandomAccessCollection.contains(_:)
- AnyRandomAccessCollection.dropFirst()
- AnyRandomAccessCollection.dropFirst(_:)
- AnyRandomAccessCollection.dropLast()
- AnyRandomAccessCollection.dropLast(_:)
- AnyRandomAccessCollection.elementsEqual(_:isEquivalent:)
- AnyRandomAccessCollection.enumerate()
- AnyRandomAccessCollection.filter(_:)
- AnyRandomAccessCollection.flatMap<T>(_: (Element) throws -> T?)
- AnyRandomAccessCollection.flatMap<S : SequenceType>(_: (Element) throws -> S)
- AnyRandomAccessCollection.forEach(_:)
- AnyRandomAccessCollection.generate()
- AnyRandomAccessCollection.indexOf(_:)
- AnyRandomAccessCollection.lexicographicalCompare(_:isOrderedBefore:)
- AnyRandomAccessCollection.map(_:)
- AnyRandomAccessCollection.maxElement(_:)
- AnyRandomAccessCollection.minElement(_:)
- AnyRandomAccessCollection.prefix(_:)
- AnyRandomAccessCollection.prefixThrough(_:)
- AnyRandomAccessCollection.prefixUpTo(_:)
- AnyRandomAccessCollection.reduce(_:combine:)
- AnyRandomAccessCollection.reverse()
- AnyRandomAccessCollection.sort(_:)
- AnyRandomAccessCollection.split(_:allowEmptySlices:isSeparator:)
- AnyRandomAccessCollection.startsWith(_:isEquivalent:)
- AnyRandomAccessCollection.suffix(_:)
- AnyRandomAccessCollection.suffixFrom(_:)
- AnyRandomAccessCollection.underestimateCount()
- AnyRandomAccessCollection.flatten()
- AnyRandomAccessCollection.lexicographicalCompare(_:)
- AnyRandomAccessCollection.maxElement()
- AnyRandomAccessCollection.minElement()
- AnyRandomAccessCollection.sort()
- AnyRandomAccessCollection.elementsEqual(_:)
- AnyRandomAccessCollection.split(_:maxSplit:allowEmptySlices:)
- AnyRandomAccessCollection.startsWith(_:)
- AnyRandomAccessCollection.joinWithSeparator(_:)
- AnyRandomAccessIndex.init(_:)
- AnyRandomAccessIndex.advancedBy(_:)
- AnyRandomAccessIndex.advancedBy(_:limit:)
- AnyRandomAccessIndex.distanceTo(_:)
- AnyRandomAccessIndex.predecessor()
- AnyRandomAccessIndex.stride(through:by:)
- AnyRandomAccessIndex.stride(to:by:)
- AnyRandomAccessIndex.successor()
- AnySequence.init<G : GeneratorType where G.Element == Element>(_: () -> G)
- AnySequence.init<S : SequenceType where S.Generator.Element == Element, S.SubSequence : SequenceType, S.SubSequence.Generator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_: S)
- AnySequence.contains(_:)
- AnySequence.dropFirst()
- AnySequence.dropFirst(_:)
- AnySequence.dropLast()
- AnySequence.dropLast(_:)
- AnySequence.elementsEqual(_:isEquivalent:)
- AnySequence.enumerate()
- AnySequence.filter(_:)
- AnySequence.flatMap<T>(_: (Generator.Element) throws -> T?)
- AnySequence.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- AnySequence.forEach(_:)
- AnySequence.generate()
- AnySequence.lexicographicalCompare(_:isOrderedBefore:)
- AnySequence.map(_:)
- AnySequence.maxElement(_:)
- AnySequence.minElement(_:)
- AnySequence.prefix(_:)
- AnySequence.reduce(_:combine:)
- AnySequence.reverse()
- AnySequence.sort(_:)
- AnySequence.split(_:allowEmptySlices:isSeparator:)
- AnySequence.startsWith(_:isEquivalent:)
- AnySequence.suffix(_:)
- AnySequence.underestimateCount()
- AnySequence.lexicographicalCompare(_:)
- AnySequence.maxElement()
- AnySequence.minElement()
- AnySequence.sort()
- AnySequence.elementsEqual(_:)
- AnySequence.split(_:maxSplit:allowEmptySlices:)
- AnySequence.startsWith(_:)
- AnySequence.flatten()
- AnySequence.joinWithSeparator(_:)
- Array.init()
- Array.init(_:)
- Array.init(arrayLiteral:)
- Array.init(count:repeatedValue:)
- Array.subscript(_: Int)
- Array.subscript(_: Range<Int>)
- Array.append(_:)
- Array.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
- Array.appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_: C)
- Array.appendContentsOf(_:)
- Array.contains(_:)
- Array.dropFirst()
- Array.dropFirst(_:)
- Array.dropLast()
- Array.dropLast(_:)
- Array.elementsEqual(_:isEquivalent:)
- Array.enumerate()
- Array.filter(_:)
- Array.flatMap<T>(_: (Element) throws -> T?)
- Array.flatMap<S : SequenceType>(_: (Element) throws -> S)
- Array.forEach(_:)
- Array.generate()
- Array.indexOf(_:)
- Array.insert(_:atIndex:)
- Array.insertContentsOf(_:at:)
- Array.lexicographicalCompare(_:isOrderedBefore:)
- Array.map(_:)
- Array.maxElement(_:)
- Array.minElement(_:)
- Array.partition(_:isOrderedBefore:)
- Array.popLast()
- Array.prefix(_:)
- Array.prefixThrough(_:)
- Array.prefixUpTo(_:)
- Array.reduce(_:combine:)
- Array.removeAll(keepCapacity:)
- Array.removeAtIndex(_:)
- Array.removeFirst()
- Array.removeFirst(_:)
- Array.removeLast()
- Array.removeLast(_:)
- Array.removeRange(_:)
- Array.replaceRange(_:with:)
- Array.reserveCapacity(_:)
- Array.reverse()
- Array.sort(_:)
- Array.sortInPlace(_:)
- Array.split(_:allowEmptySlices:isSeparator:)
- Array.startsWith(_:isEquivalent:)
- Array.suffix(_:)
- Array.suffixFrom(_:)
- Array.underestimateCount()
- Array.withUnsafeBufferPointer(_:)
- Array.withUnsafeMutableBufferPointer(_:)
- Array.flatten()
- Array.lexicographicalCompare(_:)
- Array.maxElement()
- Array.minElement()
- Array.sort()
- Array.elementsEqual(_:)
- Array.split(_:maxSplit:allowEmptySlices:)
- Array.startsWith(_:)
- Array.joinWithSeparator(_:)
- Array.partition(_:)
- Array.sortInPlace()
- ArraySlice.init()
- ArraySlice.init(_:)
- ArraySlice.init(arrayLiteral:)
- ArraySlice.init(count:repeatedValue:)
- ArraySlice.subscript(_: Int)
- ArraySlice.subscript(_: Range<Int>)
- ArraySlice.append(_:)
- ArraySlice.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
- ArraySlice.appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_: C)
- ArraySlice.appendContentsOf(_:)
- ArraySlice.contains(_:)
- ArraySlice.dropFirst()
- ArraySlice.dropFirst(_:)
- ArraySlice.dropLast()
- ArraySlice.dropLast(_:)
- ArraySlice.elementsEqual(_:isEquivalent:)
- ArraySlice.enumerate()
- ArraySlice.filter(_:)
- ArraySlice.flatMap<T>(_: (Element) throws -> T?)
- ArraySlice.flatMap<S : SequenceType>(_: (Element) throws -> S)
- ArraySlice.forEach(_:)
- ArraySlice.generate()
- ArraySlice.indexOf(_:)
- ArraySlice.insert(_:atIndex:)
- ArraySlice.insertContentsOf(_:at:)
- ArraySlice.lexicographicalCompare(_:isOrderedBefore:)
- ArraySlice.map(_:)
- ArraySlice.maxElement(_:)
- ArraySlice.minElement(_:)
- ArraySlice.partition(_:isOrderedBefore:)
- ArraySlice.popFirst()
- ArraySlice.popLast()
- ArraySlice.prefix(_:)
- ArraySlice.prefixThrough(_:)
- ArraySlice.prefixUpTo(_:)
- ArraySlice.reduce(_:combine:)
- ArraySlice.removeAll(keepCapacity:)
- ArraySlice.removeAtIndex(_:)
- ArraySlice.removeFirst()
- ArraySlice.removeFirst(_:)
- ArraySlice.removeLast()
- ArraySlice.removeLast(_:)
- ArraySlice.removeRange(_:)
- ArraySlice.replaceRange(_:with:)
- ArraySlice.reserveCapacity(_:)
- ArraySlice.reverse()
- ArraySlice.sort(_:)
- ArraySlice.sortInPlace(_:)
- ArraySlice.split(_:allowEmptySlices:isSeparator:)
- ArraySlice.startsWith(_:isEquivalent:)
- ArraySlice.suffix(_:)
- ArraySlice.suffixFrom(_:)
- ArraySlice.underestimateCount()
- ArraySlice.withUnsafeBufferPointer(_:)
- ArraySlice.withUnsafeMutableBufferPointer(_:)
- ArraySlice.flatten()
- ArraySlice.lexicographicalCompare(_:)
- ArraySlice.maxElement()
- ArraySlice.minElement()
- ArraySlice.sort()
- ArraySlice.elementsEqual(_:)
- ArraySlice.split(_:maxSplit:allowEmptySlices:)
- ArraySlice.startsWith(_:)
- ArraySlice.joinWithSeparator(_:)
- ArraySlice.partition(_:)
- ArraySlice.sortInPlace()
- AutoreleasingUnsafeMutablePointer.init()
- AutoreleasingUnsafeMutablePointer.init(_:)
- AutoreleasingUnsafeMutablePointer.init(nilLiteral:)
- AutoreleasingUnsafeMutablePointer.subscript(_: Int)
- Bit.addWithOverflow(_:_:)
- Bit.divideWithOverflow(_:_:)
- Bit.multiplyWithOverflow(_:_:)
- Bit.remainderWithOverflow(_:_:)
- Bit.subtractWithOverflow(_:_:)
- Bit.advancedBy(_:)
- Bit.advancedBy(_:limit:)
- Bit.distanceTo(_:)
- Bit.predecessor()
- Bit.stride(through:by:)
- Bit.stride(to:by:)
- Bit.successor()
- Bit.toIntMax()
- Bool.init()
- Bool.init(_:)
- Bool.init(_builtinBooleanLiteral:)
- Bool.init(booleanLiteral:)
- Character.init(_: String)
- Character.init(_: UnicodeScalar)
- Character.init(_builtinExtendedGraphemeClusterLiteral:byteSize:isASCII:)
- Character.init(_builtinUnicodeScalarLiteral:)
- Character.init(extendedGraphemeClusterLiteral:)
- Character.init(unicodeScalarLiteral:)
- Character.writeTo(inout:)
- ClosedInterval.init(_:)
- ClosedInterval.init(_:_:)
- ClosedInterval.clamp(_:)
- ClosedInterval.contains(_:)
- ClosedInterval.overlaps(_:)
- CollectionOfOne.init(_:)
- CollectionOfOne.subscript(_: Index)
- CollectionOfOne.subscript(_: Range<Index>)
- CollectionOfOne.contains(_:)
- CollectionOfOne.dropFirst()
- CollectionOfOne.dropFirst(_:)
- CollectionOfOne.dropLast()
- CollectionOfOne.dropLast(_:)
- CollectionOfOne.elementsEqual(_:isEquivalent:)
- CollectionOfOne.enumerate()
- CollectionOfOne.filter(_:)
- CollectionOfOne.flatMap<T>(_: (Element) throws -> T?)
- CollectionOfOne.flatMap<S : SequenceType>(_: (Element) throws -> S)
- CollectionOfOne.forEach(_:)
- CollectionOfOne.generate()
- CollectionOfOne.indexOf(_:)
- CollectionOfOne.lexicographicalCompare(_:isOrderedBefore:)
- CollectionOfOne.map(_:)
- CollectionOfOne.maxElement(_:)
- CollectionOfOne.minElement(_:)
- CollectionOfOne.prefix(_:)
- CollectionOfOne.prefixThrough(_:)
- CollectionOfOne.prefixUpTo(_:)
- CollectionOfOne.reduce(_:combine:)
- CollectionOfOne.reverse()
- CollectionOfOne.sort(_:)
- CollectionOfOne.split(_:allowEmptySlices:isSeparator:)
- CollectionOfOne.startsWith(_:isEquivalent:)
- CollectionOfOne.suffix(_:)
- CollectionOfOne.suffixFrom(_:)
- CollectionOfOne.underestimateCount()
- CollectionOfOne.flatten()
- CollectionOfOne.lexicographicalCompare(_:)
- CollectionOfOne.maxElement()
- CollectionOfOne.minElement()
- CollectionOfOne.sort()
- CollectionOfOne.elementsEqual(_:)
- CollectionOfOne.split(_:maxSplit:allowEmptySlices:)
- CollectionOfOne.startsWith(_:)
- CollectionOfOne.joinWithSeparator(_:)
- ContiguousArray.init()
- ContiguousArray.init(_:)
- ContiguousArray.init(arrayLiteral:)
- ContiguousArray.init(count:repeatedValue:)
- ContiguousArray.subscript(_: Int)
- ContiguousArray.subscript(_: Range<Int>)
- ContiguousArray.append(_:)
- ContiguousArray.appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_: S)
- ContiguousArray.appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_: C)
- ContiguousArray.appendContentsOf(_:)
- ContiguousArray.contains(_:)
- ContiguousArray.dropFirst()
- ContiguousArray.dropFirst(_:)
- ContiguousArray.dropLast()
- ContiguousArray.dropLast(_:)
- ContiguousArray.elementsEqual(_:isEquivalent:)
- ContiguousArray.enumerate()
- ContiguousArray.filter(_:)
- ContiguousArray.flatMap<T>(_: (Element) throws -> T?)
- ContiguousArray.flatMap<S : SequenceType>(_: (Element) throws -> S)
- ContiguousArray.forEach(_:)
- ContiguousArray.generate()
- ContiguousArray.indexOf(_:)
- ContiguousArray.insert(_:atIndex:)
- ContiguousArray.insertContentsOf(_:at:)
- ContiguousArray.lexicographicalCompare(_:isOrderedBefore:)
- ContiguousArray.map(_:)
- ContiguousArray.maxElement(_:)
- ContiguousArray.minElement(_:)
- ContiguousArray.partition(_:isOrderedBefore:)
- ContiguousArray.popLast()
- ContiguousArray.prefix(_:)
- ContiguousArray.prefixThrough(_:)
- ContiguousArray.prefixUpTo(_:)
- ContiguousArray.reduce(_:combine:)
- ContiguousArray.removeAll(keepCapacity:)
- ContiguousArray.removeAtIndex(_:)
- ContiguousArray.removeFirst()
- ContiguousArray.removeFirst(_:)
- ContiguousArray.removeLast()
- ContiguousArray.removeLast(_:)
- ContiguousArray.removeRange(_:)
- ContiguousArray.replaceRange(_:with:)
- ContiguousArray.reserveCapacity(_:)
- ContiguousArray.reverse()
- ContiguousArray.sort(_:)
- ContiguousArray.sortInPlace(_:)
- ContiguousArray.split(_:allowEmptySlices:isSeparator:)
- ContiguousArray.startsWith(_:isEquivalent:)
- ContiguousArray.suffix(_:)
- ContiguousArray.suffixFrom(_:)
- ContiguousArray.underestimateCount()
- ContiguousArray.withUnsafeBufferPointer(_:)
- ContiguousArray.withUnsafeMutableBufferPointer(_:)
- ContiguousArray.flatten()
- ContiguousArray.lexicographicalCompare(_:)
- ContiguousArray.maxElement()
- ContiguousArray.minElement()
- ContiguousArray.sort()
- ContiguousArray.elementsEqual(_:)
- ContiguousArray.split(_:maxSplit:allowEmptySlices:)
- ContiguousArray.startsWith(_:)
- ContiguousArray.joinWithSeparator(_:)
- ContiguousArray.partition(_:)
- ContiguousArray.sortInPlace()
- COpaquePointer.init()
- COpaquePointer.init<T>(_: UnsafeMutablePointer<T>)
- COpaquePointer.init<T>(_: UnsafePointer<T>)
- COpaquePointer.init(bitPattern: Int)
- COpaquePointer.init(bitPattern: UInt)
- COpaquePointer.init(nilLiteral:)
- CVaListPointer.init(_fromUnsafeMutablePointer:)
- Dictionary.init()
- Dictionary.init(dictionaryLiteral:)
- Dictionary.init(minimumCapacity:)
- Dictionary.subscript(_: DictionaryIndex<Key, Value>)
- Dictionary.subscript(_: Key)
- Dictionary.subscript(_: Range<DictionaryIndex<Key, Value>>)
- Dictionary.contains(_:)
- Dictionary.dropFirst()
- Dictionary.dropFirst(_:)
- Dictionary.dropLast()
- Dictionary.dropLast(_:)
- Dictionary.elementsEqual(_:isEquivalent:)
- Dictionary.enumerate()
- Dictionary.filter(_:)
- Dictionary.flatMap<T>(_: ((Key, Value)) throws -> T?)
- Dictionary.flatMap<S : SequenceType>(_: ((Key, Value)) throws -> S)
- Dictionary.forEach(_:)
- Dictionary.generate()
- Dictionary.indexForKey(_:)
- Dictionary.indexOf(_:)
- Dictionary.lexicographicalCompare(_:isOrderedBefore:)
- Dictionary.map(_:)
- Dictionary.maxElement(_:)
- Dictionary.minElement(_:)
- Dictionary.popFirst()
- Dictionary.prefix(_:)
- Dictionary.prefixThrough(_:)
- Dictionary.prefixUpTo(_:)
- Dictionary.reduce(_:combine:)
- Dictionary.removeAll(keepCapacity:)
- Dictionary.removeAtIndex(_:)
- Dictionary.removeValueForKey(_:)
- Dictionary.reverse()
- Dictionary.sort(_:)
- Dictionary.split(_:allowEmptySlices:isSeparator:)
- Dictionary.startsWith(_:isEquivalent:)
- Dictionary.suffix(_:)
- Dictionary.suffixFrom(_:)
- Dictionary.underestimateCount()
- Dictionary.updateValue(_:forKey:)
- DictionaryGenerator.next()
- DictionaryIndex.advancedBy(_:)
- DictionaryIndex.advancedBy(_:limit:)
- DictionaryIndex.distanceTo(_:)
- DictionaryIndex.successor()
- DictionaryLiteral.init(dictionaryLiteral:)
- DictionaryLiteral.subscript(_: Int)
- DictionaryLiteral.subscript(_: Range<Int>)
- DictionaryLiteral.contains(_:)
- DictionaryLiteral.dropFirst()
- DictionaryLiteral.dropFirst(_:)
- DictionaryLiteral.dropLast()
- DictionaryLiteral.dropLast(_:)
- DictionaryLiteral.elementsEqual(_:isEquivalent:)
- DictionaryLiteral.enumerate()
- DictionaryLiteral.filter(_:)
- DictionaryLiteral.flatMap<T>(_: ((Key, Value)) throws -> T?)
- DictionaryLiteral.flatMap<S : SequenceType>(_: ((Key, Value)) throws -> S)
- DictionaryLiteral.forEach(_:)
- DictionaryLiteral.generate()
- DictionaryLiteral.indexOf(_:)
- DictionaryLiteral.lexicographicalCompare(_:isOrderedBefore:)
- DictionaryLiteral.map(_:)
- DictionaryLiteral.maxElement(_:)
- DictionaryLiteral.minElement(_:)
- DictionaryLiteral.prefix(_:)
- DictionaryLiteral.prefixThrough(_:)
- DictionaryLiteral.prefixUpTo(_:)
- DictionaryLiteral.reduce(_:combine:)
- DictionaryLiteral.reverse()
- DictionaryLiteral.sort(_:)
- DictionaryLiteral.split(_:allowEmptySlices:isSeparator:)
- DictionaryLiteral.startsWith(_:isEquivalent:)
- DictionaryLiteral.suffix(_:)
- DictionaryLiteral.suffixFrom(_:)
- DictionaryLiteral.underestimateCount()
- Double.init()
- Double.init(_: Double)
- Double.init(_: Float)
- Double.init(_: Float80)
- Double.init(_: Int)
- Double.init(_: Int8)
- Double.init(_: Int16)
- Double.init(_: Int32)
- Double.init(_: Int64)
- Double.init(_: NSNumber)
- Double.init(_: UInt)
- Double.init(_: UInt8)
- Double.init(_: UInt16)
- Double.init(_: UInt32)
- Double.init(_: UInt64)
- Double.init(_bits:)
- Double.init(_builtinFloatLiteral:)
- Double.init(_builtinIntegerLiteral:)
- Double.init(floatLiteral:)
- Double.init(integerLiteral:)
- Double.init?(_:)
- Double.abs(_:)
- Double.advancedBy(_:)
- Double.distanceTo(_:)
- Double.stride(through:by:)
- Double.stride(to:by:)
- EmptyCollection.init()
- EmptyCollection.subscript(_: Index)
- EmptyCollection.subscript(_: Range<Index>)
- EmptyCollection.contains(_:)
- EmptyCollection.dropFirst()
- EmptyCollection.dropFirst(_:)
- EmptyCollection.dropLast()
- EmptyCollection.dropLast(_:)
- EmptyCollection.elementsEqual(_:isEquivalent:)
- EmptyCollection.enumerate()
- EmptyCollection.filter(_:)
- EmptyCollection.flatMap<T>(_: (Element) throws -> T?)
- EmptyCollection.flatMap<S : SequenceType>(_: (Element) throws -> S)
- EmptyCollection.forEach(_:)
- EmptyCollection.generate()
- EmptyCollection.indexOf(_:)
- EmptyCollection.lexicographicalCompare(_:isOrderedBefore:)
- EmptyCollection.map(_:)
- EmptyCollection.maxElement(_:)
- EmptyCollection.minElement(_:)
- EmptyCollection.prefix(_:)
- EmptyCollection.prefixThrough(_:)
- EmptyCollection.prefixUpTo(_:)
- EmptyCollection.reduce(_:combine:)
- EmptyCollection.reverse()
- EmptyCollection.sort(_:)
- EmptyCollection.split(_:allowEmptySlices:isSeparator:)
- EmptyCollection.startsWith(_:isEquivalent:)
- EmptyCollection.suffix(_:)
- EmptyCollection.suffixFrom(_:)
- EmptyCollection.underestimateCount()
- EmptyCollection.flatten()
- EmptyCollection.lexicographicalCompare(_:)
- EmptyCollection.maxElement()
- EmptyCollection.minElement()
- EmptyCollection.sort()
- EmptyCollection.elementsEqual(_:)
- EmptyCollection.split(_:maxSplit:allowEmptySlices:)
- EmptyCollection.startsWith(_:)
- EmptyCollection.joinWithSeparator(_:)
- EmptyGenerator.init()
- EmptyGenerator.contains(_:)
- EmptyGenerator.dropFirst()
- EmptyGenerator.dropFirst(_:)
- EmptyGenerator.dropLast()
- EmptyGenerator.dropLast(_:)
- EmptyGenerator.elementsEqual(_:isEquivalent:)
- EmptyGenerator.enumerate()
- EmptyGenerator.filter(_:)
- EmptyGenerator.flatMap<T>(_: (Generator.Element) throws -> T?)
- EmptyGenerator.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- EmptyGenerator.forEach(_:)
- EmptyGenerator.lexicographicalCompare(_:isOrderedBefore:)
- EmptyGenerator.map(_:)
- EmptyGenerator.maxElement(_:)
- EmptyGenerator.minElement(_:)
- EmptyGenerator.next()
- EmptyGenerator.prefix(_:)
- EmptyGenerator.reduce(_:combine:)
- EmptyGenerator.reverse()
- EmptyGenerator.sort(_:)
- EmptyGenerator.split(_:allowEmptySlices:isSeparator:)
- EmptyGenerator.startsWith(_:isEquivalent:)
- EmptyGenerator.suffix(_:)
- EmptyGenerator.underestimateCount()
- EmptyGenerator.generate()
- EmptyGenerator.lexicographicalCompare(_:)
- EmptyGenerator.maxElement()
- EmptyGenerator.minElement()
- EmptyGenerator.sort()
- EmptyGenerator.elementsEqual(_:)
- EmptyGenerator.split(_:maxSplit:allowEmptySlices:)
- EmptyGenerator.startsWith(_:)
- EmptyGenerator.flatten()
- EmptyGenerator.joinWithSeparator(_:)
- EnumerateGenerator.init(_:)
- EnumerateGenerator.contains(_:)
- EnumerateGenerator.dropFirst()
- EnumerateGenerator.dropFirst(_:)
- EnumerateGenerator.dropLast()
- EnumerateGenerator.dropLast(_:)
- EnumerateGenerator.elementsEqual(_:isEquivalent:)
- EnumerateGenerator.enumerate()
- EnumerateGenerator.filter(_:)
- EnumerateGenerator.flatMap<T>(_: ((index: Int, element: Base.Element)) throws -> T?)
- EnumerateGenerator.flatMap<S : SequenceType>(_: ((index: Int, element: Base.Element)) throws -> S)
- EnumerateGenerator.forEach(_:)
- EnumerateGenerator.lexicographicalCompare(_:isOrderedBefore:)
- EnumerateGenerator.map(_:)
- EnumerateGenerator.maxElement(_:)
- EnumerateGenerator.minElement(_:)
- EnumerateGenerator.next()
- EnumerateGenerator.prefix(_:)
- EnumerateGenerator.reduce(_:combine:)
- EnumerateGenerator.reverse()
- EnumerateGenerator.sort(_:)
- EnumerateGenerator.split(_:allowEmptySlices:isSeparator:)
- EnumerateGenerator.startsWith(_:isEquivalent:)
- EnumerateGenerator.suffix(_:)
- EnumerateGenerator.underestimateCount()
- EnumerateGenerator.generate()
- EnumerateSequence.init(_:)
- EnumerateSequence.contains(_:)
- EnumerateSequence.dropFirst()
- EnumerateSequence.dropFirst(_:)
- EnumerateSequence.dropLast()
- EnumerateSequence.dropLast(_:)
- EnumerateSequence.elementsEqual(_:isEquivalent:)
- EnumerateSequence.enumerate()
- EnumerateSequence.filter(_:)
- EnumerateSequence.flatMap<T>(_: (Generator.Element) throws -> T?)
- EnumerateSequence.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- EnumerateSequence.forEach(_:)
- EnumerateSequence.generate()
- EnumerateSequence.lexicographicalCompare(_:isOrderedBefore:)
- EnumerateSequence.map(_:)
- EnumerateSequence.maxElement(_:)
- EnumerateSequence.minElement(_:)
- EnumerateSequence.prefix(_:)
- EnumerateSequence.reduce(_:combine:)
- EnumerateSequence.reverse()
- EnumerateSequence.sort(_:)
- EnumerateSequence.split(_:allowEmptySlices:isSeparator:)
- EnumerateSequence.startsWith(_:isEquivalent:)
- EnumerateSequence.suffix(_:)
- EnumerateSequence.underestimateCount()
- EnumerateSequence.lexicographicalCompare(_:)
- EnumerateSequence.maxElement()
- EnumerateSequence.minElement()
- EnumerateSequence.sort()
- EnumerateSequence.elementsEqual(_:)
- EnumerateSequence.split(_:maxSplit:allowEmptySlices:)
- EnumerateSequence.startsWith(_:)
- EnumerateSequence.flatten()
- EnumerateSequence.joinWithSeparator(_:)
- FlattenBidirectionalCollection.init(_:)
- FlattenBidirectionalCollection.subscript(_: FlattenBidirectionalCollectionIndex<Base>)
- FlattenBidirectionalCollection.subscript(_: Range<FlattenBidirectionalCollectionIndex<Base>>)
- FlattenBidirectionalCollection.contains(_:)
- FlattenBidirectionalCollection.dropFirst()
- FlattenBidirectionalCollection.dropFirst(_:)
- FlattenBidirectionalCollection.dropLast()
- FlattenBidirectionalCollection.dropLast(_:)
- FlattenBidirectionalCollection.elementsEqual(_:isEquivalent:)
- FlattenBidirectionalCollection.enumerate()
- FlattenBidirectionalCollection.filter(_:)
- FlattenBidirectionalCollection.flatMap<T>(_: (Base.Generator.Element.Generator.Element) throws -> T?)
- FlattenBidirectionalCollection.flatMap<S : SequenceType>(_: (Base.Generator.Element.Generator.Element) throws -> S)
- FlattenBidirectionalCollection.forEach(_:)
- FlattenBidirectionalCollection.generate()
- FlattenBidirectionalCollection.indexOf(_:)
- FlattenBidirectionalCollection.lexicographicalCompare(_:isOrderedBefore:)
- FlattenBidirectionalCollection.map(_:)
- FlattenBidirectionalCollection.maxElement(_:)
- FlattenBidirectionalCollection.minElement(_:)
- FlattenBidirectionalCollection.prefix(_:)
- FlattenBidirectionalCollection.prefixThrough(_:)
- FlattenBidirectionalCollection.prefixUpTo(_:)
- FlattenBidirectionalCollection.reduce(_:combine:)
- FlattenBidirectionalCollection.reverse()
- FlattenBidirectionalCollection.sort(_:)
- FlattenBidirectionalCollection.split(_:allowEmptySlices:isSeparator:)
- FlattenBidirectionalCollection.startsWith(_:isEquivalent:)
- FlattenBidirectionalCollection.suffix(_:)
- FlattenBidirectionalCollection.suffixFrom(_:)
- FlattenBidirectionalCollection.underestimateCount()
- FlattenBidirectionalCollection.flatten()
- FlattenBidirectionalCollection.lexicographicalCompare(_:)
- FlattenBidirectionalCollection.maxElement()
- FlattenBidirectionalCollection.minElement()
- FlattenBidirectionalCollection.sort()
- FlattenBidirectionalCollection.elementsEqual(_:)
- FlattenBidirectionalCollection.split(_:maxSplit:allowEmptySlices:)
- FlattenBidirectionalCollection.startsWith(_:)
- FlattenBidirectionalCollection.joinWithSeparator(_:)
- FlattenBidirectionalCollectionIndex.advancedBy(_:)
- FlattenBidirectionalCollectionIndex.advancedBy(_:limit:)
- FlattenBidirectionalCollectionIndex.distanceTo(_:)
- FlattenBidirectionalCollectionIndex.predecessor()
- FlattenBidirectionalCollectionIndex.successor()
- FlattenCollection.init(_:)
- FlattenCollection.subscript(_: FlattenCollectionIndex<Base>)
- FlattenCollection.subscript(_: Range<FlattenCollectionIndex<Base>>)
- FlattenCollection.contains(_:)
- FlattenCollection.dropFirst()
- FlattenCollection.dropFirst(_:)
- FlattenCollection.dropLast()
- FlattenCollection.dropLast(_:)
- FlattenCollection.elementsEqual(_:isEquivalent:)
- FlattenCollection.enumerate()
- FlattenCollection.filter(_:)
- FlattenCollection.flatMap<T>(_: (Base.Generator.Element.Generator.Element) throws -> T?)
- FlattenCollection.flatMap<S : SequenceType>(_: (Base.Generator.Element.Generator.Element) throws -> S)
- FlattenCollection.forEach(_:)
- FlattenCollection.generate()
- FlattenCollection.indexOf(_:)
- FlattenCollection.lexicographicalCompare(_:isOrderedBefore:)
- FlattenCollection.map(_:)
- FlattenCollection.maxElement(_:)
- FlattenCollection.minElement(_:)
- FlattenCollection.prefix(_:)
- FlattenCollection.prefixThrough(_:)
- FlattenCollection.prefixUpTo(_:)
- FlattenCollection.reduce(_:combine:)
- FlattenCollection.reverse()
- FlattenCollection.sort(_:)
- FlattenCollection.split(_:allowEmptySlices:isSeparator:)
- FlattenCollection.startsWith(_:isEquivalent:)
- FlattenCollection.suffix(_:)
- FlattenCollection.suffixFrom(_:)
- FlattenCollection.underestimateCount()
- FlattenCollection.flatten()
- FlattenCollection.lexicographicalCompare(_:)
- FlattenCollection.maxElement()
- FlattenCollection.minElement()
- FlattenCollection.sort()
- FlattenCollection.elementsEqual(_:)
- FlattenCollection.split(_:maxSplit:allowEmptySlices:)
- FlattenCollection.startsWith(_:)
- FlattenCollection.joinWithSeparator(_:)
- FlattenCollectionIndex.advancedBy(_:)
- FlattenCollectionIndex.advancedBy(_:limit:)
- FlattenCollectionIndex.distanceTo(_:)
- FlattenCollectionIndex.successor()
- FlattenGenerator.init(_:)
- FlattenGenerator.contains(_:)
- FlattenGenerator.dropFirst()
- FlattenGenerator.dropFirst(_:)
- FlattenGenerator.dropLast()
- FlattenGenerator.dropLast(_:)
- FlattenGenerator.elementsEqual(_:isEquivalent:)
- FlattenGenerator.enumerate()
- FlattenGenerator.filter(_:)
- FlattenGenerator.flatMap<T>(_: (Generator.Element) throws -> T?)
- FlattenGenerator.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- FlattenGenerator.forEach(_:)
- FlattenGenerator.lexicographicalCompare(_:isOrderedBefore:)
- FlattenGenerator.map(_:)
- FlattenGenerator.maxElement(_:)
- FlattenGenerator.minElement(_:)
- FlattenGenerator.next()
- FlattenGenerator.prefix(_:)
- FlattenGenerator.reduce(_:combine:)
- FlattenGenerator.reverse()
- FlattenGenerator.sort(_:)
- FlattenGenerator.split(_:allowEmptySlices:isSeparator:)
- FlattenGenerator.startsWith(_:isEquivalent:)
- FlattenGenerator.suffix(_:)
- FlattenGenerator.underestimateCount()
- FlattenGenerator.generate()
- FlattenGenerator.lexicographicalCompare(_:)
- FlattenGenerator.maxElement()
- FlattenGenerator.minElement()
- FlattenGenerator.sort()
- FlattenGenerator.elementsEqual(_:)
- FlattenGenerator.split(_:maxSplit:allowEmptySlices:)
- FlattenGenerator.startsWith(_:)
- FlattenGenerator.flatten()
- FlattenGenerator.joinWithSeparator(_:)
- FlattenSequence.init(_:)
- FlattenSequence.contains(_:)
- FlattenSequence.dropFirst()
- FlattenSequence.dropFirst(_:)
- FlattenSequence.dropLast()
- FlattenSequence.dropLast(_:)
- FlattenSequence.elementsEqual(_:isEquivalent:)
- FlattenSequence.enumerate()
- FlattenSequence.filter(_:)
- FlattenSequence.flatMap<T>(_: (Generator.Element) throws -> T?)
- FlattenSequence.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- FlattenSequence.forEach(_:)
- FlattenSequence.generate()
- FlattenSequence.lexicographicalCompare(_:isOrderedBefore:)
- FlattenSequence.map(_:)
- FlattenSequence.maxElement(_:)
- FlattenSequence.minElement(_:)
- FlattenSequence.prefix(_:)
- FlattenSequence.reduce(_:combine:)
- FlattenSequence.reverse()
- FlattenSequence.sort(_:)
- FlattenSequence.split(_:allowEmptySlices:isSeparator:)
- FlattenSequence.startsWith(_:isEquivalent:)
- FlattenSequence.suffix(_:)
- FlattenSequence.underestimateCount()
- FlattenSequence.lexicographicalCompare(_:)
- FlattenSequence.maxElement()
- FlattenSequence.minElement()
- FlattenSequence.sort()
- FlattenSequence.elementsEqual(_:)
- FlattenSequence.split(_:maxSplit:allowEmptySlices:)
- FlattenSequence.startsWith(_:)
- FlattenSequence.flatten()
- FlattenSequence.joinWithSeparator(_:)
- Float.init()
- Float.init(_: Double)
- Float.init(_: Float)
- Float.init(_: Float80)
- Float.init(_: Int)
- Float.init(_: Int8)
- Float.init(_: Int16)
- Float.init(_: Int32)
- Float.init(_: Int64)
- Float.init(_: NSNumber)
- Float.init(_: UInt)
- Float.init(_: UInt8)
- Float.init(_: UInt16)
- Float.init(_: UInt32)
- Float.init(_: UInt64)
- Float.init(_bits:)
- Float.init(_builtinFloatLiteral:)
- Float.init(_builtinIntegerLiteral:)
- Float.init(floatLiteral:)
- Float.init(integerLiteral:)
- Float.init?(_:)
- Float.abs(_:)
- Float.advancedBy(_:)
- Float.distanceTo(_:)
- Float.stride(through:by:)
- Float.stride(to:by:)
- Float80.init()
- Float80.init(_: Double)
- Float80.init(_: Float)
- Float80.init(_: Float80)
- Float80.init(_: Int)
- Float80.init(_: Int8)
- Float80.init(_: Int16)
- Float80.init(_: Int32)
- Float80.init(_: Int64)
- Float80.init(_: UInt)
- Float80.init(_: UInt8)
- Float80.init(_: UInt16)
- Float80.init(_: UInt32)
- Float80.init(_: UInt64)
- Float80.init(_bits:)
- Float80.init(_builtinFloatLiteral:)
- Float80.init(_builtinIntegerLiteral:)
- Float80.init(floatLiteral:)
- Float80.init(integerLiteral:)
- Float80.init?(_:)
- Float80.abs(_:)
- Float80.advancedBy(_:)
- Float80.distanceTo(_:)
- Float80.stride(through:by:)
- Float80.stride(to:by:)
- GeneratorOfOne.init(_:)
- GeneratorOfOne.contains(_:)
- GeneratorOfOne.dropFirst()
- GeneratorOfOne.dropFirst(_:)
- GeneratorOfOne.dropLast()
- GeneratorOfOne.dropLast(_:)
- GeneratorOfOne.elementsEqual(_:isEquivalent:)
- GeneratorOfOne.enumerate()
- GeneratorOfOne.filter(_:)
- GeneratorOfOne.flatMap<T>(_: (Generator.Element) throws -> T?)
- GeneratorOfOne.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- GeneratorOfOne.forEach(_:)
- GeneratorOfOne.lexicographicalCompare(_:isOrderedBefore:)
- GeneratorOfOne.map(_:)
- GeneratorOfOne.maxElement(_:)
- GeneratorOfOne.minElement(_:)
- GeneratorOfOne.next()
- GeneratorOfOne.prefix(_:)
- GeneratorOfOne.reduce(_:combine:)
- GeneratorOfOne.reverse()
- GeneratorOfOne.sort(_:)
- GeneratorOfOne.split(_:allowEmptySlices:isSeparator:)
- GeneratorOfOne.startsWith(_:isEquivalent:)
- GeneratorOfOne.suffix(_:)
- GeneratorOfOne.underestimateCount()
- GeneratorOfOne.generate()
- GeneratorOfOne.lexicographicalCompare(_:)
- GeneratorOfOne.maxElement()
- GeneratorOfOne.minElement()
- GeneratorOfOne.sort()
- GeneratorOfOne.elementsEqual(_:)
- GeneratorOfOne.split(_:maxSplit:allowEmptySlices:)
- GeneratorOfOne.startsWith(_:)
- GeneratorOfOne.flatten()
- GeneratorOfOne.joinWithSeparator(_:)
- GeneratorSequence.init(_:)
- GeneratorSequence.contains(_:)
- GeneratorSequence.dropFirst()
- GeneratorSequence.dropFirst(_:)
- GeneratorSequence.dropLast()
- GeneratorSequence.dropLast(_:)
- GeneratorSequence.elementsEqual(_:isEquivalent:)
- GeneratorSequence.enumerate()
- GeneratorSequence.filter(_:)
- GeneratorSequence.flatMap<T>(_: (Generator.Element) throws -> T?)
- GeneratorSequence.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- GeneratorSequence.forEach(_:)
- GeneratorSequence.lexicographicalCompare(_:isOrderedBefore:)
- GeneratorSequence.map(_:)
- GeneratorSequence.maxElement(_:)
- GeneratorSequence.minElement(_:)
- GeneratorSequence.next()
- GeneratorSequence.prefix(_:)
- GeneratorSequence.reduce(_:combine:)
- GeneratorSequence.reverse()
- GeneratorSequence.sort(_:)
- GeneratorSequence.split(_:allowEmptySlices:isSeparator:)
- GeneratorSequence.startsWith(_:isEquivalent:)
- GeneratorSequence.suffix(_:)
- GeneratorSequence.underestimateCount()
- GeneratorSequence.generate()
- GeneratorSequence.lexicographicalCompare(_:)
- GeneratorSequence.maxElement()
- GeneratorSequence.minElement()
- GeneratorSequence.sort()
- GeneratorSequence.elementsEqual(_:)
- GeneratorSequence.split(_:maxSplit:allowEmptySlices:)
- GeneratorSequence.startsWith(_:)
- GeneratorSequence.flatten()
- GeneratorSequence.joinWithSeparator(_:)
- HalfOpenInterval.init(_:)
- HalfOpenInterval.init(_:_:)
- HalfOpenInterval.clamp(_:)
- HalfOpenInterval.contains(_:)
- HalfOpenInterval.overlaps(_:)
- ImplicitlyUnwrappedOptional.init()
- ImplicitlyUnwrappedOptional.init(_: Wrapped)
- ImplicitlyUnwrappedOptional.init(_: Wrapped?)
- ImplicitlyUnwrappedOptional.init(nilLiteral:)
- ImplicitlyUnwrappedOptional.flatMap(_:)
- ImplicitlyUnwrappedOptional.map(_:)
- IndexingGenerator.init(_:)
- IndexingGenerator.contains(_:)
- IndexingGenerator.dropFirst()
- IndexingGenerator.dropFirst(_:)
- IndexingGenerator.dropLast()
- IndexingGenerator.dropLast(_:)
- IndexingGenerator.elementsEqual(_:isEquivalent:)
- IndexingGenerator.enumerate()
- IndexingGenerator.filter(_:)
- IndexingGenerator.flatMap<T>(_: (Generator.Element) throws -> T?)
- IndexingGenerator.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- IndexingGenerator.forEach(_:)
- IndexingGenerator.lexicographicalCompare(_:isOrderedBefore:)
- IndexingGenerator.map(_:)
- IndexingGenerator.maxElement(_:)
- IndexingGenerator.minElement(_:)
- IndexingGenerator.next()
- IndexingGenerator.prefix(_:)
- IndexingGenerator.reduce(_:combine:)
- IndexingGenerator.reverse()
- IndexingGenerator.sort(_:)
- IndexingGenerator.split(_:allowEmptySlices:isSeparator:)
- IndexingGenerator.startsWith(_:isEquivalent:)
- IndexingGenerator.suffix(_:)
- IndexingGenerator.underestimateCount()
- IndexingGenerator.generate()
- IndexingGenerator.lexicographicalCompare(_:)
- IndexingGenerator.maxElement()
- IndexingGenerator.minElement()
- IndexingGenerator.sort()
- IndexingGenerator.elementsEqual(_:)
- IndexingGenerator.split(_:maxSplit:allowEmptySlices:)
- IndexingGenerator.startsWith(_:)
- IndexingGenerator.flatten()
- IndexingGenerator.joinWithSeparator(_:)
- Int.init()
- Int.init(_: Builtin.Word)
- Int.init(_: Double)
- Int.init(_: Float)
- Int.init(_: Float80)
- Int.init(_: Int)
- Int.init(_: Int8)
- Int.init(_: Int16)
- Int.init(_: Int32)
- Int.init(_: Int64)
- Int.init(_: UInt)
- Int.init(_: UInt8)
- Int.init(_: UInt16)
- Int.init(_: UInt32)
- Int.init(_: UInt64)
- Int.init(_builtinIntegerLiteral:)
- Int.init(bigEndian:)
- Int.init(bitPattern:)
- Int.init(integerLiteral:)
- Int.init(littleEndian:)
- Int.init(truncatingBitPattern: Int64)
- Int.init(truncatingBitPattern: UInt64)
- Int.init?(_:radix:)
- Int.addWithOverflow(_:_:)
- Int.divideWithOverflow(_:_:)
- Int.multiplyWithOverflow(_:_:)
- Int.remainderWithOverflow(_:_:)
- Int.subtractWithOverflow(_:_:)
- Int.advancedBy(_:)
- Int.advancedBy(_:limit:)
- Int.distanceTo(_:)
- Int.predecessor()
- Int.stride(through:by:)
- Int.stride(to:by:)
- Int.successor()
- Int.toIntMax()
- Int16.init()
- Int16.init(_: Double)
- Int16.init(_: Float)
- Int16.init(_: Float80)
- Int16.init(_: Int)
- Int16.init(_: Int8)
- Int16.init(_: Int16)
- Int16.init(_: Int32)
- Int16.init(_: Int64)
- Int16.init(_: UInt)
- Int16.init(_: UInt8)
- Int16.init(_: UInt16)
- Int16.init(_: UInt32)
- Int16.init(_: UInt64)
- Int16.init(_builtinIntegerLiteral:)
- Int16.init(bigEndian:)
- Int16.init(bitPattern:)
- Int16.init(integerLiteral:)
- Int16.init(littleEndian:)
- Int16.init(truncatingBitPattern: Int)
- Int16.init(truncatingBitPattern: Int32)
- Int16.init(truncatingBitPattern: Int64)
- Int16.init(truncatingBitPattern: UInt)
- Int16.init(truncatingBitPattern: UInt32)
- Int16.init(truncatingBitPattern: UInt64)
- Int16.init?(_:radix:)
- Int16.addWithOverflow(_:_:)
- Int16.divideWithOverflow(_:_:)
- Int16.multiplyWithOverflow(_:_:)
- Int16.remainderWithOverflow(_:_:)
- Int16.subtractWithOverflow(_:_:)
- Int16.advancedBy(_:)
- Int16.advancedBy(_:limit:)
- Int16.distanceTo(_:)
- Int16.predecessor()
- Int16.stride(through:by:)
- Int16.stride(to:by:)
- Int16.successor()
- Int16.toIntMax()
- Int32.init()
- Int32.init(_: Double)
- Int32.init(_: Float)
- Int32.init(_: Float80)
- Int32.init(_: Int)
- Int32.init(_: Int8)
- Int32.init(_: Int16)
- Int32.init(_: Int32)
- Int32.init(_: Int64)
- Int32.init(_: UInt)
- Int32.init(_: UInt8)
- Int32.init(_: UInt16)
- Int32.init(_: UInt32)
- Int32.init(_: UInt64)
- Int32.init(_builtinIntegerLiteral:)
- Int32.init(bigEndian:)
- Int32.init(bitPattern:)
- Int32.init(integerLiteral:)
- Int32.init(littleEndian:)
- Int32.init(truncatingBitPattern: Int)
- Int32.init(truncatingBitPattern: Int64)
- Int32.init(truncatingBitPattern: UInt)
- Int32.init(truncatingBitPattern: UInt64)
- Int32.init?(_:radix:)
- Int32.addWithOverflow(_:_:)
- Int32.divideWithOverflow(_:_:)
- Int32.multiplyWithOverflow(_:_:)
- Int32.remainderWithOverflow(_:_:)
- Int32.subtractWithOverflow(_:_:)
- Int32.advancedBy(_:)
- Int32.advancedBy(_:limit:)
- Int32.distanceTo(_:)
- Int32.predecessor()
- Int32.stride(through:by:)
- Int32.stride(to:by:)
- Int32.successor()
- Int32.toIntMax()
- Int64.init()
- Int64.init(_: Double)
- Int64.init(_: Float)
- Int64.init(_: Float80)
- Int64.init(_: Int)
- Int64.init(_: Int8)
- Int64.init(_: Int16)
- Int64.init(_: Int32)
- Int64.init(_: Int64)
- Int64.init(_: UInt)
- Int64.init(_: UInt8)
- Int64.init(_: UInt16)
- Int64.init(_: UInt32)
- Int64.init(_: UInt64)
- Int64.init(_builtinIntegerLiteral:)
- Int64.init(bigEndian:)
- Int64.init(bitPattern:)
- Int64.init(integerLiteral:)
- Int64.init(littleEndian:)
- Int64.init?(_:radix:)
- Int64.addWithOverflow(_:_:)
- Int64.divideWithOverflow(_:_:)
- Int64.multiplyWithOverflow(_:_:)
- Int64.remainderWithOverflow(_:_:)
- Int64.subtractWithOverflow(_:_:)
- Int64.advancedBy(_:)
- Int64.advancedBy(_:limit:)
- Int64.distanceTo(_:)
- Int64.predecessor()
- Int64.stride(through:by:)
- Int64.stride(to:by:)
- Int64.successor()
- Int64.toIntMax()
- Int8.init()
- Int8.init(_: Double)
- Int8.init(_: Float)
- Int8.init(_: Float80)
- Int8.init(_: Int)
- Int8.init(_: Int8)
- Int8.init(_: Int16)
- Int8.init(_: Int32)
- Int8.init(_: Int64)
- Int8.init(_: UInt)
- Int8.init(_: UInt8)
- Int8.init(_: UInt16)
- Int8.init(_: UInt32)
- Int8.init(_: UInt64)
- Int8.init(_builtinIntegerLiteral:)
- Int8.init(bitPattern:)
- Int8.init(integerLiteral:)
- Int8.init(truncatingBitPattern: Int)
- Int8.init(truncatingBitPattern: Int16)
- Int8.init(truncatingBitPattern: Int32)
- Int8.init(truncatingBitPattern: Int64)
- Int8.init(truncatingBitPattern: UInt)
- Int8.init(truncatingBitPattern: UInt16)
- Int8.init(truncatingBitPattern: UInt32)
- Int8.init(truncatingBitPattern: UInt64)
- Int8.init?(_:radix:)
- Int8.addWithOverflow(_:_:)
- Int8.divideWithOverflow(_:_:)
- Int8.multiplyWithOverflow(_:_:)
- Int8.remainderWithOverflow(_:_:)
- Int8.subtractWithOverflow(_:_:)
- Int8.advancedBy(_:)
- Int8.advancedBy(_:limit:)
- Int8.distanceTo(_:)
- Int8.predecessor()
- Int8.stride(through:by:)
- Int8.stride(to:by:)
- Int8.successor()
- Int8.toIntMax()
- JoinGenerator.init(base:separator:)
- JoinGenerator.next()
- JoinSequence.init(base:separator:)
- JoinSequence.contains(_:)
- JoinSequence.dropFirst()
- JoinSequence.dropFirst(_:)
- JoinSequence.dropLast()
- JoinSequence.dropLast(_:)
- JoinSequence.elementsEqual(_:isEquivalent:)
- JoinSequence.enumerate()
- JoinSequence.filter(_:)
- JoinSequence.flatMap<T>(_: (Generator.Element) throws -> T?)
- JoinSequence.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- JoinSequence.forEach(_:)
- JoinSequence.generate()
- JoinSequence.lexicographicalCompare(_:isOrderedBefore:)
- JoinSequence.map(_:)
- JoinSequence.maxElement(_:)
- JoinSequence.minElement(_:)
- JoinSequence.prefix(_:)
- JoinSequence.reduce(_:combine:)
- JoinSequence.reverse()
- JoinSequence.sort(_:)
- JoinSequence.split(_:allowEmptySlices:isSeparator:)
- JoinSequence.startsWith(_:isEquivalent:)
- JoinSequence.suffix(_:)
- JoinSequence.underestimateCount()
- JoinSequence.lexicographicalCompare(_:)
- JoinSequence.maxElement()
- JoinSequence.minElement()
- JoinSequence.sort()
- JoinSequence.elementsEqual(_:)
- JoinSequence.split(_:maxSplit:allowEmptySlices:)
- JoinSequence.startsWith(_:)
- JoinSequence.flatten()
- JoinSequence.joinWithSeparator(_:)
- LazyCollection.init(_:)
- LazyCollection.subscript(_: Base.Index)
- LazyCollection.subscript(_: Range<Base.Index>)
- LazyCollection.contains(_:)
- LazyCollection.dropFirst()
- LazyCollection.dropFirst(_:)
- LazyCollection.dropLast()
- LazyCollection.dropLast(_:)
- LazyCollection.elementsEqual(_:isEquivalent:)
- LazyCollection.enumerate()
- LazyCollection.filter(_:)
- LazyCollection.flatMap<T>(_: (Base.Generator.Element) throws -> T?)
- LazyCollection.flatMap<S : SequenceType>(_: (Base.Generator.Element) throws -> S)
- LazyCollection.flatMap(_:)
- LazyCollection.forEach(_:)
- LazyCollection.generate()
- LazyCollection.indexOf(_:)
- LazyCollection.lexicographicalCompare(_:isOrderedBefore:)
- LazyCollection.map(_:)
- LazyCollection.maxElement(_:)
- LazyCollection.minElement(_:)
- LazyCollection.popFirst()
- LazyCollection.popLast()
- LazyCollection.prefix(_:)
- LazyCollection.prefixThrough(_:)
- LazyCollection.prefixUpTo(_:)
- LazyCollection.reduce(_:combine:)
- LazyCollection.removeFirst()
- LazyCollection.removeFirst(_:)
- LazyCollection.reverse()
- LazyCollection.sort(_:)
- LazyCollection.split(_:allowEmptySlices:isSeparator:)
- LazyCollection.startsWith(_:isEquivalent:)
- LazyCollection.suffix(_:)
- LazyCollection.suffixFrom(_:)
- LazyCollection.underestimateCount()
- LazyCollection.flatten()
- LazyCollection.lexicographicalCompare(_:)
- LazyCollection.maxElement()
- LazyCollection.minElement()
- LazyCollection.sort()
- LazyCollection.elementsEqual(_:)
- LazyCollection.split(_:maxSplit:allowEmptySlices:)
- LazyCollection.startsWith(_:)
- LazyCollection.joinWithSeparator(_:)
- LazyCollection.removeLast()
- LazyCollection.removeLast(_:)
- LazyFilterCollection.init(_:whereElementsSatisfy:)
- LazyFilterCollection.subscript(_: LazyFilterIndex<Base>)
- LazyFilterCollection.subscript(_: Range<LazyFilterIndex<Base>>)
- LazyFilterCollection.contains(_:)
- LazyFilterCollection.dropFirst()
- LazyFilterCollection.dropFirst(_:)
- LazyFilterCollection.dropLast()
- LazyFilterCollection.dropLast(_:)
- LazyFilterCollection.elementsEqual(_:isEquivalent:)
- LazyFilterCollection.enumerate()
- LazyFilterCollection.filter(_:)
- LazyFilterCollection.flatMap<T>(_: (Base.Generator.Element) throws -> T?)
- LazyFilterCollection.flatMap<S : SequenceType>(_: (Base.Generator.Element) throws -> S)
- LazyFilterCollection.flatMap(_:)
- LazyFilterCollection.forEach(_:)
- LazyFilterCollection.generate()
- LazyFilterCollection.indexOf(_:)
- LazyFilterCollection.lexicographicalCompare(_:isOrderedBefore:)
- LazyFilterCollection.map(_:)
- LazyFilterCollection.maxElement(_:)
- LazyFilterCollection.minElement(_:)
- LazyFilterCollection.prefix(_:)
- LazyFilterCollection.prefixThrough(_:)
- LazyFilterCollection.prefixUpTo(_:)
- LazyFilterCollection.reduce(_:combine:)
- LazyFilterCollection.reverse()
- LazyFilterCollection.sort(_:)
- LazyFilterCollection.split(_:allowEmptySlices:isSeparator:)
- LazyFilterCollection.startsWith(_:isEquivalent:)
- LazyFilterCollection.suffix(_:)
- LazyFilterCollection.suffixFrom(_:)
- LazyFilterCollection.underestimateCount()
- LazyFilterCollection.flatten()
- LazyFilterCollection.lexicographicalCompare(_:)
- LazyFilterCollection.maxElement()
- LazyFilterCollection.minElement()
- LazyFilterCollection.sort()
- LazyFilterCollection.elementsEqual(_:)
- LazyFilterCollection.split(_:maxSplit:allowEmptySlices:)
- LazyFilterCollection.startsWith(_:)
- LazyFilterCollection.joinWithSeparator(_:)
- LazyFilterGenerator.init(_:whereElementsSatisfy:)
- LazyFilterGenerator.contains(_:)
- LazyFilterGenerator.dropFirst()
- LazyFilterGenerator.dropFirst(_:)
- LazyFilterGenerator.dropLast()
- LazyFilterGenerator.dropLast(_:)
- LazyFilterGenerator.elementsEqual(_:isEquivalent:)
- LazyFilterGenerator.enumerate()
- LazyFilterGenerator.filter(_:)
- LazyFilterGenerator.flatMap<T>(_: (Generator.Element) throws -> T?)
- LazyFilterGenerator.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- LazyFilterGenerator.forEach(_:)
- LazyFilterGenerator.lexicographicalCompare(_:isOrderedBefore:)
- LazyFilterGenerator.map(_:)
- LazyFilterGenerator.maxElement(_:)
- LazyFilterGenerator.minElement(_:)
- LazyFilterGenerator.next()
- LazyFilterGenerator.prefix(_:)
- LazyFilterGenerator.reduce(_:combine:)
- LazyFilterGenerator.reverse()
- LazyFilterGenerator.sort(_:)
- LazyFilterGenerator.split(_:allowEmptySlices:isSeparator:)
- LazyFilterGenerator.startsWith(_:isEquivalent:)
- LazyFilterGenerator.suffix(_:)
- LazyFilterGenerator.underestimateCount()
- LazyFilterGenerator.generate()
- LazyFilterGenerator.lexicographicalCompare(_:)
- LazyFilterGenerator.maxElement()
- LazyFilterGenerator.minElement()
- LazyFilterGenerator.sort()
- LazyFilterGenerator.elementsEqual(_:)
- LazyFilterGenerator.split(_:maxSplit:allowEmptySlices:)
- LazyFilterGenerator.startsWith(_:)
- LazyFilterGenerator.flatten()
- LazyFilterGenerator.joinWithSeparator(_:)
- LazyFilterIndex.advancedBy(_:)
- LazyFilterIndex.advancedBy(_:limit:)
- LazyFilterIndex.distanceTo(_:)
- LazyFilterIndex.successor()
- LazyFilterSequence.init(_:whereElementsSatisfy:)
- LazyFilterSequence.contains(_:)
- LazyFilterSequence.dropFirst()
- LazyFilterSequence.dropFirst(_:)
- LazyFilterSequence.dropLast()
- LazyFilterSequence.dropLast(_:)
- LazyFilterSequence.elementsEqual(_:isEquivalent:)
- LazyFilterSequence.enumerate()
- LazyFilterSequence.filter(_:)
- LazyFilterSequence.flatMap<T>(_: (Generator.Element) throws -> T?)
- LazyFilterSequence.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- LazyFilterSequence.flatMap(_:)
- LazyFilterSequence.forEach(_:)
- LazyFilterSequence.generate()
- LazyFilterSequence.lexicographicalCompare(_:isOrderedBefore:)
- LazyFilterSequence.map(_:)
- LazyFilterSequence.maxElement(_:)
- LazyFilterSequence.minElement(_:)
- LazyFilterSequence.prefix(_:)
- LazyFilterSequence.reduce(_:combine:)
- LazyFilterSequence.reverse()
- LazyFilterSequence.sort(_:)
- LazyFilterSequence.split(_:allowEmptySlices:isSeparator:)
- LazyFilterSequence.startsWith(_:isEquivalent:)
- LazyFilterSequence.suffix(_:)
- LazyFilterSequence.underestimateCount()
- LazyFilterSequence.flatten()
- LazyFilterSequence.lexicographicalCompare(_:)
- LazyFilterSequence.maxElement()
- LazyFilterSequence.minElement()
- LazyFilterSequence.sort()
- LazyFilterSequence.elementsEqual(_:)
- LazyFilterSequence.split(_:maxSplit:allowEmptySlices:)
- LazyFilterSequence.startsWith(_:)
- LazyFilterSequence.joinWithSeparator(_:)
- LazyMapCollection.init(_:transform:)
- LazyMapCollection.subscript(_: Base.Index)
- LazyMapCollection.subscript(_: Range<Base.Index>)
- LazyMapCollection.contains(_:)
- LazyMapCollection.dropFirst()
- LazyMapCollection.dropFirst(_:)
- LazyMapCollection.dropLast()
- LazyMapCollection.dropLast(_:)
- LazyMapCollection.elementsEqual(_:isEquivalent:)
- LazyMapCollection.enumerate()
- LazyMapCollection.filter(_:)
- LazyMapCollection.flatMap<T>(_: (Element) throws -> T?)
- LazyMapCollection.flatMap<S : SequenceType>(_: (Element) throws -> S)
- LazyMapCollection.flatMap(_:)
- LazyMapCollection.forEach(_:)
- LazyMapCollection.generate()
- LazyMapCollection.indexOf(_:)
- LazyMapCollection.lexicographicalCompare(_:isOrderedBefore:)
- LazyMapCollection.map(_:)
- LazyMapCollection.maxElement(_:)
- LazyMapCollection.minElement(_:)
- LazyMapCollection.prefix(_:)
- LazyMapCollection.prefixThrough(_:)
- LazyMapCollection.prefixUpTo(_:)
- LazyMapCollection.reduce(_:combine:)
- LazyMapCollection.reverse()
- LazyMapCollection.sort(_:)
- LazyMapCollection.split(_:allowEmptySlices:isSeparator:)
- LazyMapCollection.startsWith(_:isEquivalent:)
- LazyMapCollection.suffix(_:)
- LazyMapCollection.suffixFrom(_:)
- LazyMapCollection.underestimateCount()
- LazyMapCollection.flatten()
- LazyMapCollection.lexicographicalCompare(_:)
- LazyMapCollection.maxElement()
- LazyMapCollection.minElement()
- LazyMapCollection.sort()
- LazyMapCollection.elementsEqual(_:)
- LazyMapCollection.split(_:maxSplit:allowEmptySlices:)
- LazyMapCollection.startsWith(_:)
- LazyMapCollection.joinWithSeparator(_:)
- LazyMapGenerator.contains(_:)
- LazyMapGenerator.dropFirst()
- LazyMapGenerator.dropFirst(_:)
- LazyMapGenerator.dropLast()
- LazyMapGenerator.dropLast(_:)
- LazyMapGenerator.elementsEqual(_:isEquivalent:)
- LazyMapGenerator.enumerate()
- LazyMapGenerator.filter(_:)
- LazyMapGenerator.flatMap<T>(_: (Generator.Element) throws -> T?)
- LazyMapGenerator.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- LazyMapGenerator.forEach(_:)
- LazyMapGenerator.lexicographicalCompare(_:isOrderedBefore:)
- LazyMapGenerator.map(_:)
- LazyMapGenerator.maxElement(_:)
- LazyMapGenerator.minElement(_:)
- LazyMapGenerator.next()
- LazyMapGenerator.prefix(_:)
- LazyMapGenerator.reduce(_:combine:)
- LazyMapGenerator.reverse()
- LazyMapGenerator.sort(_:)
- LazyMapGenerator.split(_:allowEmptySlices:isSeparator:)
- LazyMapGenerator.startsWith(_:isEquivalent:)
- LazyMapGenerator.suffix(_:)
- LazyMapGenerator.underestimateCount()
- LazyMapGenerator.generate()
- LazyMapGenerator.lexicographicalCompare(_:)
- LazyMapGenerator.maxElement()
- LazyMapGenerator.minElement()
- LazyMapGenerator.sort()
- LazyMapGenerator.elementsEqual(_:)
- LazyMapGenerator.split(_:maxSplit:allowEmptySlices:)
- LazyMapGenerator.startsWith(_:)
- LazyMapGenerator.flatten()
- LazyMapGenerator.joinWithSeparator(_:)
- LazyMapSequence.init(_:transform:)
- LazyMapSequence.contains(_:)
- LazyMapSequence.dropFirst()
- LazyMapSequence.dropFirst(_:)
- LazyMapSequence.dropLast()
- LazyMapSequence.dropLast(_:)
- LazyMapSequence.elementsEqual(_:isEquivalent:)
- LazyMapSequence.enumerate()
- LazyMapSequence.filter(_:)
- LazyMapSequence.flatMap<T>(_: (Generator.Element) throws -> T?)
- LazyMapSequence.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- LazyMapSequence.flatMap(_:)
- LazyMapSequence.forEach(_:)
- LazyMapSequence.generate()
- LazyMapSequence.lexicographicalCompare(_:isOrderedBefore:)
- LazyMapSequence.map(_:)
- LazyMapSequence.maxElement(_:)
- LazyMapSequence.minElement(_:)
- LazyMapSequence.prefix(_:)
- LazyMapSequence.reduce(_:combine:)
- LazyMapSequence.reverse()
- LazyMapSequence.sort(_:)
- LazyMapSequence.split(_:allowEmptySlices:isSeparator:)
- LazyMapSequence.startsWith(_:isEquivalent:)
- LazyMapSequence.suffix(_:)
- LazyMapSequence.underestimateCount()
- LazyMapSequence.flatten()
- LazyMapSequence.lexicographicalCompare(_:)
- LazyMapSequence.maxElement()
- LazyMapSequence.minElement()
- LazyMapSequence.sort()
- LazyMapSequence.elementsEqual(_:)
- LazyMapSequence.split(_:maxSplit:allowEmptySlices:)
- LazyMapSequence.startsWith(_:)
- LazyMapSequence.joinWithSeparator(_:)
- LazySequence.init(_:)
- LazySequence.contains(_:)
- LazySequence.dropFirst()
- LazySequence.dropFirst(_:)
- LazySequence.dropLast()
- LazySequence.dropLast(_:)
- LazySequence.elementsEqual(_:isEquivalent:)
- LazySequence.enumerate()
- LazySequence.filter(_:)
- LazySequence.flatMap<T>(_: (Generator.Element) throws -> T?)
- LazySequence.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- LazySequence.flatMap(_:)
- LazySequence.forEach(_:)
- LazySequence.lexicographicalCompare(_:isOrderedBefore:)
- LazySequence.map(_:)
- LazySequence.maxElement(_:)
- LazySequence.minElement(_:)
- LazySequence.prefix(_:)
- LazySequence.reduce(_:combine:)
- LazySequence.reverse()
- LazySequence.sort(_:)
- LazySequence.split(_:allowEmptySlices:isSeparator:)
- LazySequence.startsWith(_:isEquivalent:)
- LazySequence.suffix(_:)
- LazySequence.underestimateCount()
- LazySequence.flatten()
- LazySequence.lexicographicalCompare(_:)
- LazySequence.maxElement()
- LazySequence.minElement()
- LazySequence.sort()
- LazySequence.elementsEqual(_:)
- LazySequence.split(_:maxSplit:allowEmptySlices:)
- LazySequence.startsWith(_:)
- LazySequence.joinWithSeparator(_:)
- ManagedBuffer.create(_:initialValue:)
- ManagedBufferPointer.init(bufferClass:minimumCapacity:initialValue:)
- ManagedBufferPointer.init(unsafeBufferObject:)
- ManagedBufferPointer.holdsUniqueOrPinnedReference()
- ManagedBufferPointer.holdsUniqueReference()
- ManagedBufferPointer.withUnsafeMutablePointerToElements(_:)
- ManagedBufferPointer.withUnsafeMutablePointerToValue(_:)
- ManagedBufferPointer.withUnsafeMutablePointers(_:)
- ManagedProtoBuffer.withUnsafeMutablePointerToElements(_:)
- ManagedProtoBuffer.withUnsafeMutablePointerToValue(_:)
- ManagedProtoBuffer.withUnsafeMutablePointers(_:)
- Mirror.init<T>(_: T, children: DictionaryLiteral<String, Any>, displayStyle: Mirror.DisplayStyle?, ancestorRepresentation: Mirror.AncestorRepresentation)
- Mirror.init<T, C : CollectionType where C.Generator.Element == Child>(_: T, children: C, displayStyle: Mirror.DisplayStyle?, ancestorRepresentation: Mirror.AncestorRepresentation)
- Mirror.init(_:unlabeledChildren:displayStyle:ancestorRepresentation:)
- Mirror.init(reflecting:)
- Mirror.customMirror()
- Mirror.descendant(_:_:)
- Mirror.superclassMirror()
- MutableSlice.init(base:bounds:)
- MutableSlice.subscript(_: Base.Index)
- MutableSlice.subscript(_: Range<Base.Index>)
- MutableSlice.contains(_:)
- MutableSlice.dropFirst()
- MutableSlice.dropFirst(_:)
- MutableSlice.dropLast()
- MutableSlice.dropLast(_:)
- MutableSlice.elementsEqual(_:isEquivalent:)
- MutableSlice.enumerate()
- MutableSlice.filter(_:)
- MutableSlice.flatMap<T>(_: (Base._Element) throws -> T?)
- MutableSlice.flatMap<S : SequenceType>(_: (Base._Element) throws -> S)
- MutableSlice.forEach(_:)
- MutableSlice.generate()
- MutableSlice.indexOf(_:)
- MutableSlice.lexicographicalCompare(_:isOrderedBefore:)
- MutableSlice.map(_:)
- MutableSlice.maxElement(_:)
- MutableSlice.minElement(_:)
- MutableSlice.popFirst()
- MutableSlice.popLast()
- MutableSlice.prefix(_:)
- MutableSlice.prefixThrough(_:)
- MutableSlice.prefixUpTo(_:)
- MutableSlice.reduce(_:combine:)
- MutableSlice.removeFirst()
- MutableSlice.removeFirst(_:)
- MutableSlice.reverse()
- MutableSlice.sort(_:)
- MutableSlice.split(_:allowEmptySlices:isSeparator:)
- MutableSlice.startsWith(_:isEquivalent:)
- MutableSlice.suffix(_:)
- MutableSlice.suffixFrom(_:)
- MutableSlice.underestimateCount()
- MutableSlice.flatten()
- MutableSlice.lexicographicalCompare(_:)
- MutableSlice.maxElement()
- MutableSlice.minElement()
- MutableSlice.sort()
- MutableSlice.elementsEqual(_:)
- MutableSlice.split(_:maxSplit:allowEmptySlices:)
- MutableSlice.startsWith(_:)
- MutableSlice.joinWithSeparator(_:)
- MutableSlice.partition(_:isOrderedBefore:)
- MutableSlice.sortInPlace(_:)
- MutableSlice.partition(_:)
- MutableSlice.sortInPlace()
- MutableSlice.removeLast()
- MutableSlice.removeLast(_:)
- NonObjectiveCBase.init()
- ObjectIdentifier.init(_: Any.Type)
- ObjectIdentifier.init(_: AnyObject)
- Optional.init()
- Optional.init(_:)
- Optional.init(nilLiteral:)
- Optional.flatMap(_:)
- Optional.map(_:)
- PermutationGenerator.init(elements:indices:)
- PermutationGenerator.contains(_:)
- PermutationGenerator.dropFirst()
- PermutationGenerator.dropFirst(_:)
- PermutationGenerator.dropLast()
- PermutationGenerator.dropLast(_:)
- PermutationGenerator.elementsEqual(_:isEquivalent:)
- PermutationGenerator.enumerate()
- PermutationGenerator.filter(_:)
- PermutationGenerator.flatMap<T>(_: (C.Generator.Element) throws -> T?)
- PermutationGenerator.flatMap<S : SequenceType>(_: (C.Generator.Element) throws -> S)
- PermutationGenerator.forEach(_:)
- PermutationGenerator.lexicographicalCompare(_:isOrderedBefore:)
- PermutationGenerator.map(_:)
- PermutationGenerator.maxElement(_:)
- PermutationGenerator.minElement(_:)
- PermutationGenerator.next()
- PermutationGenerator.prefix(_:)
- PermutationGenerator.reduce(_:combine:)
- PermutationGenerator.reverse()
- PermutationGenerator.sort(_:)
- PermutationGenerator.split(_:allowEmptySlices:isSeparator:)
- PermutationGenerator.startsWith(_:isEquivalent:)
- PermutationGenerator.suffix(_:)
- PermutationGenerator.underestimateCount()
- PermutationGenerator.generate()
- PermutationGenerator.lexicographicalCompare(_:)
- PermutationGenerator.maxElement()
- PermutationGenerator.minElement()
- PermutationGenerator.sort()
- PermutationGenerator.elementsEqual(_:)
- PermutationGenerator.split(_:maxSplit:allowEmptySlices:)
- PermutationGenerator.startsWith(_:)
- PermutationGenerator.flatten()
- PermutationGenerator.joinWithSeparator(_:)
- PlaygroundQuickLook.init(reflecting:)
- Range.init(_:)
- Range.init(start:end:)
- Range.subscript(_: Element)
- Range.subscript(_: Element._DisabledRangeIndex)
- Range.subscript(_: Range<Element>)
- Range.contains(_:)
- Range.dropFirst()
- Range.dropFirst(_:)
- Range.dropLast()
- Range.dropLast(_:)
- Range.elementsEqual(_:)
- Range.elementsEqual(_:isEquivalent:)
- Range.enumerate()
- Range.filter(_:)
- Range.flatMap<T>(_: (Element) throws -> T?)
- Range.flatMap<S : SequenceType>(_: (Element) throws -> S)
- Range.forEach(_:)
- Range.generate()
- Range.indexOf(_:)
- Range.lexicographicalCompare(_:isOrderedBefore:)
- Range.map(_:)
- Range.maxElement(_:)
- Range.minElement(_:)
- Range.prefix(_:)
- Range.prefixThrough(_:)
- Range.prefixUpTo(_:)
- Range.reduce(_:combine:)
- Range.reverse()
- Range.sort(_:)
- Range.split(_:allowEmptySlices:isSeparator:)
- Range.split(_:maxSplit:allowEmptySlices:)
- Range.startsWith(_:)
- Range.startsWith(_:isEquivalent:)
- Range.suffix(_:)
- Range.suffixFrom(_:)
- Range.underestimateCount()
- Range.flatten()
- Range.lexicographicalCompare(_:)
- Range.maxElement()
- Range.minElement()
- Range.sort()
- Range.joinWithSeparator(_:)
- RangeGenerator.init(_:)
- RangeGenerator.contains(_:)
- RangeGenerator.dropFirst()
- RangeGenerator.dropFirst(_:)
- RangeGenerator.dropLast()
- RangeGenerator.dropLast(_:)
- RangeGenerator.elementsEqual(_:)
- RangeGenerator.elementsEqual(_:isEquivalent:)
- RangeGenerator.enumerate()
- RangeGenerator.filter(_:)
- RangeGenerator.flatMap<T>(_: (ForwardIndexType) throws -> T?)
- RangeGenerator.flatMap<S : SequenceType>(_: (ForwardIndexType) throws -> S)
- RangeGenerator.forEach(_:)
- RangeGenerator.lexicographicalCompare(_:isOrderedBefore:)
- RangeGenerator.map(_:)
- RangeGenerator.maxElement(_:)
- RangeGenerator.minElement(_:)
- RangeGenerator.next()
- RangeGenerator.prefix(_:)
- RangeGenerator.reduce(_:combine:)
- RangeGenerator.reverse()
- RangeGenerator.sort(_:)
- RangeGenerator.split(_:allowEmptySlices:isSeparator:)
- RangeGenerator.split(_:maxSplit:allowEmptySlices:)
- RangeGenerator.startsWith(_:)
- RangeGenerator.startsWith(_:isEquivalent:)
- RangeGenerator.suffix(_:)
- RangeGenerator.underestimateCount()
- RangeGenerator.generate()
- Repeat.init(count:repeatedValue:)
- Repeat.subscript(_: Int)
- Repeat.subscript(_: Range<Int>)
- Repeat.contains(_:)
- Repeat.dropFirst()
- Repeat.dropFirst(_:)
- Repeat.dropLast()
- Repeat.dropLast(_:)
- Repeat.elementsEqual(_:isEquivalent:)
- Repeat.enumerate()
- Repeat.filter(_:)
- Repeat.flatMap<T>(_: (Element) throws -> T?)
- Repeat.flatMap<S : SequenceType>(_: (Element) throws -> S)
- Repeat.forEach(_:)
- Repeat.generate()
- Repeat.indexOf(_:)
- Repeat.lexicographicalCompare(_:isOrderedBefore:)
- Repeat.map(_:)
- Repeat.maxElement(_:)
- Repeat.minElement(_:)
- Repeat.prefix(_:)
- Repeat.prefixThrough(_:)
- Repeat.prefixUpTo(_:)
- Repeat.reduce(_:combine:)
- Repeat.reverse()
- Repeat.sort(_:)
- Repeat.split(_:allowEmptySlices:isSeparator:)
- Repeat.startsWith(_:isEquivalent:)
- Repeat.suffix(_:)
- Repeat.suffixFrom(_:)
- Repeat.underestimateCount()
- Repeat.flatten()
- Repeat.lexicographicalCompare(_:)
- Repeat.maxElement()
- Repeat.minElement()
- Repeat.sort()
- Repeat.elementsEqual(_:)
- Repeat.split(_:maxSplit:allowEmptySlices:)
- Repeat.startsWith(_:)
- Repeat.joinWithSeparator(_:)
- ReverseCollection.init(_:)
- ReverseCollection.subscript(_: Range<ReverseCollection<Base>.Index>)
- ReverseCollection.contains(_:)
- ReverseCollection.dropFirst()
- ReverseCollection.dropFirst(_:)
- ReverseCollection.dropLast()
- ReverseCollection.dropLast(_:)
- ReverseCollection.elementsEqual(_:isEquivalent:)
- ReverseCollection.enumerate()
- ReverseCollection.filter(_:)
- ReverseCollection.flatMap<T>(_: (Generator.Element) throws -> T?)
- ReverseCollection.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- ReverseCollection.forEach(_:)
- ReverseCollection.generate()
- ReverseCollection.indexOf(_:)
- ReverseCollection.lexicographicalCompare(_:isOrderedBefore:)
- ReverseCollection.map(_:)
- ReverseCollection.maxElement(_:)
- ReverseCollection.minElement(_:)
- ReverseCollection.prefix(_:)
- ReverseCollection.prefixThrough(_:)
- ReverseCollection.prefixUpTo(_:)
- ReverseCollection.reduce(_:combine:)
- ReverseCollection.reverse()
- ReverseCollection.sort(_:)
- ReverseCollection.split(_:allowEmptySlices:isSeparator:)
- ReverseCollection.startsWith(_:isEquivalent:)
- ReverseCollection.suffix(_:)
- ReverseCollection.suffixFrom(_:)
- ReverseCollection.underestimateCount()
- ReverseCollection.flatten()
- ReverseCollection.lexicographicalCompare(_:)
- ReverseCollection.maxElement()
- ReverseCollection.minElement()
- ReverseCollection.sort()
- ReverseCollection.elementsEqual(_:)
- ReverseCollection.split(_:maxSplit:allowEmptySlices:)
- ReverseCollection.startsWith(_:)
- ReverseCollection.joinWithSeparator(_:)
- ReverseCollection.subscript(_: ReverseCollection<Base>.Index)
- ReverseIndex.init(_:)
- ReverseIndex.advancedBy(_:)
- ReverseIndex.advancedBy(_:limit:)
- ReverseIndex.distanceTo(_:)
- ReverseIndex.predecessor()
- ReverseIndex.successor()
- ReverseRandomAccessCollection.init(_:)
- ReverseRandomAccessCollection.subscript(_: Range<ReverseRandomAccessCollection<Base>.Index>)
- ReverseRandomAccessCollection.contains(_:)
- ReverseRandomAccessCollection.dropFirst()
- ReverseRandomAccessCollection.dropFirst(_:)
- ReverseRandomAccessCollection.dropLast()
- ReverseRandomAccessCollection.dropLast(_:)
- ReverseRandomAccessCollection.elementsEqual(_:isEquivalent:)
- ReverseRandomAccessCollection.enumerate()
- ReverseRandomAccessCollection.filter(_:)
- ReverseRandomAccessCollection.flatMap<T>(_: (Generator.Element) throws -> T?)
- ReverseRandomAccessCollection.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- ReverseRandomAccessCollection.forEach(_:)
- ReverseRandomAccessCollection.generate()
- ReverseRandomAccessCollection.indexOf(_:)
- ReverseRandomAccessCollection.lexicographicalCompare(_:isOrderedBefore:)
- ReverseRandomAccessCollection.map(_:)
- ReverseRandomAccessCollection.maxElement(_:)
- ReverseRandomAccessCollection.minElement(_:)
- ReverseRandomAccessCollection.prefix(_:)
- ReverseRandomAccessCollection.prefixThrough(_:)
- ReverseRandomAccessCollection.prefixUpTo(_:)
- ReverseRandomAccessCollection.reduce(_:combine:)
- ReverseRandomAccessCollection.reverse()
- ReverseRandomAccessCollection.sort(_:)
- ReverseRandomAccessCollection.split(_:allowEmptySlices:isSeparator:)
- ReverseRandomAccessCollection.startsWith(_:isEquivalent:)
- ReverseRandomAccessCollection.suffix(_:)
- ReverseRandomAccessCollection.suffixFrom(_:)
- ReverseRandomAccessCollection.underestimateCount()
- ReverseRandomAccessCollection.flatten()
- ReverseRandomAccessCollection.lexicographicalCompare(_:)
- ReverseRandomAccessCollection.maxElement()
- ReverseRandomAccessCollection.minElement()
- ReverseRandomAccessCollection.sort()
- ReverseRandomAccessCollection.elementsEqual(_:)
- ReverseRandomAccessCollection.split(_:maxSplit:allowEmptySlices:)
- ReverseRandomAccessCollection.startsWith(_:)
- ReverseRandomAccessCollection.joinWithSeparator(_:)
- ReverseRandomAccessCollection.subscript(_: ReverseRandomAccessCollection<Base>.Index)
- ReverseRandomAccessIndex.init(_:)
- ReverseRandomAccessIndex.advancedBy(_:)
- ReverseRandomAccessIndex.advancedBy(_:limit:)
- ReverseRandomAccessIndex.distanceTo(_:)
- ReverseRandomAccessIndex.predecessor()
- ReverseRandomAccessIndex.stride(through:by:)
- ReverseRandomAccessIndex.stride(to:by:)
- ReverseRandomAccessIndex.successor()
- Set.init()
- Set.init(_:)
- Set.init(arrayLiteral:)
- Set.init(minimumCapacity:)
- Set.subscript(_: Range<SetIndex<Element>>)
- Set.subscript(_: SetIndex<Element>)
- Set.contains(_:)
- Set.dropFirst()
- Set.dropFirst(_:)
- Set.dropLast()
- Set.dropLast(_:)
- Set.elementsEqual(_:)
- Set.elementsEqual(_:isEquivalent:)
- Set.enumerate()
- Set.exclusiveOr(_:)
- Set.exclusiveOrInPlace(_:)
- Set.filter(_:)
- Set.flatMap<T>(_: (Element) throws -> T?)
- Set.flatMap<S : SequenceType>(_: (Element) throws -> S)
- Set.forEach(_:)
- Set.generate()
- Set.indexOf(_:)
- Set.insert(_:)
- Set.intersect(_:)
- Set.intersectInPlace(_:)
- Set.isDisjointWith(_:)
- Set.isStrictSubsetOf(_:)
- Set.isStrictSupersetOf(_:)
- Set.isSubsetOf(_:)
- Set.isSupersetOf(_:)
- Set.lexicographicalCompare(_:isOrderedBefore:)
- Set.map(_:)
- Set.maxElement(_:)
- Set.minElement(_:)
- Set.popFirst()
- Set.prefix(_:)
- Set.prefixThrough(_:)
- Set.prefixUpTo(_:)
- Set.reduce(_:combine:)
- Set.remove(_:)
- Set.removeAll(keepCapacity:)
- Set.removeAtIndex(_:)
- Set.removeFirst()
- Set.reverse()
- Set.sort(_:)
- Set.split(_:allowEmptySlices:isSeparator:)
- Set.split(_:maxSplit:allowEmptySlices:)
- Set.startsWith(_:)
- Set.startsWith(_:isEquivalent:)
- Set.subtract(_:)
- Set.subtractInPlace(_:)
- Set.suffix(_:)
- Set.suffixFrom(_:)
- Set.underestimateCount()
- Set.union(_:)
- Set.unionInPlace(_:)
- Set.flatten()
- Set.lexicographicalCompare(_:)
- Set.maxElement()
- Set.minElement()
- Set.sort()
- Set.joinWithSeparator(_:)
- SetGenerator.next()
- SetIndex.advancedBy(_:)
- SetIndex.advancedBy(_:limit:)
- SetIndex.distanceTo(_:)
- SetIndex.successor()
- Slice.init(base:bounds:)
- Slice.subscript(_: Base.Index)
- Slice.subscript(_: Range<Base.Index>)
- Slice.contains(_:)
- Slice.dropFirst()
- Slice.dropFirst(_:)
- Slice.dropLast()
- Slice.dropLast(_:)
- Slice.elementsEqual(_:isEquivalent:)
- Slice.enumerate()
- Slice.filter(_:)
- Slice.flatMap<T>(_: (Base._Element) throws -> T?)
- Slice.flatMap<S : SequenceType>(_: (Base._Element) throws -> S)
- Slice.forEach(_:)
- Slice.generate()
- Slice.indexOf(_:)
- Slice.lexicographicalCompare(_:isOrderedBefore:)
- Slice.map(_:)
- Slice.maxElement(_:)
- Slice.minElement(_:)
- Slice.popFirst()
- Slice.popLast()
- Slice.prefix(_:)
- Slice.prefixThrough(_:)
- Slice.prefixUpTo(_:)
- Slice.reduce(_:combine:)
- Slice.removeFirst()
- Slice.removeFirst(_:)
- Slice.reverse()
- Slice.sort(_:)
- Slice.split(_:allowEmptySlices:isSeparator:)
- Slice.startsWith(_:isEquivalent:)
- Slice.suffix(_:)
- Slice.suffixFrom(_:)
- Slice.underestimateCount()
- Slice.flatten()
- Slice.lexicographicalCompare(_:)
- Slice.maxElement()
- Slice.minElement()
- Slice.sort()
- Slice.elementsEqual(_:)
- Slice.split(_:maxSplit:allowEmptySlices:)
- Slice.startsWith(_:)
- Slice.joinWithSeparator(_:)
- Slice.removeLast()
- Slice.removeLast(_:)
- StaticString.init()
- StaticString.init(_builtinExtendedGraphemeClusterLiteral:byteSize:isASCII:)
- StaticString.init(_builtinStringLiteral:byteSize:isASCII:)
- StaticString.init(_builtinUnicodeScalarLiteral:)
- StaticString.init(extendedGraphemeClusterLiteral:)
- StaticString.init(stringLiteral:)
- StaticString.init(unicodeScalarLiteral:)
- StaticString.withUTF8Buffer(_:)
- StrideThrough.contains(_:)
- StrideThrough.dropFirst()
- StrideThrough.dropFirst(_:)
- StrideThrough.dropLast()
- StrideThrough.dropLast(_:)
- StrideThrough.elementsEqual(_:)
- StrideThrough.elementsEqual(_:isEquivalent:)
- StrideThrough.enumerate()
- StrideThrough.filter(_:)
- StrideThrough.flatMap<T>(_: (Strideable) throws -> T?)
- StrideThrough.flatMap<S : SequenceType>(_: (Strideable) throws -> S)
- StrideThrough.forEach(_:)
- StrideThrough.generate()
- StrideThrough.lexicographicalCompare(_:)
- StrideThrough.lexicographicalCompare(_:isOrderedBefore:)
- StrideThrough.map(_:)
- StrideThrough.maxElement()
- StrideThrough.maxElement(_:)
- StrideThrough.minElement()
- StrideThrough.minElement(_:)
- StrideThrough.prefix(_:)
- StrideThrough.reduce(_:combine:)
- StrideThrough.reverse()
- StrideThrough.sort()
- StrideThrough.sort(_:)
- StrideThrough.split(_:allowEmptySlices:isSeparator:)
- StrideThrough.split(_:maxSplit:allowEmptySlices:)
- StrideThrough.startsWith(_:)
- StrideThrough.startsWith(_:isEquivalent:)
- StrideThrough.suffix(_:)
- StrideThrough.underestimateCount()
- StrideThroughGenerator.next()
- StrideTo.contains(_:)
- StrideTo.dropFirst()
- StrideTo.dropFirst(_:)
- StrideTo.dropLast()
- StrideTo.dropLast(_:)
- StrideTo.elementsEqual(_:)
- StrideTo.elementsEqual(_:isEquivalent:)
- StrideTo.enumerate()
- StrideTo.filter(_:)
- StrideTo.flatMap<T>(_: (Strideable) throws -> T?)
- StrideTo.flatMap<S : SequenceType>(_: (Strideable) throws -> S)
- StrideTo.forEach(_:)
- StrideTo.generate()
- StrideTo.lexicographicalCompare(_:)
- StrideTo.lexicographicalCompare(_:isOrderedBefore:)
- StrideTo.map(_:)
- StrideTo.maxElement()
- StrideTo.maxElement(_:)
- StrideTo.minElement()
- StrideTo.minElement(_:)
- StrideTo.prefix(_:)
- StrideTo.reduce(_:combine:)
- StrideTo.reverse()
- StrideTo.sort()
- StrideTo.sort(_:)
- StrideTo.split(_:allowEmptySlices:isSeparator:)
- StrideTo.split(_:maxSplit:allowEmptySlices:)
- StrideTo.startsWith(_:)
- StrideTo.startsWith(_:isEquivalent:)
- StrideTo.suffix(_:)
- StrideTo.underestimateCount()
- StrideToGenerator.next()
- String.init()
- String.init(_: Character)
- String.init(_: NSString)
- String.init(_: String.CharacterView)
- String.init(_: String.UnicodeScalarView)
- String.init<T>(_: T)
- String.init<T : _SignedIntegerType>(_: T)
- String.init<T : UnsignedIntegerType>(_: T)
- String.init<S : SequenceType where S.Generator.Element == Character>(_: S)
- String.init<T : _SignedIntegerType>(_: T, radix: Int, uppercase: Bool)
- String.init<T : UnsignedIntegerType>(_: T, radix: Int, uppercase: Bool)
- String.init(_builtinExtendedGraphemeClusterLiteral:byteSize:isASCII:)
- String.init(_builtinStringLiteral:byteSize:isASCII:)
- String.init(_builtinUTF16StringLiteral:numberOfCodeUnits:)
- String.init(_builtinUnicodeScalarLiteral:)
- String.init(contentsOfFile:encoding:)
- String.init(contentsOfFile:usedEncoding:)
- String.init(contentsOfURL:encoding:)
- String.init(contentsOfURL:usedEncoding:)
- String.init(count: Int, repeatedValue: Character)
- String.init(count: Int, repeatedValue: UnicodeScalar)
- String.init(extendedGraphemeClusterLiteral:)
- String.init(format:_:)
- String.init(format:arguments:)
- String.init(format:locale:_:)
- String.init(format:locale:arguments:)
- String.init(reflecting:)
- String.init(stringInterpolation:)
- String.init(stringInterpolationSegment: Bool)
- String.init(stringInterpolationSegment: Character)
- String.init(stringInterpolationSegment: Float32)
- String.init(stringInterpolationSegment: Float64)
- String.init(stringInterpolationSegment: Int)
- String.init(stringInterpolationSegment: Int8)
- String.init(stringInterpolationSegment: Int16)
- String.init(stringInterpolationSegment: Int32)
- String.init(stringInterpolationSegment: Int64)
- String.init(stringInterpolationSegment: String)
- String.init(stringInterpolationSegment: UInt)
- String.init(stringInterpolationSegment: UInt8)
- String.init(stringInterpolationSegment: UInt16)
- String.init(stringInterpolationSegment: UInt32)
- String.init(stringInterpolationSegment: UInt64)
- String.init(stringInterpolationSegment: UnicodeScalar)
- String.init<T>(stringInterpolationSegment: T)
- String.init(stringLiteral:)
- String.init(unicodeScalarLiteral:)
- String.init(utf16CodeUnits:count:)
- String.init(utf16CodeUnitsNoCopy:count:freeWhenDone:)
- String.init?(_: String.UTF8View)
- String.init?(_: String.UTF16View)
- String.init?(CString:encoding:)
- String.init?(UTF8String:)
- String.init?(bytes:encoding:)
- String.init?(bytesNoCopy:length:encoding:freeWhenDone:)
- String.init?(data:encoding:)
- String.subscript(_: Index)
- String.subscript(_: Range<Index>)
- String.availableStringEncodings()
- String.defaultCStringEncoding()
- String.fromCString(_:)
- String.fromCStringRepairingIllFormedUTF8(_:)
- String.localizedNameOfStringEncoding(_:)
- String.localizedStringWithFormat(_:_:)
- String.append(_: Character)
- String.append(_: UnicodeScalar)
- String.appendContentsOf(_: String)
- String.appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_: S)
- String.cStringUsingEncoding(_:)
- String.canBeConvertedToEncoding(_:)
- String.capitalizedStringWithLocale(_:)
- String.caseInsensitiveCompare(_:)
- String.commonPrefixWithString(_:options:)
- String.compare(_:options:range:locale:)
- String.completePathIntoString(_:caseSensitive:matchesIntoArray:filterTypes:)
- String.componentsSeparatedByCharactersInSet(_:)
- String.componentsSeparatedByString(_:)
- String.containsString(_:)
- String.dataUsingEncoding(_:allowLossyConversion:)
- String.enumerateLines(_:)
- String.enumerateLinguisticTagsInRange(_:scheme:options:orthography:_:)
- String.enumerateSubstringsInRange(_:options:_ body: (substring: String?, substringRange: Range<Index>,:))
- String.getBytes(inout:maxLength:usedLength:encoding:options:range:remainingRange:)
- String.getCString(inout:maxLength:encoding:)
- String.getLineStart(_:end:contentsEnd:forRange:)
- String.getParagraphStart(_:end:contentsEnd:forRange:)
- String.hasPrefix(_:)
- String.hasSuffix(_:)
- String.insert(_:atIndex:)
- String.insertContentsOf(_:at:)
- String.lengthOfBytesUsingEncoding(_:)
- String.lineRangeForRange(_:)
- String.linguisticTagsInRange(_:scheme:options:orthography:tokenRanges:)
- String.localizedCaseInsensitiveCompare(_:)
- String.localizedCaseInsensitiveContainsString(_:)
- String.localizedCompare(_:)
- String.localizedStandardCompare(_:)
- String.localizedStandardContainsString(_:)
- String.localizedStandardRangeOfString(_:)
- String.lowercaseStringWithLocale(_:)
- String.maximumLengthOfBytesUsingEncoding(_:)
- String.paragraphRangeForRange(_:)
- String.propertyList()
- String.propertyListFromStringsFileFormat()
- String.rangeOfCharacterFromSet(_:options:range:)
- String.rangeOfComposedCharacterSequenceAtIndex(_:)
- String.rangeOfComposedCharacterSequencesForRange(_:)
- String.rangeOfString(_:options:range:locale:)
- String.removeAll(keepCapacity:)
- String.removeAtIndex(_:)
- String.removeRange(_:)
- String.replaceRange(_: Range<Index>, with: String)
- String.replaceRange<C : CollectionType where C.Generator.Element == Character>(_: Range<Index>, with: C)
- String.reserveCapacity(_:)
- String.stringByAddingPercentEncodingWithAllowedCharacters(_:)
- String.stringByAddingPercentEscapesUsingEncoding(_:)
- String.stringByAppendingFormat(_:_:)
- String.stringByAppendingString(_:)
- String.stringByApplyingTransform(_:reverse:)
- String.stringByFoldingWithOptions(_:locale:)
- String.stringByPaddingToLength(_:withString:startingAtIndex:)
- String.stringByReplacingCharactersInRange(_:withString:)
- String.stringByReplacingOccurrencesOfString(_:withString:options:range:)
- String.stringByReplacingPercentEscapesUsingEncoding(_:)
- String.stringByTrimmingCharactersInSet(_:)
- String.substringFromIndex(_:)
- String.substringToIndex(_:)
- String.substringWithRange(_:)
- String.uppercaseStringWithLocale(_:)
- String.withCString(_:)
- String.withMutableCharacters(_:)
- String.write(_:)
- String.writeTo(inout:)
- String.writeToFile(_:atomically:encoding:)
- String.writeToURL(_:atomically:encoding:)
- String.CharacterView.init()
- String.CharacterView.init(_: String)
- String.CharacterView.init<S : SequenceType where S.Generator.Element == Character>(_: S)
- String.CharacterView.init(_:)
- String.CharacterView.subscript(_: Range<String.CharacterView.Index>)
- String.CharacterView.subscript(_: String.CharacterView.Index)
- String.CharacterView.append(_:)
- String.CharacterView.appendContentsOf(_:)
- String.CharacterView.contains(_:)
- String.CharacterView.dropFirst()
- String.CharacterView.dropFirst(_:)
- String.CharacterView.dropLast()
- String.CharacterView.dropLast(_:)
- String.CharacterView.elementsEqual(_:)
- String.CharacterView.elementsEqual(_:isEquivalent:)
- String.CharacterView.enumerate()
- String.CharacterView.filter(_:)
- String.CharacterView.flatMap<T>(_: (Character) throws -> T?)
- String.CharacterView.flatMap<S : SequenceType>(_: (Character) throws -> S)
- String.CharacterView.forEach(_:)
- String.CharacterView.generate()
- String.CharacterView.indexOf(_:)
- String.CharacterView.insert(_:atIndex:)
- String.CharacterView.insertContentsOf(_:at:)
- String.CharacterView.lexicographicalCompare(_:)
- String.CharacterView.lexicographicalCompare(_:isOrderedBefore:)
- String.CharacterView.map(_:)
- String.CharacterView.maxElement()
- String.CharacterView.maxElement(_:)
- String.CharacterView.minElement()
- String.CharacterView.minElement(_:)
- String.CharacterView.popFirst()
- String.CharacterView.popLast()
- String.CharacterView.prefix(_:)
- String.CharacterView.prefixThrough(_:)
- String.CharacterView.prefixUpTo(_:)
- String.CharacterView.reduce(_:combine:)
- String.CharacterView.removeAll(keepCapacity:)
- String.CharacterView.removeAtIndex(_:)
- String.CharacterView.removeFirst()
- String.CharacterView.removeFirst(_:)
- String.CharacterView.removeLast()
- String.CharacterView.removeLast(_:)
- String.CharacterView.removeRange(_:)
- String.CharacterView.replaceRange(_:with:)
- String.CharacterView.reserveCapacity(_:)
- String.CharacterView.reverse()
- String.CharacterView.sort()
- String.CharacterView.sort(_:)
- String.CharacterView.split(_:allowEmptySlices:isSeparator:)
- String.CharacterView.split(_:maxSplit:allowEmptySlices:)
- String.CharacterView.startsWith(_:)
- String.CharacterView.startsWith(_:isEquivalent:)
- String.CharacterView.suffix(_:)
- String.CharacterView.suffixFrom(_:)
- String.CharacterView.underestimateCount()
- String.CharacterView.Index.init?(_: UTF8Index, within: String)
- String.CharacterView.Index.init?(_: UTF16Index, within: String)
- String.CharacterView.Index.init?(_: UnicodeScalarIndex, within: String)
- String.CharacterView.Index.advancedBy(_:)
- String.CharacterView.Index.advancedBy(_:limit:)
- String.CharacterView.Index.distanceTo(_:)
- String.CharacterView.Index.predecessor()
- String.CharacterView.Index.samePositionIn(_: String.UTF8View)
- String.CharacterView.Index.samePositionIn(_: String.UTF16View)
- String.CharacterView.Index.samePositionIn(_: String.UnicodeScalarView)
- String.CharacterView.Index.successor()
- String.UnicodeScalarView.init()
- String.UnicodeScalarView.init(_:)
- String.UnicodeScalarView.subscript(_: Range<String.UnicodeScalarView.Index>)
- String.UnicodeScalarView.subscript(_: String.UnicodeScalarView.Index)
- String.UnicodeScalarView.append(_:)
- String.UnicodeScalarView.appendContentsOf(_:)
- String.UnicodeScalarView.contains(_:)
- String.UnicodeScalarView.dropFirst()
- String.UnicodeScalarView.dropFirst(_:)
- String.UnicodeScalarView.dropLast()
- String.UnicodeScalarView.dropLast(_:)
- String.UnicodeScalarView.elementsEqual(_:)
- String.UnicodeScalarView.elementsEqual(_:isEquivalent:)
- String.UnicodeScalarView.enumerate()
- String.UnicodeScalarView.filter(_:)
- String.UnicodeScalarView.flatMap<T>(_: (UnicodeScalar) throws -> T?)
- String.UnicodeScalarView.flatMap<S : SequenceType>(_: (UnicodeScalar) throws -> S)
- String.UnicodeScalarView.forEach(_:)
- String.UnicodeScalarView.generate()
- String.UnicodeScalarView.indexOf(_:)
- String.UnicodeScalarView.insert(_:atIndex:)
- String.UnicodeScalarView.insertContentsOf(_:at:)
- String.UnicodeScalarView.lexicographicalCompare(_:)
- String.UnicodeScalarView.lexicographicalCompare(_:isOrderedBefore:)
- String.UnicodeScalarView.map(_:)
- String.UnicodeScalarView.maxElement()
- String.UnicodeScalarView.maxElement(_:)
- String.UnicodeScalarView.minElement()
- String.UnicodeScalarView.minElement(_:)
- String.UnicodeScalarView.popFirst()
- String.UnicodeScalarView.popLast()
- String.UnicodeScalarView.prefix(_:)
- String.UnicodeScalarView.prefixThrough(_:)
- String.UnicodeScalarView.prefixUpTo(_:)
- String.UnicodeScalarView.reduce(_:combine:)
- String.UnicodeScalarView.removeAll(keepCapacity:)
- String.UnicodeScalarView.removeAtIndex(_:)
- String.UnicodeScalarView.removeFirst()
- String.UnicodeScalarView.removeFirst(_:)
- String.UnicodeScalarView.removeLast()
- String.UnicodeScalarView.removeLast(_:)
- String.UnicodeScalarView.removeRange(_:)
- String.UnicodeScalarView.replaceRange(_:with:)
- String.UnicodeScalarView.reserveCapacity(_:)
- String.UnicodeScalarView.reverse()
- String.UnicodeScalarView.sort()
- String.UnicodeScalarView.sort(_:)
- String.UnicodeScalarView.split(_:allowEmptySlices:isSeparator:)
- String.UnicodeScalarView.split(_:maxSplit:allowEmptySlices:)
- String.UnicodeScalarView.startsWith(_:)
- String.UnicodeScalarView.startsWith(_:isEquivalent:)
- String.UnicodeScalarView.suffix(_:)
- String.UnicodeScalarView.suffixFrom(_:)
- String.UnicodeScalarView.underestimateCount()
- String.UnicodeScalarView.Generator.next()
- String.UnicodeScalarView.Index.advancedBy(_:)
- String.UnicodeScalarView.Index.advancedBy(_:limit:)
- String.UnicodeScalarView.Index.distanceTo(_:)
- String.UnicodeScalarView.Index.predecessor()
- String.UnicodeScalarView.Index.successor()
- String.UnicodeScalarView.UnicodeScalarIndex.init(_:within:)
- String.UnicodeScalarView.UnicodeScalarIndex.init?(_: UTF8Index, within: String.UnicodeScalarView)
- String.UnicodeScalarView.UnicodeScalarIndex.init?(_: UTF16Index, within: String.UnicodeScalarView)
- String.UnicodeScalarView.UnicodeScalarIndex.samePositionIn(_: String)
- String.UnicodeScalarView.UnicodeScalarIndex.samePositionIn(_: String.UTF8View)
- String.UnicodeScalarView.UnicodeScalarIndex.samePositionIn(_: String.UTF16View)
- String.UTF16View.subscript(_: Range<String.UTF16View.Index>)
- String.UTF16View.subscript(_: String.UTF16View.Index)
- String.UTF16View.contains(_:)
- String.UTF16View.dropFirst()
- String.UTF16View.dropFirst(_:)
- String.UTF16View.dropLast()
- String.UTF16View.dropLast(_:)
- String.UTF16View.elementsEqual(_:isEquivalent:)
- String.UTF16View.enumerate()
- String.UTF16View.filter(_:)
- String.UTF16View.flatMap<T>(_: (CodeUnit) throws -> T?)
- String.UTF16View.flatMap<S : SequenceType>(_: (CodeUnit) throws -> S)
- String.UTF16View.forEach(_:)
- String.UTF16View.generate()
- String.UTF16View.indexOf(_:)
- String.UTF16View.lexicographicalCompare(_:isOrderedBefore:)
- String.UTF16View.map(_:)
- String.UTF16View.maxElement(_:)
- String.UTF16View.minElement(_:)
- String.UTF16View.popFirst()
- String.UTF16View.popLast()
- String.UTF16View.prefix(_:)
- String.UTF16View.prefixThrough(_:)
- String.UTF16View.prefixUpTo(_:)
- String.UTF16View.reduce(_:combine:)
- String.UTF16View.removeFirst()
- String.UTF16View.removeFirst(_:)
- String.UTF16View.removeLast()
- String.UTF16View.removeLast(_:)
- String.UTF16View.reverse()
- String.UTF16View.sort(_:)
- String.UTF16View.split(_:allowEmptySlices:isSeparator:)
- String.UTF16View.startsWith(_:isEquivalent:)
- String.UTF16View.suffix(_:)
- String.UTF16View.suffixFrom(_:)
- String.UTF16View.underestimateCount()
- String.UTF16View.Index.init(_: Index, within: String.UTF16View)
- String.UTF16View.Index.init(_: UnicodeScalarIndex, within: String.UTF16View)
- String.UTF16View.Index.init?(_:within:)
- String.UTF16View.Index.advancedBy(_:)
- String.UTF16View.Index.advancedBy(_:limit:)
- String.UTF16View.Index.distanceTo(_:)
- String.UTF16View.Index.predecessor()
- String.UTF16View.Index.samePositionIn(_: String)
- String.UTF16View.Index.samePositionIn(_: String.UTF8View)
- String.UTF16View.Index.samePositionIn(_: String.UnicodeScalarView)
- String.UTF16View.Index.successor()
- String.UTF8View.subscript(_: Range<String.UTF8View.Index>)
- String.UTF8View.subscript(_: String.UTF8View.Index)
- String.UTF8View.contains(_:)
- String.UTF8View.dropFirst()
- String.UTF8View.dropFirst(_:)
- String.UTF8View.dropLast()
- String.UTF8View.dropLast(_:)
- String.UTF8View.elementsEqual(_:isEquivalent:)
- String.UTF8View.enumerate()
- String.UTF8View.filter(_:)
- String.UTF8View.flatMap<T>(_: (CodeUnit) throws -> T?)
- String.UTF8View.flatMap<S : SequenceType>(_: (CodeUnit) throws -> S)
- String.UTF8View.forEach(_:)
- String.UTF8View.generate()
- String.UTF8View.indexOf(_:)
- String.UTF8View.lexicographicalCompare(_:isOrderedBefore:)
- String.UTF8View.map(_:)
- String.UTF8View.maxElement(_:)
- String.UTF8View.minElement(_:)
- String.UTF8View.popFirst()
- String.UTF8View.popLast()
- String.UTF8View.prefix(_:)
- String.UTF8View.prefixThrough(_:)
- String.UTF8View.prefixUpTo(_:)
- String.UTF8View.reduce(_:combine:)
- String.UTF8View.removeFirst()
- String.UTF8View.removeFirst(_:)
- String.UTF8View.reverse()
- String.UTF8View.sort(_:)
- String.UTF8View.split(_:allowEmptySlices:isSeparator:)
- String.UTF8View.startsWith(_:isEquivalent:)
- String.UTF8View.suffix(_:)
- String.UTF8View.suffixFrom(_:)
- String.UTF8View.underestimateCount()
- String.UTF8View.Index.init(_: Index, within: String.UTF8View)
- String.UTF8View.Index.init(_: UnicodeScalarIndex, within: String.UTF8View)
- String.UTF8View.Index.init?(_:within:)
- String.UTF8View.Index.advancedBy(_:)
- String.UTF8View.Index.advancedBy(_:limit:)
- String.UTF8View.Index.distanceTo(_:)
- String.UTF8View.Index.samePositionIn(_: String)
- String.UTF8View.Index.samePositionIn(_: String.UTF16View)
- String.UTF8View.Index.samePositionIn(_: String.UnicodeScalarView)
- String.UTF8View.Index.successor()
- UInt.init()
- UInt.init(_: Builtin.Word)
- UInt.init(_: Double)
- UInt.init(_: Float)
- UInt.init(_: Float80)
- UInt.init(_: Int)
- UInt.init(_: Int8)
- UInt.init(_: Int16)
- UInt.init(_: Int32)
- UInt.init(_: Int64)
- UInt.init(_: UInt)
- UInt.init(_: UInt8)
- UInt.init(_: UInt16)
- UInt.init(_: UInt32)
- UInt.init(_: UInt64)
- UInt.init(_builtinIntegerLiteral:)
- UInt.init(bigEndian:)
- UInt.init(bitPattern:)
- UInt.init(integerLiteral:)
- UInt.init(littleEndian:)
- UInt.init(truncatingBitPattern: Int64)
- UInt.init(truncatingBitPattern: UInt64)
- UInt.init?(_:radix:)
- UInt.addWithOverflow(_:_:)
- UInt.divideWithOverflow(_:_:)
- UInt.multiplyWithOverflow(_:_:)
- UInt.remainderWithOverflow(_:_:)
- UInt.subtractWithOverflow(_:_:)
- UInt.advancedBy(_:)
- UInt.advancedBy(_:limit:)
- UInt.distanceTo(_:)
- UInt.predecessor()
- UInt.stride(through:by:)
- UInt.stride(to:by:)
- UInt.successor()
- UInt.toIntMax()
- UInt.toUIntMax()
- UInt16.init()
- UInt16.init(_: Double)
- UInt16.init(_: Float)
- UInt16.init(_: Float80)
- UInt16.init(_: Int)
- UInt16.init(_: Int8)
- UInt16.init(_: Int16)
- UInt16.init(_: Int32)
- UInt16.init(_: Int64)
- UInt16.init(_: UInt)
- UInt16.init(_: UInt8)
- UInt16.init(_: UInt16)
- UInt16.init(_: UInt32)
- UInt16.init(_: UInt64)
- UInt16.init(_builtinIntegerLiteral:)
- UInt16.init(bigEndian:)
- UInt16.init(bitPattern:)
- UInt16.init(integerLiteral:)
- UInt16.init(littleEndian:)
- UInt16.init(truncatingBitPattern: Int)
- UInt16.init(truncatingBitPattern: Int32)
- UInt16.init(truncatingBitPattern: Int64)
- UInt16.init(truncatingBitPattern: UInt)
- UInt16.init(truncatingBitPattern: UInt32)
- UInt16.init(truncatingBitPattern: UInt64)
- UInt16.init?(_:radix:)
- UInt16.addWithOverflow(_:_:)
- UInt16.divideWithOverflow(_:_:)
- UInt16.multiplyWithOverflow(_:_:)
- UInt16.remainderWithOverflow(_:_:)
- UInt16.subtractWithOverflow(_:_:)
- UInt16.advancedBy(_:)
- UInt16.advancedBy(_:limit:)
- UInt16.distanceTo(_:)
- UInt16.predecessor()
- UInt16.stride(through:by:)
- UInt16.stride(to:by:)
- UInt16.successor()
- UInt16.toIntMax()
- UInt16.toUIntMax()
- UInt32.init()
- UInt32.init(_: Double)
- UInt32.init(_: Float)
- UInt32.init(_: Float80)
- UInt32.init(_: Int)
- UInt32.init(_: Int8)
- UInt32.init(_: Int16)
- UInt32.init(_: Int32)
- UInt32.init(_: Int64)
- UInt32.init(_: UInt)
- UInt32.init(_: UInt8)
- UInt32.init(_: UInt16)
- UInt32.init(_: UInt32)
- UInt32.init(_: UInt64)
- UInt32.init(_: UnicodeScalar)
- UInt32.init(_builtinIntegerLiteral:)
- UInt32.init(bigEndian:)
- UInt32.init(bitPattern:)
- UInt32.init(integerLiteral:)
- UInt32.init(littleEndian:)
- UInt32.init(truncatingBitPattern: Int)
- UInt32.init(truncatingBitPattern: Int64)
- UInt32.init(truncatingBitPattern: UInt)
- UInt32.init(truncatingBitPattern: UInt64)
- UInt32.init?(_:radix:)
- UInt32.addWithOverflow(_:_:)
- UInt32.divideWithOverflow(_:_:)
- UInt32.multiplyWithOverflow(_:_:)
- UInt32.remainderWithOverflow(_:_:)
- UInt32.subtractWithOverflow(_:_:)
- UInt32.advancedBy(_:)
- UInt32.advancedBy(_:limit:)
- UInt32.distanceTo(_:)
- UInt32.predecessor()
- UInt32.stride(through:by:)
- UInt32.stride(to:by:)
- UInt32.successor()
- UInt32.toIntMax()
- UInt32.toUIntMax()
- UInt64.init()
- UInt64.init(_: Double)
- UInt64.init(_: Float)
- UInt64.init(_: Float80)
- UInt64.init(_: Int)
- UInt64.init(_: Int8)
- UInt64.init(_: Int16)
- UInt64.init(_: Int32)
- UInt64.init(_: Int64)
- UInt64.init(_: UInt)
- UInt64.init(_: UInt8)
- UInt64.init(_: UInt16)
- UInt64.init(_: UInt32)
- UInt64.init(_: UInt64)
- UInt64.init(_: UnicodeScalar)
- UInt64.init(_builtinIntegerLiteral:)
- UInt64.init(bigEndian:)
- UInt64.init(bitPattern:)
- UInt64.init(integerLiteral:)
- UInt64.init(littleEndian:)
- UInt64.init?(_:radix:)
- UInt64.addWithOverflow(_:_:)
- UInt64.divideWithOverflow(_:_:)
- UInt64.multiplyWithOverflow(_:_:)
- UInt64.remainderWithOverflow(_:_:)
- UInt64.subtractWithOverflow(_:_:)
- UInt64.advancedBy(_:)
- UInt64.advancedBy(_:limit:)
- UInt64.distanceTo(_:)
- UInt64.predecessor()
- UInt64.stride(through:by:)
- UInt64.stride(to:by:)
- UInt64.successor()
- UInt64.toIntMax()
- UInt64.toUIntMax()
- UInt8.init()
- UInt8.init(_: Double)
- UInt8.init(_: Float)
- UInt8.init(_: Float80)
- UInt8.init(_: Int)
- UInt8.init(_: Int8)
- UInt8.init(_: Int16)
- UInt8.init(_: Int32)
- UInt8.init(_: Int64)
- UInt8.init(_: UInt)
- UInt8.init(_: UInt8)
- UInt8.init(_: UInt16)
- UInt8.init(_: UInt32)
- UInt8.init(_: UInt64)
- UInt8.init(_builtinIntegerLiteral:)
- UInt8.init(ascii:)
- UInt8.init(bitPattern:)
- UInt8.init(integerLiteral:)
- UInt8.init(truncatingBitPattern: Int)
- UInt8.init(truncatingBitPattern: Int16)
- UInt8.init(truncatingBitPattern: Int32)
- UInt8.init(truncatingBitPattern: Int64)
- UInt8.init(truncatingBitPattern: UInt)
- UInt8.init(truncatingBitPattern: UInt16)
- UInt8.init(truncatingBitPattern: UInt32)
- UInt8.init(truncatingBitPattern: UInt64)
- UInt8.init?(_:radix:)
- UInt8.addWithOverflow(_:_:)
- UInt8.divideWithOverflow(_:_:)
- UInt8.multiplyWithOverflow(_:_:)
- UInt8.remainderWithOverflow(_:_:)
- UInt8.subtractWithOverflow(_:_:)
- UInt8.advancedBy(_:)
- UInt8.advancedBy(_:limit:)
- UInt8.distanceTo(_:)
- UInt8.predecessor()
- UInt8.stride(through:by:)
- UInt8.stride(to:by:)
- UInt8.successor()
- UInt8.toIntMax()
- UInt8.toUIntMax()
- UnicodeDecodingResult.isEmptyInput()
- UnicodeScalar.init()
- UnicodeScalar.init(_: Int)
- UnicodeScalar.init(_: UInt8)
- UnicodeScalar.init(_: UInt16)
- UnicodeScalar.init(_: UInt32)
- UnicodeScalar.init(_: UnicodeScalar)
- UnicodeScalar.init(_builtinUnicodeScalarLiteral:)
- UnicodeScalar.init(unicodeScalarLiteral:)
- UnicodeScalar.escape(asASCII:)
- UnicodeScalar.isASCII()
- UnicodeScalar.writeTo(inout:)
- Unmanaged.fromOpaque(_:)
- Unmanaged.passRetained(_:)
- Unmanaged.passUnretained(_:)
- Unmanaged.autorelease()
- Unmanaged.release()
- Unmanaged.retain()
- Unmanaged.takeRetainedValue()
- Unmanaged.takeUnretainedValue()
- Unmanaged.toOpaque()
- UnsafeBufferPointer.init(start:count:)
- UnsafeBufferPointer.subscript(_: Int)
- UnsafeBufferPointer.subscript(_: Range<Int>)
- UnsafeBufferPointer.contains(_:)
- UnsafeBufferPointer.dropFirst()
- UnsafeBufferPointer.dropFirst(_:)
- UnsafeBufferPointer.dropLast()
- UnsafeBufferPointer.dropLast(_:)
- UnsafeBufferPointer.elementsEqual(_:isEquivalent:)
- UnsafeBufferPointer.enumerate()
- UnsafeBufferPointer.filter(_:)
- UnsafeBufferPointer.flatMap<T>(_: (Element) throws -> T?)
- UnsafeBufferPointer.flatMap<S : SequenceType>(_: (Element) throws -> S)
- UnsafeBufferPointer.forEach(_:)
- UnsafeBufferPointer.generate()
- UnsafeBufferPointer.indexOf(_:)
- UnsafeBufferPointer.lexicographicalCompare(_:isOrderedBefore:)
- UnsafeBufferPointer.map(_:)
- UnsafeBufferPointer.maxElement(_:)
- UnsafeBufferPointer.minElement(_:)
- UnsafeBufferPointer.prefix(_:)
- UnsafeBufferPointer.prefixThrough(_:)
- UnsafeBufferPointer.prefixUpTo(_:)
- UnsafeBufferPointer.reduce(_:combine:)
- UnsafeBufferPointer.reverse()
- UnsafeBufferPointer.sort(_:)
- UnsafeBufferPointer.split(_:allowEmptySlices:isSeparator:)
- UnsafeBufferPointer.startsWith(_:isEquivalent:)
- UnsafeBufferPointer.suffix(_:)
- UnsafeBufferPointer.suffixFrom(_:)
- UnsafeBufferPointer.underestimateCount()
- UnsafeBufferPointer.flatten()
- UnsafeBufferPointer.lexicographicalCompare(_:)
- UnsafeBufferPointer.maxElement()
- UnsafeBufferPointer.minElement()
- UnsafeBufferPointer.sort()
- UnsafeBufferPointer.elementsEqual(_:)
- UnsafeBufferPointer.split(_:maxSplit:allowEmptySlices:)
- UnsafeBufferPointer.startsWith(_:)
- UnsafeBufferPointer.joinWithSeparator(_:)
- UnsafeBufferPointerGenerator.contains(_:)
- UnsafeBufferPointerGenerator.dropFirst()
- UnsafeBufferPointerGenerator.dropFirst(_:)
- UnsafeBufferPointerGenerator.dropLast()
- UnsafeBufferPointerGenerator.dropLast(_:)
- UnsafeBufferPointerGenerator.elementsEqual(_:isEquivalent:)
- UnsafeBufferPointerGenerator.enumerate()
- UnsafeBufferPointerGenerator.filter(_:)
- UnsafeBufferPointerGenerator.flatMap<T>(_: (Generator.Element) throws -> T?)
- UnsafeBufferPointerGenerator.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- UnsafeBufferPointerGenerator.forEach(_:)
- UnsafeBufferPointerGenerator.lexicographicalCompare(_:isOrderedBefore:)
- UnsafeBufferPointerGenerator.map(_:)
- UnsafeBufferPointerGenerator.maxElement(_:)
- UnsafeBufferPointerGenerator.minElement(_:)
- UnsafeBufferPointerGenerator.next()
- UnsafeBufferPointerGenerator.prefix(_:)
- UnsafeBufferPointerGenerator.reduce(_:combine:)
- UnsafeBufferPointerGenerator.reverse()
- UnsafeBufferPointerGenerator.sort(_:)
- UnsafeBufferPointerGenerator.split(_:allowEmptySlices:isSeparator:)
- UnsafeBufferPointerGenerator.startsWith(_:isEquivalent:)
- UnsafeBufferPointerGenerator.suffix(_:)
- UnsafeBufferPointerGenerator.underestimateCount()
- UnsafeBufferPointerGenerator.generate()
- UnsafeBufferPointerGenerator.lexicographicalCompare(_:)
- UnsafeBufferPointerGenerator.maxElement()
- UnsafeBufferPointerGenerator.minElement()
- UnsafeBufferPointerGenerator.sort()
- UnsafeBufferPointerGenerator.elementsEqual(_:)
- UnsafeBufferPointerGenerator.split(_:maxSplit:allowEmptySlices:)
- UnsafeBufferPointerGenerator.startsWith(_:)
- UnsafeBufferPointerGenerator.flatten()
- UnsafeBufferPointerGenerator.joinWithSeparator(_:)
- UnsafeMutableBufferPointer.init(start:count:)
- UnsafeMutableBufferPointer.subscript(_: Int)
- UnsafeMutableBufferPointer.subscript(_: Range<Int>)
- UnsafeMutableBufferPointer.contains(_:)
- UnsafeMutableBufferPointer.dropFirst()
- UnsafeMutableBufferPointer.dropFirst(_:)
- UnsafeMutableBufferPointer.dropLast()
- UnsafeMutableBufferPointer.dropLast(_:)
- UnsafeMutableBufferPointer.elementsEqual(_:isEquivalent:)
- UnsafeMutableBufferPointer.enumerate()
- UnsafeMutableBufferPointer.filter(_:)
- UnsafeMutableBufferPointer.flatMap<T>(_: (Element) throws -> T?)
- UnsafeMutableBufferPointer.flatMap<S : SequenceType>(_: (Element) throws -> S)
- UnsafeMutableBufferPointer.forEach(_:)
- UnsafeMutableBufferPointer.generate()
- UnsafeMutableBufferPointer.indexOf(_:)
- UnsafeMutableBufferPointer.lexicographicalCompare(_:isOrderedBefore:)
- UnsafeMutableBufferPointer.map(_:)
- UnsafeMutableBufferPointer.maxElement(_:)
- UnsafeMutableBufferPointer.minElement(_:)
- UnsafeMutableBufferPointer.partition(_:isOrderedBefore:)
- UnsafeMutableBufferPointer.prefix(_:)
- UnsafeMutableBufferPointer.prefixThrough(_:)
- UnsafeMutableBufferPointer.prefixUpTo(_:)
- UnsafeMutableBufferPointer.reduce(_:combine:)
- UnsafeMutableBufferPointer.reverse()
- UnsafeMutableBufferPointer.sort(_:)
- UnsafeMutableBufferPointer.sortInPlace(_:)
- UnsafeMutableBufferPointer.split(_:allowEmptySlices:isSeparator:)
- UnsafeMutableBufferPointer.startsWith(_:isEquivalent:)
- UnsafeMutableBufferPointer.suffix(_:)
- UnsafeMutableBufferPointer.suffixFrom(_:)
- UnsafeMutableBufferPointer.underestimateCount()
- UnsafeMutableBufferPointer.flatten()
- UnsafeMutableBufferPointer.lexicographicalCompare(_:)
- UnsafeMutableBufferPointer.maxElement()
- UnsafeMutableBufferPointer.minElement()
- UnsafeMutableBufferPointer.sort()
- UnsafeMutableBufferPointer.elementsEqual(_:)
- UnsafeMutableBufferPointer.split(_:maxSplit:allowEmptySlices:)
- UnsafeMutableBufferPointer.startsWith(_:)
- UnsafeMutableBufferPointer.joinWithSeparator(_:)
- UnsafeMutableBufferPointer.partition(_:)
- UnsafeMutableBufferPointer.sortInPlace()
- UnsafeMutablePointer.init()
- UnsafeMutablePointer.init(_: COpaquePointer)
- UnsafeMutablePointer.init<U>(_: UnsafeMutablePointer<U>)
- UnsafeMutablePointer.init<U>(_: UnsafePointer<U>)
- UnsafeMutablePointer.init(bitPattern: Int)
- UnsafeMutablePointer.init(bitPattern: UInt)
- UnsafeMutablePointer.init(nilLiteral:)
- UnsafeMutablePointer.subscript(_: Int)
- UnsafeMutablePointer.alloc(_:)
- UnsafeMutablePointer.advancedBy(_:)
- UnsafeMutablePointer.advancedBy(_:limit:)
- UnsafeMutablePointer.assignBackwardFrom(_:count:)
- UnsafeMutablePointer.assignFrom(_:count:)
- UnsafeMutablePointer.dealloc(_:)
- UnsafeMutablePointer.destroy()
- UnsafeMutablePointer.destroy(_:)
- UnsafeMutablePointer.distanceTo(_:)
- UnsafeMutablePointer.initialize(_:)
- UnsafeMutablePointer.initializeFrom(_:)
- UnsafeMutablePointer.initializeFrom(_:count:)
- UnsafeMutablePointer.move()
- UnsafeMutablePointer.moveAssignFrom(_:count:)
- UnsafeMutablePointer.moveInitializeBackwardFrom(_:count:)
- UnsafeMutablePointer.moveInitializeFrom(_:count:)
- UnsafeMutablePointer.predecessor()
- UnsafeMutablePointer.stride(through:by:)
- UnsafeMutablePointer.stride(to:by:)
- UnsafeMutablePointer.successor()
- UnsafePointer.init()
- UnsafePointer.init(_: COpaquePointer)
- UnsafePointer.init<U>(_: UnsafeMutablePointer<U>)
- UnsafePointer.init<U>(_: UnsafePointer<U>)
- UnsafePointer.init(bitPattern: Int)
- UnsafePointer.init(bitPattern: UInt)
- UnsafePointer.init(nilLiteral:)
- UnsafePointer.subscript(_: Int)
- UnsafePointer.advancedBy(_:)
- UnsafePointer.advancedBy(_:limit:)
- UnsafePointer.distanceTo(_:)
- UnsafePointer.predecessor()
- UnsafePointer.stride(through:by:)
- UnsafePointer.stride(to:by:)
- UnsafePointer.successor()
- UTF16.init()
- UTF16.encode(_:output:)
- UTF16.isLeadSurrogate(_:)
- UTF16.isTrailSurrogate(_:)
- UTF16.leadSurrogate(_:)
- UTF16.measure(_:input:repairIllFormedSequences:)
- UTF16.trailSurrogate(_:)
- UTF16.width(_:)
- UTF16.decode(inout:)
- UTF32.init()
- UTF32.encode(_:output:)
- UTF32.decode(inout:)
- UTF8.init()
- UTF8.encode(_:output:)
- UTF8.isContinuation(_:)
- UTF8.decode(inout:)
- Zip2Generator.init(_:_:)
- Zip2Generator.next()
- Zip2Sequence.init(_:_:)
- Zip2Sequence.contains(_:)
- Zip2Sequence.dropFirst()
- Zip2Sequence.dropFirst(_:)
- Zip2Sequence.dropLast()
- Zip2Sequence.dropLast(_:)
- Zip2Sequence.elementsEqual(_:isEquivalent:)
- Zip2Sequence.enumerate()
- Zip2Sequence.filter(_:)
- Zip2Sequence.flatMap<T>(_: (Generator.Element) throws -> T?)
- Zip2Sequence.flatMap<S : SequenceType>(_: (Generator.Element) throws -> S)
- Zip2Sequence.forEach(_:)
- Zip2Sequence.generate()
- Zip2Sequence.lexicographicalCompare(_:isOrderedBefore:)
- Zip2Sequence.map(_:)
- Zip2Sequence.maxElement(_:)
- Zip2Sequence.minElement(_:)
- Zip2Sequence.prefix(_:)
- Zip2Sequence.reduce(_:combine:)
- Zip2Sequence.reverse()
- Zip2Sequence.sort(_:)
- Zip2Sequence.split(_:allowEmptySlices:isSeparator:)
- Zip2Sequence.startsWith(_:isEquivalent:)
- Zip2Sequence.suffix(_:)
- Zip2Sequence.underestimateCount()
- Zip2Sequence.lexicographicalCompare(_:)
- Zip2Sequence.maxElement()
- Zip2Sequence.minElement()
- Zip2Sequence.sort()
- Zip2Sequence.elementsEqual(_:)
- Zip2Sequence.split(_:maxSplit:allowEmptySlices:)
- Zip2Sequence.startsWith(_:)
- Zip2Sequence.flatten()
- Zip2Sequence.joinWithSeparator(_:)
Variable
Type
Constant
Function(36)
Section(5)
Alias(294)
Operator(44)
Protocol(84)
Method(3773)
Variable(612)
Type(120)
Constant(48)