cst.Swift

struct LayerGen<T> : GeneratorType {
  
  typealias Element = T
  private let proc: T -> T
  
  private var prev: T
  
  mutating func next() -> Element? {
    prev = proc(prev)
    return prev
  }
}

struct LayerSeq<T> : SequenceType {
  
  typealias Generator = LayerGen<T>
  
  private let start: T
  private let proc: T -> T
  
  func generate() -> Generator {
    return LayerGen(proc: proc, prev: start)
  }
  
  init(initial: T, inc: T -> T) {
    self.start = initial
    self.proc = inc
  }
}

struct CStyleGen<T> : GeneratorType {
  
  typealias Element = T
  
  private var prev: T
  private let cond: T -> Bool
  private let proc: T -> T
  
  
  mutating func next() -> Element? {
    defer { prev = proc(prev) }
    return cond(prev) ? prev : nil
  }
}

struct CStyleSeq<T> : SequenceType {
  
  typealias Generator = CStyleGen<T>
  
  private let start: T
  private let cond: T -> Bool
  private let proc: T -> T
  
  func generate() -> Generator {
    return CStyleGen(prev: start, cond: cond, proc: proc)
  }
  
  init(_ initial: T, _ cond: T -> Bool, _ inc: T -> T) {
    self.start = initial
    self.cond = cond
    self.proc = inc
  }
  
  init(_ initial: T, inc: T -> T) {
    self.init(initial, {_ in true}, inc)
  }
}