     public subscript(position: Index) -> Element {
         return transform(base[position])
     }
+    
+    public func generate() -> Generator {
+        return ParallelMapCollectionGenerator(base: base.generate(), transform: transform)
+    }
+}
+
+public struct ParallelMapCollectionGenerator<Base: GeneratorType, Element> : GeneratorType, SequenceType {
+    
+    private var base: Base
+    private let transform: (Base.Element) -> Element
+    
+    public mutating func next() -> Element? {
+        return base.next().map(transform)
+    }
 }
 
 extension ParallelCollectionType {

    
    private let base: Base
    
    public typealias Generator = IndexingGenerator<ParallelCollection>
    
    public typealias Index = Base.Index
    

    public subscript(position: Index) -> Base.Generator.Element {
        return base[position]
    }
    
    public func generate() -> Generator {
        return ParallelCollectionGenerator(base: base.generate())
    }
}

public struct ParallelCollectionGenerator<Base: GeneratorType> : GeneratorType, SequenceType {
    
    private var base: Base
    
    public mutating func next() -> Base.Element? {
        return base.next()
    }
}

public struct ParallelMapCollection<Base: CollectionType, Element where Base.Index : RandomAccessIndexType> : ParallelCollectionType {
