GenHelpers.Swift

public struct BuildGen<T> : GeneratorType {
  typealias Element = T
  private var cur: T
  private let inc: T -> T
  public mutating func next() -> Element? {
    defer { cur = inc(cur) }
    return cur
  }
  public init(start: T, inc: T -> T) {
    self.cur = start
    self.inc = inc
  }
}

public struct RollGen<T> : GeneratorType {
  typealias Element = T
  private var cur: T
  private let inc: T -> T
  public mutating func next() -> Element? {
    cur = inc(cur)
    return cur
  }
}

public struct IncGenAfter<I : ForwardIndexType> : GeneratorType {
  typealias Element = I
  private var cur: I
  public mutating func next() -> Element? {
    cur._successorInPlace()
    return cur
  }
}

public struct IncGenAt<I : ForwardIndexType> : GeneratorType {
  typealias Element = I
  private var cur: I
  public mutating func next() -> Element? {
    defer { cur._successorInPlace() }
    return cur
  }
}

public struct IncSeqAfter<I : ForwardIndexType> : LazySequenceType {
  typealias Generator = IncGenAfter<I>
  private let start: I
  public func generate() -> Generator {
    return IncGenAfter(cur: start)
  }
}

public struct IncSeqAt<I : ForwardIndexType> : LazySequenceType {
  typealias Generator = IncGenAt<I>
  private let start: I
  public func generate() -> Generator {
    return IncGenAt(cur: start)
  }
}

postfix operator ... {}
public postfix func ... <I : ForwardIndexType>(f: I) -> IncSeqAt   <I> {
  return IncSeqAt(start: f)
}

public postfix func ... <I : BidirectionalIndexType>(f: I) -> IncSeqAfter<I> {
  return IncSeqAfter(start: f.predecessor())
}

public struct StrideForeverGen<T : Strideable> : GeneratorType {
  
  typealias Element = T
  
  private let strd: T.Stride
  private var cur: T
  
  public mutating func next() -> Element? {
    defer { cur = cur.advancedBy(strd) }
    return cur
  }
}

public struct StrideForeverSeq<T : Strideable> : LazySequenceType {
  
  typealias Generator = StrideForeverGen<T>
  
  private let strd: T.Stride
  private let strt: T
  
  public func generate() -> Generator { return StrideForeverGen(strd: strd, cur: strt) }
  
}

public func stride<T : Strideable>(from: T, by: T.Stride) -> StrideForeverSeq<T> {
  return StrideForeverSeq(strd: by, strt: from)
}

public struct CycleGen<C: CollectionType> : GeneratorType, LazySequenceType {
  
  typealias Element = C.Generator.Element
  typealias Generator = CycleGen<C>
  
  private let inner: C
  private var innerGen: C.Generator
  
  private init(col: C) {
    self.inner = col
    self.innerGen = col.generate()
  }
  
  public func generate() -> Generator {
    return self
  }
  
  public mutating func next() -> Element? {
    for ;;innerGen = inner.generate() {
      if let next = innerGen.next() {
        return next
      }
    }
  }
}

public extension CollectionType {
  func cycle() -> CycleGen<Self> {
    return CycleGen(col: self)
  }
}