Programação D - Faixas
Os intervalos são uma abstração do acesso ao elemento. Essa abstração permite o uso de um grande número de algoritmos sobre um grande número de tipos de contêineres. Os intervalos enfatizam como os elementos do contêiner são acessados, ao contrário de como os contêineres são implementados. Intervalos é um conceito muito simples que se baseia em se um tipo define determinados conjuntos de funções de membro.
Os intervalos são parte integrante das fatias de D. D's por acaso são implementações do intervalo mais poderoso RandomAccessRange, e há muitos recursos de intervalo em Phobos. Muitos algoritmos de Phobos retornam objetos de alcance temporário. Por exemplo, filter () escolhe elementos maiores que 10 no código a seguir, na verdade retorna um objeto de intervalo, não uma matriz.
Intervalos de números
Intervalos numéricos são comumente usados e esses intervalos são do tipo int. Alguns exemplos para intervalos de números são mostrados abaixo -
// Example 1
foreach (value; 3..7)
// Example 2
int[] slice = array[5..10];Fobos
Intervalos relacionados a structs e interfaces de classes são intervalos de phobos. Phobos é o runtime oficial e a biblioteca padrão que vem com o compilador da linguagem D.
Existem vários tipos de intervalos, que incluem -
- InputRange
- ForwardRange
- BidirectionalRange
- RandomAccessRange
- OutputRange
InputRange
O intervalo mais simples é o intervalo de entrada. As outras faixas trazem mais requisitos além da faixa em que se baseiam. Existem três funções que InputRange requer -
empty- especifica se o intervalo está vazio; ele deve retornar verdadeiro quando o intervalo for considerado vazio; caso contrário, false.
front - Fornece acesso ao elemento no início do intervalo.
popFront() - Encurta o intervalo desde o início, removendo o primeiro elemento.
Exemplo
import std.stdio;
import std.string;
struct Student {
string name;
int number;
string toString() const {
return format("%s(%s)", name, number);
}
}
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 .. $];
}
}
void main() {
auto school = School([ Student("Raj", 1), Student("John", 2), Student("Ram", 3)]);
auto range = StudentRange(school);
writeln(range);
writeln(school.students.length);
writeln(range.front);
range.popFront;
writeln(range.empty);
writeln(range);
}Quando o código acima é compilado e executado, ele produz o seguinte resultado -
[Raj(1), John(2), Ram(3)]
3
Raj(1)
false
[John(2), Ram(3)]ForwardRange
ForwardRange requer adicionalmente a parte da função de membro de salvamento das outras três funções de InputRange e retornar uma cópia do intervalo quando a função de salvamento for chamada.
import std.array;
import std.stdio;
import std.string;
import std.range;
struct FibonacciSeries {
int first = 0;
int second = 1;
enum empty = false; // infinite range
@property int front() const {
return first;
}
void popFront() {
int third = first + second;
first = second;
second = third;
}
@property FibonacciSeries save() const {
return this;
}
}
void report(T)(const dchar[] title, const ref T range) {
writefln("%s: %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);
}Quando o código acima é compilado e executado, ele produz o seguinte resultado -
Original range: [0, 1, 1, 2, 3]
After removing two elements: [1, 2, 3, 5, 8]
The copy: [1, 2, 3, 5, 8]
After removing three more elements: [5, 8, 13, 21, 34]
The copy: [1, 2, 3, 5, 8]BidirectionalRange
BidirectionalRange fornece adicionalmente duas funções de membro sobre as funções de membro de ForwardRange. A função posterior, semelhante à anterior, permite o acesso ao último elemento da gama. A função popBack é semelhante à função popFront e remove o último elemento do intervalo.
Exemplo
import std.array;
import std.stdio;
import std.string;
struct Reversed {
int[] range;
this(int[] range) {
this.range = range;
}
@property bool empty() const {
return range.empty;
}
@property int front() const {
return range.back; // reverse
}
@property int back() const {
return range.front; // reverse
}
void popFront() {
range.popBack();
}
void popBack() {
range.popFront();
}
}
void main() {
writeln(Reversed([ 1, 2, 3]));
}Quando o código acima é compilado e executado, ele produz o seguinte resultado -
[3, 2, 1]Infinite RandomAccessRange
opIndex () é adicionalmente necessário quando comparado ao ForwardRange. Além disso, o valor de uma função vazia deve ser conhecido no momento da compilação como falso. Um exemplo simples é explicado com intervalo de quadrados é mostrado abaixo.
import std.array;
import std.stdio;
import std.string;
import std.range;
import std.algorithm;
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 {
/* This function operates at constant time */
immutable integerValue = first + cast(int)index;
return integerValue * integerValue;
}
}
bool are_lastTwoDigitsSame(int value) {
/* Must have at least two digits */
if (value < 10) {
return false;
}
/* Last two digits must be divisible by 11 */
immutable lastTwoDigits = value % 100;
return (lastTwoDigits % 11) == 0;
}
void main() {
auto squares = new SquaresRange();
writeln(squares[5]);
writeln(squares[10]);
squares.popFrontN(5);
writeln(squares[0]);
writeln(squares.take(50).filter!are_lastTwoDigitsSame);
}Quando o código acima é compilado e executado, ele produz o seguinte resultado -
25
100
25
[100, 144, 400, 900, 1444, 1600, 2500]Finite RandomAccessRange
opIndex () e length são adicionalmente necessários quando comparados ao intervalo bidirecional. Isso é explicado com a ajuda de um exemplo detalhado que usa a série Fibonacci e o exemplo de intervalo de quadrados usado anteriormente. Este exemplo funciona bem no compilador D normal, mas não funciona no compilador online.
Exemplo
import std.array;
import std.stdio;
import std.string;
import std.range;
import std.algorithm;
struct FibonacciSeries {
int first = 0;
int second = 1;
enum empty = false; // infinite range
@property int front() const {
return first;
}
void popFront() {
int third = first + second;
first = second;
second = third;
}
@property FibonacciSeries save() const {
return this;
}
}
void report(T)(const dchar[] title, const ref T range) {
writefln("%40s: %s", title, range.take(5));
}
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 {
/* This function operates at constant time */
immutable integerValue = first + cast(int)index;
return integerValue * integerValue;
}
}
bool are_lastTwoDigitsSame(int value) {
/* Must have at least two digits */
if (value < 10) {
return false;
}
/* Last two digits must be divisible by 11 */
immutable lastTwoDigits = value % 100;
return (lastTwoDigits % 11) == 0;
}
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 {
return reduce!((a, b) => a + b.length)(size_t.init, slices);
}
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));
}
}
void main() {
auto range = Together(FibonacciSeries().take(10).array, [ 777, 888 ],
(new SquaresRange()).take(5).array);
writeln(range.save);
}Quando o código acima é compilado e executado, ele produz o seguinte resultado -
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 777, 888, 0, 1, 4, 9, 16]OutputRange
OutputRange representa a saída do elemento transmitido, semelhante ao envio de caracteres para o stdout. OutputRange requer suporte para a operação put (range, element). put () é uma função definida no módulo std.range. Ele determina as capacidades do intervalo e do elemento em tempo de compilação e usa o método mais apropriado para usar na saída dos elementos. Um exemplo simples é mostrado abaixo.
import std.algorithm;
import std.stdio;
struct MultiFile {
string delimiter;
File[] files;
this(string delimiter, string[] fileNames ...) {
this.delimiter = delimiter;
/* stdout is always included */
this.files ~= stdout;
/* A File object for each file name */
foreach (fileName; fileNames) {
this.files ~= File(fileName, "w");
}
}
void put(T)(T element) {
foreach (file; files) {
file.write(element, delimiter);
}
}
}
void main() {
auto output = MultiFile("\n", "output_0", "output_1");
copy([ 1, 2, 3], output);
copy([ "red", "blue", "green" ], output);
}Quando o código acima é compilado e executado, ele produz o seguinte resultado -
[1, 2, 3]
["red", "blue", "green"]