如何在Swift中声明返回自定义结构序列的方法

Question

What is the proper way to declare a function that return a Sequence in Swift 4. I tried the following but receive a error stating:

error: Models.playground:29:13: error: cannot convert return expression of type 'Cars' to return type 'S' return Cars(cars) ^~~~~~~~~~ as! S

Here is the code I used:

import Foundation

struct Car {
    let make:String
    let model:String
}

class Cars: Sequence, IteratorProtocol {
    typealias Element = Car

    var current = 0
    let cars:[Element]
    init(_ cars:[Element]) {
        self.cars = cars;
    }

    func makeIterator() -> Iterator {
        current = 0
        return self
    }

    func next() -> Element? {
        if current < cars.count {
            defer { current += 1 }
            return cars[current]
        } else {
            return nil
        }
    }
}

let cars = Cars([Car(make:"Buick", model:"Century"), Car(make:"Buick", model:"LaSabre")])

func getCars<S:Sequence>(cars:[Car]) -> S where S.Iterator.Element == Car {
    return  Cars(cars)
}

Answer 1

The return value cannot be a specialization of the Sequence protocol. You can either return Cars itself, as Daniel suggested , or – if you want to hide the implementation of the sequence – a “type-erased” sequence:

func getCars(cars:[Car]) -> AnySequence<Car> {
    return AnySequence(Cars(cars))
}

or even

func getCars(cars:[Car]) -> AnySequence<Car> {
    return AnySequence(cars)
}

AnySequence is a generic struct conforming to the Sequence protocol which forwards to the underlying sequence or iterator from which it was created. See also A Little Respect for AnySequence for more examples.

Remark: Similarly, it is possible to make Cars a Sequence by returning a type-erased iterator which forwards to the array iterator:

class Cars: Sequence {
    typealias Element = Car

    let cars: [Element]
    init(_ cars: [Element]) {
        self.cars = cars;
    }

    func makeIterator() -> AnyIterator<Element> {
        return AnyIterator(cars.makeIterator())
    }
}

Answer 2

The problem is that you are using a generic for a specific type. You can either return a Cars element (note that Cars conforms to Sequence , so you are returning a Sequence here):

func getCars(cars: [Car]) -> Cars {
    return  Cars(cars)
}

or use a generic (also a Sequence , since it is defined in the generic):

func getCars<S: Sequence>(cars: [Car]) -> S {
    return cars as! S
}