Product.Swift

struct ProdGen<C : CollectionType> : GeneratorType {
  
  typealias Element = [C.Generator.Element]
  private let seqs: [C]
  private var gens: [C.Generator]
  private var cur: Element
  
  mutating func next() -> Element? {
    for i in gens.indices.reverse() {
      if let n = gens[i].next() {
        cur[i] = n
        return cur
      } else {
        gens[i] = seqs[i].generate()
        cur[i] = gens[i].next()!
      }
    }
    return nil
  }
  
//  mutating func next() -> Element? {
//    if let n = gens[i].next() {
//      cur[i] = n
//      i = gens.count - 1
//      return cur
//    }
//    gens[i] = seqs[i].generate()
//    cur[i] = gens[i].next()!
//    return --i < 0 ? nil : next()
//  }

  init(seqs: [C]) {
    var gens = seqs.map{$0.generate()}
    self.seqs = seqs
    self.cur = dropLast(gens).indices.map{gens[$0].next()!} + [self.seqs.last!.first!]
    self.gens = gens
  }
}

struct ProdSeq<C : CollectionType> : SequenceType {
  typealias Generator = ProdGen<C>
  private let seqs: [C]
  func generate() -> Generator {
    return ProdGen( seqs: seqs )
  }
}

func product<C : CollectionType>(cols: [C]) -> ProdSeq<C> {
  return ProdSeq(seqs: cols)
}

extension SequenceType where Generator.Element : SequenceType {
  func product() -> ProdSeq<[Generator.Element.Generator.Element]> {
    return ProdSeq(seqs: self.map{Array($0)})
  }
}

extension SequenceType where Generator.Element : CollectionType {
  func product() -> ProdSeq<Generator.Element> {
    return ProdSeq(seqs: Array(self))
  }
}