msd - ¿Qué es un "rendimiento de rendimiento" equivalente en el lenguaje de programación D?

dds msd

Question

Aquí hay un generador simple en C #.

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

¿Cómo escribo un generador similar en Digital Mars D?

(La pregunta es sobre la declaración de rendimiento )

¡Gracias!

Actualizar. Eso es interesante. Como solo estoy generando una secuencia matemática, usar la recurrence puede ser una buena opción.

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

El módulo std.concurrency ahora tiene una clase de Generator que lo hace aún más fácil (y no necesita una biblioteca de terceros).

La clase es un rango de entrada, por lo que se puede usar con bucles y todas las std.range estándar 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
    ;
}

Answer 2

No hay un equivalente exacto en D. Aquí hay algunos equivalentes aproximados:

Usando la iteración interna de opApply-style. Sin embargo, esto no permite iterar más de dos iteradores en bloqueo.

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.
    }
}

Utilizar rangos. Estos son un poco más difíciles de escribir en algunos casos, pero son muy eficientes y permiten la iteración de pasos de bloqueo. Esto también puede repetirse con un bucle foreach , exactamente como la versió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; }
}

Si realmente necesita cosas de estilo coroutine, puede combinar rangos y opApply juntos usando core.thread.Fiber , pero probablemente encontrará que o rangos u opApply hacen lo que necesita casi todo el tiempo.

Answer 3

Ver here extracto de ejemplo a continuación:

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);
}