ChunkSequence 🔪🍰

Have cake and eat it

Have a cake and consume the cake by the Swift function, at the same time. Magic.

The nature of the Swift type is that it is copied or copied on write. When I assign A to B (A = B), then effectively B is copy of A.

And there are slices

ArraySlice presents a view onto the storage of some larger array.

A Slice is a view of subrange of the collection. Here is small tip I found useful about that.

I can slice any array in pieces, then process one chunk at a time using the SequenceType. I use it all the time in CryptoSwift, this way I can easily do intermediate computations still working on the same copy of input.

Sequence of pieces

The ChunkSequence struct I demonstrate here (below) is kind of implementation of split() and stride() together. It produces sequence of slices for given Array of elements.

I'll start depiction with the yummy 🎂, then simply use 🔪 to have a 🍰

var 🎂 = ["🍰","🍰","🍰","🍰","🍰"]  
for 🍰 in 🎂.slice(every: 2) {  

this results with at most 2 pieces of cake for every person

ArraySlice<🎂> = [🍰,🍰]  
ArraySlice<🎂> = [🍰,🍰]  
ArraySlice<🎂> = [🍰]  

...or boring numbers example:

var array = [1,2,3,4,5]  
for slice in array.slice(every: 2) {  
    // ArraySlice<Int> = [1,2]
    // ArraySlice<Int> = [3,4]
    // ArraySlice<Int> = [5]

slice() is added with convenient Array extension

extension Array {  
    func slice(every every: Index) -> ChunkSequence<Element> {
        return ChunkSequence(chunkSize: every, collection: self)

built with ChunkSequence struct

struct ChunkSequence<Element>: SequenceType {  
    let chunkSize: Array<Element>.Index
    let collection: Array<Element>

    func generate() -> AnyGenerator<ArraySlice<Element>> {
        var offset:Array<Element>.Index = collection.startIndex
        return anyGenerator {
            let result = self.collection[offset..<offset.advancedBy(self.chunkSize, limit: self.collection.endIndex)]
            offset += result.count
            return result.count > 0 ? result : nil

a piece of cake. Bon appétit!


PS. I wrote more detailed post about Sliceable back in the times of Swift 1.0