lazyFlatMap.swift

public struct FlatMapGen<G : GeneratorType, S : SequenceType> : GeneratorType {
  
  private let transform: G.Element -> S
  private var g : G
  private var innerGen : S.Generator?
  
  public mutating func next() -> S.Generator.Element? {
    for ; innerGen != nil; innerGen = g.next().map(transform)?.generate() {
      if let next = innerGen?.next() {
        return next
      }
    }
    return nil
  }
  private init(transform: G.Element -> S, var g: G) {
    self.transform = transform
    self.innerGen = g.next().map(transform)?.generate()
    self.g = g
  }
}

public struct FlatMapSequenceView<S0 : SequenceType, S1 : SequenceType> : SequenceType {
  
  private let seq: S0
  private let transform: S0.Generator.Element -> S1
  
  public func generate() -> FlatMapGen<S0.Generator, S1> {
    return FlatMapGen(transform: transform, g: seq.generate())
  }
  
  public var array: Array<S1.Generator.Element> { return Array(self) }
}

public extension LazyRandomAccessCollection {
  func flatMap<S : SequenceType>
    (transform: (Generator.Element) -> S) -> FlatMapSequenceView<LazyRandomAccessCollection, S> {
      return FlatMapSequenceView(seq: self, transform: transform)
  }
}

// Example:

let lazyArray = lazy([Int](1...5))

func printAndPutInArray(n: Int) -> [Int] {
  print(n)
  return [n, 100]
}

let lazyFlatMapped = lazyArray.flatMap(printAndPutInArray)

lazyFlatMapped.contains(3) // true

// Console output:
//
// 1
// 
// 2
//
// 3

lazyFlatMapped.array // [1, 100, 2, 100, 3, 100, 4, 100, 5, 100]