具有CollectionType的Swift协议和协议扩展

Question

I don't understand the return type for an array.indexOf() in swift. When I command click the function it takes me to a protocol extension:

extension CollectionType where Generator.Element : Equatable {

/// Returns the first index where `value` appears in `self` or `nil` if
/// `value` is not found.
///
/// - Complexity: O(`self.count`).
func indexOf(element: Self.Generator.Element) -> Self.Index?
}

The method indexOf returns Self.Index?,

how does it know that its an Int?

Answer 1

If you look into Swift header for _CollectionDefaultsType, you will see the protocol definition as follows,

protocol _CollectionDefaultsType : SequenceType {

    /// A type that represents a valid position in the collection.
    ///
    /// Valid indices consist of the position of every element and a
    /// "past the end" position that's not valid for use as a subscript.
    typealias Index : ForwardIndexType

    /// The position of the first element in a non-empty collection.
    ///
    /// In an empty collection, `startIndex == endIndex`.
    var startIndex: Self.Index { get }

    /// The collection's "past the end" position.
    ///
    /// `endIndex` is not a valid argument to `subscript`, and is always
    /// reachable from `startIndex` by zero or more applications of
    /// `successor()`.
    var endIndex: Self.Index { get }

    /// Returns the first element of `self`, or `nil` if `self` is empty.
    var first: Self.Generator.Element? { get }
}

If you go through the Swift header file, you can see the definition of Array as follows

struct Array<T> : CollectionType, SequenceType, _CollectionDefaultsType, _CollectionGeneratorDefaultsType, MutableCollectionType, Sliceable, _Sliceable, _DestructorSafeContainer {

    /// The type of element stored by this `Array`.
    typealias Element = T

    /// Always zero, which is the index of the first element when non-empty.
    var startIndex: Int { get }

    /// A "past-the-end" element index; the successor of the last valid
    /// subscript argument.
    var endIndex: Int { get }
    subscript (index: Int) -> T

    /// Return a *generator* over the elements.
    ///
    /// - Complexity: O(1).
    func generate() -> IndexingGenerator<[T]>

    /// A type that can represent a sub-range of an `Array`.
    typealias SubSlice = ArraySlice<T>
    subscript (subRange: Range<Int>) -> ArraySlice<T>
}

The getter startIndex, endIndex, first are the ones which are implemented from the protocol _CollectionDefaultsType , whose type is Self.Index . Now, if you look at the definition of the indexOf method, it is implemented as a protocol extension with the type of Self.Index .

extension CollectionType where Generator.Element : Equatable {

    /// Returns the first index where `value` appears in `self` or `nil` if
    /// `value` is not found.
    ///
    /// - Complexity: O(`self.count`).
    func indexOf(element: Self.Generator.Element) -> Self.Index?
}

Thus, the type Index gets inferred to Int from above two implementation.

By the way, if you type into playground to see the type Index inside Array, typing Array.Index, the autocomplete shows the type as Int,