Tương đương "lợi nhuận" tương đương với ngôn ngữ lập trình D là gì?

Question

Đây là một trình tạo đơn giản trong C#.

IEnumerable<int> Foo() 
    { 
     int a = 1, b = 1; 
     while(true) 
     { 
      yield return b; 
      int temp = a + b; 
      a = b; 
      b = temp; 
     } 
    } 

Làm cách nào để viết trình tạo tương tự trong Kỹ thuật số Mars D?

(Câu hỏi đặt ra là về sự trở lại tuyên bố năng suất)

Cảm ơn!

---

Cập nhật. Điều đó thật thú vị. Vì tôi chỉ tạo một chuỗi toán học, sử dụng recurrence có thể là một lựa chọn tốt.

auto fib = recurrence!("a[n-1] + a[n-2]")(1, 1); 

foreach (e; take(fib, 10)) // <- prints first ten numbers from the sequence 
{ 
    writeln(e); 
} 

Answer 1

Không có chính xác tương đương trong D. Dưới đây là một số tương đương thô:

Sử dụng opApply kiểu lặp nội bộ. Tuy nhiên, điều này không cho phép lặp qua hai trình lặp trong ngưỡng khóa:

struct Foo { 
    int opApply(int delegate(ref int) dg) { 
     int a = 1, b = 1; 
     int result; 
     while(true) { 
      result = dg(b); 
      if(result) break; 
      int temp = a + b; 
      a = b; 
      b = temp; 
     } 

     return result; 
    } 
} 

void main() { 
    // Show usage: 
    Foo foo; 
    foreach(elem; foo) { 
     // Do stuff. 
    } 
} 

Phạm vi sử dụng. Đây là một chút khó khăn hơn để viết trong một số trường hợp, nhưng rất hiệu quả và cho phép lặp lại khóa. Đây cũng có thể được lặp lại với một vòng lặp foreach, giống hệt như phiên bản opApply:

struct Foo { 
    int a = 1, b = 1; 

    int front() @property { 
     return b; 
    } 

    void popFront() { 
     int temp = a + b; 
     a = b; 
     b = temp; 
    } 

    // This range is infinite, i.e. never empty. 
    enum bool empty = false; 

    typeof(this) save() @property { return this; } 
} 

Nếu bạn thực sự cần coroutine kiểu thứ bạn có thể kết hợp các dãy và opApply cùng sử dụng core.thread.Fiber, nhưng có thể bạn sẽ tìm thấy hoặc là phạm vi hoặc opApply thực hiện những gì bạn cần gần như mọi lúc.

Answer 2

Xem here; ví dụ trích dẫn dưới đây:

module main; 

import std.stdio; 
import generators; 

void genSquares(out int result, int from, int to) 
{ 
    foreach (x; from .. to + 1) 
     yield!result(x * x); 
} 

void main(string[] argv) 
{ 
    foreach (sqr; generator(&genSquares, 10, 20)) 
     writeln(sqr); 
} 

Answer 3

Module std.concurrency bây giờ có một lớp Generator mà làm cho điều này dễ dàng hơn (và bạn không cần một thư viện của bên thứ ba).

Lớp này là phạm vi đầu vào, vì vậy lớp này có thể được sử dụng cho các vòng lặp và tất cả các chức năng chuẩn std.range/std.algorithm.

import std.stdio; 
import std.range; 
import std.algorithm; 
import std.concurrency : Generator, yield; 

void main(string[] args) { 
    auto gen = new Generator!int({ 
     foreach(i; 1..10) 
      yield(i); 
    }); 

    gen 
     .map!(x => x*2) 
     .each!writeln 
    ; 
}