Segmented Ranges?

[bearophile]

Andrei Alexandrescu:

> Would joiner help?

I don't know. I think the point of those segmented ranges is to 
not hide their segmented nature (as joiner does).

- - - - - - - - - - - - - -

This paper shows a variant of the stream fusion, applied on 
chunked arrays that represent strings:

"Rewriting Haskell Strings" (2007) by Duncan Coutts, Don Stewart, 
Roman Leshchinskiy:
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.90.3166


In D it's easy to create a range that segments a given lazy range 
into a lazy iterable of arrays:


import std.range: ElementType;
import std.array: empty, front, popFront;

struct Segmenter(size_t chunkLength, Range) {
     alias ElementType!Range elementT;
     private elementT[chunkLength] chunk;
     private Range r;
     private size_t len;

     this(Range rin) {
         this.r = rin;
         popFront();
     }

     @property bool empty() const {
         return len == 0 && r.empty;
     }

     @property elementT[] front() pure nothrow {
         return chunk[0 .. len];
     }

     void popFront() {
         len = 0;
         while (len < chunkLength && !r.empty) {
             chunk[len] = r.front;
             len++;
             r.popFront();
         }
     }
}


But Phobos ranges don't manage segments automatically (so you 
can't just apply a normal map on a Segmenter, because this map 
will work on the chunks), and there aren't the optimizations 
described in that paper. On the other hand some range methods 
become inlined, because D ranges are quite different from Haskell 
lazy lists, so maybe some of those optimizations are not needed.

Bye,
bearophile