Eu tenho usado o yield em muitos dos meus programas em Python, erealmente limpa o código em muitos casos. Eublogou sobre isso e é uma das páginas populares do meu site.

O C # também oferece rendimento - é implementado através da manutenção de estado no lado do chamador, feito através de uma classe gerada automaticamente que mantém o estado, as variáveis locais da função, etc.

Atualmente, estou lendo sobre C ++ 0x e suas adições; e ao ler sobre a implementação de lambdas no C ++ 0x, descobri que isso também foi feito por meio de classes geradas automaticamente, equipadas com o operador () que armazena o código lambda. A questão natural se formou em minha mente: eles fizeram isso por lambdas, por que não consideraram isso também como apoio ao "rendimento"?

Certamente eles podem ver o valor das co-rotinas ... então, posso apenas supor que eles pensam em implementações baseadas em macro (comoSimon Tatham's) como um substituto adequado. Eles não são, no entanto, por muitas razões: estado mantido por chamada, não reentrante, baseado em macro (apenas isso é motivo suficiente), etc.

Editar: yield não depende da coleta de lixo, threads ou fibras. Você pode ler o artigo de Simon para ver que estou falando sobre o compilador fazer uma transformação simples, como:

int fibonacci() {
    int a = 0, b = 1;
    while (true) {
        yield a;
        int c = a + b;
        a = b;
        b = c;
    }
}

Para dentro:

struct GeneratedFibonacci {
    int state;
    int a, b;

    GeneratedFibonacci() : state (0), a (0), b (1) {}

    int operator()() {
        switch (state) {
        case 0:
            state = 1;
            while (true) {
                return a;

        case 1:
                int c = a + b;
                a = b;
                b = c;
            }
        }
    }
}

Coleta de lixo? Não. Tópicos? Não. Fibras? Não. Transformação simples? Indiscutivelmente, sim.