49用d编程区间

把区间与容器/算法结合起来的是模板(非常重要).
stl.拉开序幕.
d的区间,RandomAccessRange,最强大,随机访问,就是类似数组.

import std.stdio;
import std.algorithm;

void main(){
     int [] values = [1,20,7,11];
    writeln(values.filter!(value => value> 10));
//返回的是区间
}
 int[] chosen = values.filter!(value => value > 10); //编译错误,
//不能把FilterResult!(__lambda2, int[])转换为int[]
//但可以转为数组.

传统的:

struct Node {
    int element;
    Node * next;
}

void print(const(Node) * list) {
    for ( ; list; list = list.next) {
        write(' ', list.element);
    }
}

数据结构知道算法如何实现.类似的

void print(const int[] array) {
    for(int i = 0;i != array.length; ++i) {//长度
        write(' ', array[i]);//[]
    }
}

因而传统N种算法,M种数据结构,
数组,链表,关联数组,二叉树,堆等必须编写find(), sort(), swap()等算法.折腾.接近N星M的折腾.但无法对关联数组排序.
但区间远离数据结构.只需要实现N种算法,M种数据结构就可以了.区间就是搞个规范.然后你们去实现吧.

    foreach (value; 3..7) {//数字区间
    int[] slice = array[5..10];  

各种各样的区间输入(empty,front,popFront),前向(前+save),双向(back,popBack),随机([],另一个..)区间.
随机还分有限/无限随机访问区间.
还有输出区间.要求put(range, element)操作.

    int[] slice = [ 10, 11, 12 ];

    for (int i = 0; i != slice.length; ++i) {
        write(' ', slice[i]);
    }

    assert(slice.length == 3); 

迭代容器元素,并不改变容器自身.

   for ( ; slice.length; slice = slice[1..$]) {
        write(' ', slice[0]);   // 瞎折腾
    }

另造一个切片来:

   int[] slice = [ 10, 11, 12 ];
    int[] surrogate = slice;

    for ( ; surrogate.length; surrogate = surrogate[1..$]) {
        write(' ', surrogate[0]);
    }

    assert(surrogate.length == 0); //0
    assert(slice.length == 3);     //不变

d标准库也是这样,返回特殊的,原来的切片不变.
输入区间三函数empty,front,popFront(),前两个可当属性用.
popFront()有(),表明改变了.

void print(T)(T range) {
    for ( ; !range.empty; range.popFront()) {
        write(' ', range.front);
    }

    writeln();
}

示例:

import std.string;

struct Student {
    string name;
    int number;

    string toString() const {
        return format("%s(%s)", name, number);
    }
}

struct School {
    Student[] students;
}

void main() {
    auto school = School( [ Student("Ebru", 1),
                            Student("Derya", 2) ,
                            Student("Damla", 3) ] );
}

加三成员:

struct School {
    // ...

    @property bool empty() const {
        return students.length == 0;
    }//判断是否为空,好结束判断
    @property ref Student front(){
         return students [0];
    }//当前元素,返回引用
    void popFront() {
        students = students[1 .. $];
    }//修改元素.这里删元素不合理.
}

只导入std.array,就可使最常见的容器类型匹配最有能力的区间类型:切片可按随机访问区间使用.
std.array可为切片提供empty, front, popFront()和其他函数.因而任意区间函数可使用切片.

import std.array;
// ...
    print([ 1, 2, 3, 4 ]);

如果导入了std.range,就没必要导入std.array了.

void print(T)(T range) {
    for ( ; !range.empty; range.popFront()) {
        write(' ', range.front);
    }//编译错误,定义处

    writeln();
}

void main() {
    int[4] array = [ 1, 2, 3, 4 ];
    print(array);
}

由于切片中的popFront要删元素,因而固定数组不能用作区间(元素不变),

void print(T)(T range)
        if (isInputRange!T) {    //限制模板
    // ...
}
// ...
    print(array);    //报编译错误.调用处

固定数组仍然可以:print(array[]);//编译,复制成区间了.
尽管切片可用作区间,不是所有区间都可用作数组.

import std.array;
// ...
    // 注意: 利用统一调用
    auto copiesOfStudents = school.array;//不注意,就看不出来.
    writeln(copiesOfStudents);

std.array.array帮助从切片转成数组.其迭代输入区间复制为一个新数组.
把串自动解码为dchar的区间.其实这是个坏主意.
当把串用作区间时,自动解码串元素.

void printElements(T)(T str) {
    for (int i = 0; i != str.length; ++i) {
        write(' ', str[i]);
    }

    writeln();
}

// ...

    printElements("abc?deé??"c);
    printElements("abc?deé??"w);
    printElements("abc?deé??"d);

自动解码的值不是实际元素,而是右值.

import std.array;

void main() {
    char[] s = "hello".dup;
    s.front = 'H';//编译错误//右值
}

这样:

import std.array;
import std.string;//represention

void main() {
    char[] s = "hello".dup;
    s.representation.front = 'H';    // 编译
    assert(s == "Hello");
//串被当作`ubyte`数组
}

char, wchar, 和 dchar的表示为ubyte, ushort, 和 uint
切片的一个优势:不拥有元素,每次调用popFront时计算返回元素,front返回当前元素作为值,其为dchar代表一个统一码
一些区间没有元素,但能访问其他区间元素,为了保留实际元素,可用特殊区间.

struct School {
    Student[] students;
}

struct StudentRange {
    Student[] students;

    this(School school) {
        this.students = school.students;
    }//这里.则学校不再是区间

    @property bool empty() const {
        return students.length == 0;
    }

    @property ref Student front() {
        return students[0];
    }

    void popFront() {
        students = students[1 .. $];
    }
}
//使用
    auto school = School( [ Student("Ebru", 1),
                            Student("Derya", 2) ,
                            Student("Damla", 3) ] );

    print(StudentRange(school));

    // 原元素,保留了的
    assert(school.students.length == 3);

无限区间enum empty = false;,或static immutable empty = false;

struct FibonacciSeries
{
    int current = 0;
    int next = 1;//但不超过`int.max`

    enum empty = false ;   //无限区间
 
    @property int front()const {
         return current;
    }

    void popFront(){
         const nextNext = current + next;
        current = next;
        next = nextNext;
    }
}

print(FibonacciSeries());不会终止.
当不需要消耗完区间时有用.

StudentRange studentsOf(ref School school) {
    return StudentRange(school);
}
// ...
    print(school.studentsOf);//注意,利用统一调用

感觉又是个间接层(麻烦),//避免显式记区间类型.

import std.range;

// ...
    auto school = School( [ Student("Ebru", 1),
                            Student("Derya", 2) ,
                            Student("Damla", 3) ] );
    print(school.studentsOf.take(2));
//先要从学生们中建一个学校

writeln(typeof(school.studentsOf.take(2)).stringof);感觉很折腾.得到Take!(StudentRange)
std.range and std.algorithm有大量区间,结构,类和算法.

import std.algorithm;

// ...

    auto turkishSchool = School( [ Student("Ebru", 1),
                                   Student("Derya", 2) ,
                                   Student("Damla", 3) ] );

    auto americanSchool = School( [ Student("Mary", 10),
                                    Student("Jane", 20) ] );

    swapFront(turkishSchool.studentsOf,
              americanSchool.studentsOf);
//交换区间头

    print(turkishSchool.studentsOf);
    print(americanSchool.studentsOf);

过滤

 print(school.studentsOf.filter!(a => a.number % 2));
import std.array;

// ...

    bool startsWithD(Student student) {
        return student.name.front == 'D';
    }

    print(school.studentsOf.filter!startsWithD);

其实与c++的元编程没啥区别.(过滤!函数)就是过滤<函数>(),只不过c++比较夸张而已.
注意student.name[0],这是第一个代码单元,不是第一个字母

import std.stdio;
import std.range;
import std.random;

void main() {
    auto diceThrower = generate!(() => uniform(0, 6));
    writeln(diceThrower.take(10));
}

std.range的generate从可调用实体(函数,指针,λ)生成区间.无穷区间,函数返回值作为一个个的元素.
懒,不到使用时不干活.
前向区间提供save函数.返回区间副本.

struct FibonacciSeries {
 // ...
    @property FibonacciSeries save()const {
         return  this ;
    }//副本,不是引用.
}

import std.range;

// ...

void report(T)(const dchar[] title, const ref T range) {
    writefln("%40s: %s", title, range.take(5));
}

void main() {
    auto range = FibonacciSeries();
    report("Original range", range);

    range.popFrontN(2);
    report("After removing two elements", range);

    auto theCopy = range.save;
    report("The copy", theCopy);

    range.popFrontN(3);
    report("After removing three more elements", range);
    report("The copy", theCopy);
}

区间是挨个挨个的.
stdio也可带InputRange对象.
writeln(FibonacciSeries().take(5).cycle.take(20));
[0, 1, 1, 2, 3, 0, 1, 1, 2, 3, 0, 1, 1, 2, 3, 0, 1, 1, 2, 3]

    auto series                   = FibonacciSeries();
    auto firstPart                = series.take(5);
    auto cycledThrough            = firstPart.cycle;
    auto firstPartOfCycledThrough = cycledThrough.take(20);
//上面为区间
    writeln(firstPartOfCycledThrough);

哪有这么麻烦?
双向区间:

import std.array;
import std.stdio;

struct Reversed {
    int[] range;

    this(int[] range) {
        this.range = range;
    }

    @property bool empty() const {
        return range.empty;
    }

    @property int front() const {
        return range.back;  // 逆向
    }

    @property int back() const {
        return range.front; // 逆向
    }

    void popFront() {
        range.popBack();    // 逆向
    }

    void popBack() {
        range.popFront();   // 逆向
    }
}

void main() {
    writeln(Reversed([ 1, 2, 3]));
}

随机访问[].
char,wchar不能随机访问,
无穷随机编译时empty==false,
有穷,定义了长度属性

class SquaresRange {
    int first;

    this(int first = 0) {
        this.first = first;
    }

    enum empty = false;

    @property int front() const {
        return opIndex(0);
    }

    void popFront() {
        ++first;
    }

    @property SquaresRange save() const {
        return new SquaresRange(first);
    }

    int opIndex(size_t index) const {
         /* 常数时间*/
        immutable integerValue = first + cast(int)index;
        return integerValue * integerValue;
    }
}
    squares.popFrontN(5);//弹N
    writeln(squares[0]);//头,
//=-=========
 bool are_lastTwoDigitsSame(int value) {
        if (value < 10) {//至少
            return false;
        }

        immutable lastTwoDigits = value % 100;
        return (lastTwoDigits % 11) == 0;
    }//可整除11.

    writeln(squares.take(50).filter!are_lastTwoDigitsSame);

示例:

    auto range = Together([ 1, 2, 3 ], [ 101, 102, 103]);
    writeln(range[4]);

元素不直接复制,只是从原区间访问.

struct Together {
    const(int)[][] slices;

    this(const(int)[][] slices...) {//
        this.slices = slices.dup;

        clearFront();
        clearBack();
    }//去头尾空切片
    private  void clearFront(){
         while(!slices.empty && slices.front.empty){
            slices.popFront();
        }
    }

    private  void clearBack(){
         while(!slices.empty && slices.back.empty){
            slices.popBack();
        }
    }
    @property bool empty() const {
        return slices.empty;
    }
    @property int front() const {
        return slices.front.front;
    }
    void popFront(){
        slices.front.popFront();
        clearFront();//每一次都要校验,
    }
    @property Together save()const {
         return Together(slices.dup);
    }//仍然是区间,不是实体.
    @property int back()const {
         return slices.back.back;
    }

    void popBack(){
        slices.back.popBack();
        clearBack();
    }//尾类似
    @property size_t length()const {
        size_t totalLength = 0;

        foreach(slice;slices){
            totalLength + = slice.length;
        }

        return totalLength;
    }//上下两个一样的.
    @property size_t length()const {
         return slices.fold!((a，b)=> a + b.length)(size_t.init);
    }
    int opIndex(size_t index) const {
        /* Save the index for the error message */
        immutable originalIndex = index;

        foreach (slice; slices) {
            if (slice.length > index) {
                return slice[index];

            } else {
                index -= slice.length;
            }
        }

        throw new Exception(
            format("Invalid index: %s (length: %s)",originalIndex, this.length));
    }//太麻烦了.不能`常数时间`访问
}

其实切片是搞复杂了.每一次都要校验,能不复杂吗?
看得出来,搞复杂了.

    auto range = Together(FibonacciSeries().take(10).array,
                          [ 777, 888 ],
                          (new SquaresRange()).take(5).array);

    writeln(range.save);

可用,但太长,太麻烦,不推荐.
输出区间

情况	方法
R有成员函数叫put,并取E作参数	range.put(e);
R有成员函数叫put,并取E[]作参数	range.put([ e ]);
R是输入区间,e可赋值给range.front	range.front = e;range.popFront();
E是输入区间,可复制给R	for(;!e.empty;e.popFront())put(range, e.front);
R有E作参数(如R可能是闭包)	range(e);
R有E[]作参数(如R可能是闭包)	range([e]);

其中R为区间类型,E为元素类型,range为区间对象,e为区间元素

struct MultiFile {
    string delimiter;
    File[] files;

    this(string delimiter, string[] fileNames...) {
        this.delimiter = delimiter;

        /* 总是包含stdout*/
        this.files ~= stdout;

        /* 每个文件名的文件对象*/
        foreach (fileName; fileNames) {
            this.files ~= File(fileName, "w");
        }
    }

    // 取数组的版本,但不是串
    void put(T)(T slice)
            if (isArray!T && !isSomeString!T) {
        foreach (element; slice) {
            put(element);//调用下面其他版本的put
        }
    }

    // 取非数组和是串的版本
    void put(T)(T value)
            if (!isArray!T || isSomeString!T) {
        foreach (file; files) {
            file.write(value, delimiter);
        }
    }
}

接着

import std.traits;
import std.stdio;
import std.algorithm;

// ...

void main() {
    auto output = MultiFile("\n", "output_0", "output_1");
    copy([ 1, 2, 3], output);
    copy([ "red", "blue", "green" ], output);
}

标准库中std.algorithm.copy使用输出区间

import std.stdio;
import std.range;

void main() {
    int[] slice = [ 1, 2, 3 ];
    int[] slice2 = slice;

    put(slice2, 100);

    writeln(slice2);//只2个元素,丢了一个
    writeln(slice);
}

再:

    int[] slice = [ 1, 2, 3 ];
    int[] slice2 = slice;

    foreach (i; 0 .. 4) {    
        put(slice2, i * 100);
    }

由程序员保证空间足够,输出区间也是一个折腾.

import std.array;

// ...

    auto a = appender([ 1, 2, 3 ]);

    foreach (i; 0 .. 4) {
        a.put(i * 100);
    }

补救措施.
还可以

    a ~= 1000;writeln(a.data);

c++的一个向量,都搞定了.还有区间模板.