Swift Bulk Generator

Bulk Generator.swift

struct BulkGenerator<G : GeneratorType> : GeneratorType {
    
    var generator: G
    var bulk: [G.Element]
    var size: Int
    
    init(generator: G, size: Int){
        assert(size > 0, "Bulk size must be a positive integer")
        self.generator = generator
        self.size = size
        self.bulk = Array<G.Element>()
    }
    
    mutating func next() -> [G.Element]? {
        while bulk.count < size {
            if let next = generator.next() { bulk.append(next) }
            else { return nil }
        }
        let grab = bulk
        bulk.removeAtIndex(0)
        return grab
    }
}

struct BulkSequence<S : SequenceType> : SequenceType {
    
    let sequence: S
    let size: Int
    
    init(sequence: S, size: Int){
        self.sequence = sequence
        self.size = size
    }
    
    func generate() -> BulkGenerator<S.Generator> {
        return BulkGenerator(generator: sequence.generate(), size: size)
    }
}

func bulk<S : SequenceType>(size: Int) -> S -> BulkSequence<S> {
    return { sequence in
        return BulkSequence(sequence: sequence, size: size)
    }
}

// Example

var str = "Hey World"
for c in bulk(4)(str) {
    println(c) // -> [H, e, y,  ]
}              //    [e, y,  , W]
               //    [y,  , W, o]
               //    [ , W, o, r]
               //    [W, o, r, l]
               //    [o, r, l, d]