Why array array primitives use their sources?

Question

Range primitives designed for embedded arrays consume their sources, but you can easily develop a range system that would rather be based on the .ptr source (look more flexible at first). A.

 struct ArrayRange(T) { private T* _front; private T* _back; this(ref T[] stuff) { _front = stuff.ptr; _back = _front + stuff.length; } @property bool empty(){return _front == _back;} @property T front(){ return *_front;} @property T back(){return *_back;} void popFront(){ ++_front;} void popBack(){--_back;} T[] array(){return _front[0 .. _back - _front];} typeof(this) save() { auto r = this.array.dup; return typeof(this)(r); } } void main(string[] args) { auto s = "bla".dup; // here the source is 'fire-proofed' auto rng = ArrayRange!char(s); rng.popFront; assert (s == "bla"); assert (rng.array == "la"); // default primitives: now the source is consumed import std.array; s.popFront; assert (s == "la"); } 

Why is the default system not based on pointer arithmetic, since the appearance of a front implies redistribution / lower efficiency?

Any rationale for this project?

Answer 1

I agree with you, there is no reason to redistribute in every popFront . Well, that's not what happens then!

The popFront mechanism popFront very similar to what you presented, and the source is not consumed, but only the array on which you call popFront (because it is still pop). What you implemented is what happens when you slice an array: you get a reference range for the original array:

 auto a = [1, 2, 3]; auto s = a[]; s.popFront; assert(s == [2, 3]); assert(a == [1, 2, 3]); 

.dup exists to provide a copy of the array so that you can safely modify the copy without changing the original, therefore it copies the original array and provides an input range for that copy. Of course, you can change the copy (which is the point), and popFront will change it, but it still uses pointer arithmetic without changing the source.

 auto a = [1, 2, 3]; auto s = a.dup; s.popFront; assert(s = [2, 3]); assert(a = [1, 2, 3]); 

.dup may not seem very useful as such, because we use it with arrays, but it is very important to deal with "clean" ranges, since the range is often lazy so as not to consume it. Since the copy of the range is consumed, not the original one, we can safely pass this copy to the function and still have our initial lazy range.