Here’s my situation. I have an endless sequence that generates integers from min to max and back. So I initially figured, “let me just make a generator”. (I’m not saying this is a good generator. I just want to know if I should be using a generator here.)

public struct UpAndDownIntGenerator: GeneratorType {
    public typealias Element = Int
    let (magnitude, period): (Int, Int)
    let minValue: Int
    var currentOffset: Int = 0

    public init(minValue: Int = 0, maxValue: Int) {
        assert(minValue < maxValue, 
            "minValue must be less than maxValue") 
        self.minValue = minValue 
        magnitude = maxValue - minValue 
        period = magnitude * 2 
    }

    public mutating func next() -> Int? {
        let value = currentOffset % period
        let adjustedValue = value % magnitude
        let isAscending = value < magnitude
        defer { currentOffset += 1 }
        return minValue + (isAscending 
            ? adjustedValue 
            : magnitude - adjustedValue)
    }
}

But this generator is never going to terminate and I know it will always return a non-nil value. So I added this:

    // This is not going to be fed into a sequence
    // so fetch the next value and test for nil
    public mutating func fetchNextValue() -> Element {
        guard let value = next() else {
            fatalError("unable to generate next value")
        }
        return value
    }

And then I was all: So why bother being a generator with the extra overhead? Why am I creating something that has the hallmarks of a generator but isn’t suitable for use in a sequence (for example, mapping over an infinite sequence or filtering, or just figuring how to grab one value at a time). So then I wrote this:

public struct UpAndDownProducer {
    let (magnitude, period): (Int, Int)
    let minValue: Int
    var currentOffset: Int = 0

    public init(minValue: Int = 0, maxValue: Int) {
        assert(minValue < maxValue, 
            "minValue must be less than maxValue") 
        self.minValue = minValue 
        magnitude = maxValue - minValue 
        period = magnitude * 2 
    }

    public mutating func next() -> Int {
        let value = currentOffset % period
        let adjustedValue = value % magnitude
        let isAscending = value < magnitude
        defer { currentOffset += 1 }
        return minValue + (isAscending 
            ? adjustedValue 
            : magnitude - adjustedValue)
    } 
}

So what should I actually be doing here? Advice greatly appreciated.

p.s. The following would be a much simpler approach:

public struct UpAndDownProducer {
    let minValue, maxValue: Int
    var currentValue: Int
    var direction = -1
    
    public init(minValue: Int = 0, maxValue: Int) {
        assert(minValue != maxValue,
            "No point going up and down between two equal values")

       // Since it starts at minValue, it's
       // going to flip immediately.
       if maxValue < minValue { direction = 1 }
       currentValue = minValue 
       (self.minValue, self.maxValue) = (minValue, maxValue) 
    } 

    public mutating func next() -> Int {
        defer {
            if currentValue == minValue || currentValue == maxValue {
                direction *= -1
            }
            currentValue += direction
        }
        return currentValue
    }
}

p.p.s. Davide De Franceschi suggests something along the following lines:

protocol EndlessGeneratorType: GeneratorType {}
extension EndlessGeneratorType {
    public mutating func someNext() -> Element {
        guard let element = next() else { 
            fatalError("EndlessGeneratorType must always have a next() element") 
        }
        return element
    }
}

he adds:

@jckarter @ericasadun @tTikitu @vvendra imho it's always best to conform to relevant protocols: present + future + 3rd party free goodies

— Davide De Franceschi (@DeFrenZ) March 17, 2016