Swift Resistance Explored

First off, a struct is not an object. Structs in Swift, like many languages, are value types. They have the same packing structure in Swift as in C, especially in the example that I gave.

You can read more about them here: https://developer.apple.com/library/ios/documentation/Swift/...

I can write the same problem with components of the array as bytes if you prefer, but then performance will be even worse. The root cause of the performance issues is the array access and set. The more the do, the worse the performance.

So what you are saying, is that no person would ever create an array of data and expect to do anything with that data? And they would never do that in a processing loop? Ok...

If you actually read the blog post, you can see that I already gave an example using raw buffers (the UnsafeMutablePointer). Which means that every index into the pointer moves 4 bytes. Again, using UnsafeMutablePointer is not doing anything other than creating a harder API surface to work with.

Also, the UnsafePointer types exist because without them, there would be no way to interact with C code. And if I need to use the UnsafePointer types everywhere I have arrays so that I can have reasonable performance in debug and release builds, then there is a bigger problem that needs to be addressed.

I wonder if creating a wrapper struct (let's call it Buffer) which combines an UnsafeMutablePointer and an UnsafeMutableBufferPointer would improve the language ergonomics while keeping the performance of the 'Swift*' version.

Buffer would have a constructor taking the number of items to store, and would upon creation create a buffer using UnsafeMutablePointer.alloc(). It would then use the UnsafeMutablePointer to build an UnsafeMutableBufferPointer. The latter type allows subscript indexing (e.g. myBuffer[10]) and iteration using for-in, which we could support by implementing a pass-through subscript() and generate() function.

Then, when using the struct, we'd pass it using inout parameters to ensure that it doesn't get copied.

This wouldn't fix the problem of Arrays being ludicrously unperformant, but it would at least make using the C-style buffer less painful.