Donc, le problème que j'ai rencontré en essayant de créer une fonction de générateur récursif, c'est qu'une fois que vous dépassez votre premier niveau de profondeur, chaque rendement suivant cède à son appel parent plutôt qu'à l'implémentation d'itération (la boucle).

Depuis php 7, une nouvelle fonctionnalité a été ajoutée qui vous permet de générer à partir de une fonction de générateur ultérieure. C'est la nouvelle Générateur de Délégation fonction: https://wiki.php.net/rfc/generator-delegation

Ce nous permet de céder à partir d'appels récursifs ultérieurs, ce qui signifie que nous pouvons maintenant écrire efficacement des fonctions récursives avec l'utilisation de générateurs.

$items = ['what', 'this', 'is', ['is', 'a', ['nested', 'array', ['with', 'a', 'bunch',  ['of', ['values']]]]]];

function processItems($items)
{
    foreach ($items as $value)
    {
        if (is_array($value))
        {
            yield from processItems($value);
            continue;
        }
        yield $value;
    }
}

foreach (processItems($items) as $item)
{
    echo $item . "\n";
}

Cela donne la sortie suivante..

what
this
is
is
a
nested
array
with
a
bunch
of
values

function fibonacci($n)
{
    if($n < 2) {
        yield $n;
    }

    $x = fibonacci($n-1);
    $y = fibonacci($n-2);
    yield $x->current() + $y->current();
}


for($i = 0; $i <= 10; $i++) {
    $x = fibonacci($i);
    $value = $x->current();
    echo $i , ' -> ' , $value, PHP_EOL;
}

Merci à Mark Baker j'ai réalisé que le cas d'utilisation réel pour cela est difficile à trouver (sinon impossible).

Générateur n'est pas une fonction, oui (peut-être que la confusion moi) - si "appel" à l'intérieur avec "récursive" paramètre est près inutile. Nous pouvons agir comme Mark l'a suggéré, mais après avoir réfléchi un peu, j'ai fini avec ce code pour mon exemple de séquence Fibonacci:

function xfibonacci($n)
{
   $recursion = function($n) use (&$recursion)
   {
      return $n<2?$n:$recursion($n-1)+$recursion($n-2);
   };
   for($i=0; $i<$n; $i++)
   {
      yield $recursion($i);
   }  
}
//...
foreach(xfibonacci(6) as $i)
{
   echo('num is: '.$i.PHP_EOL);//0,1,1,2,3,5
}

- et, ce qui est plus important, qu'il peut être facilement converti en cas commun, lorsque nous vous voulez avoir un générateur, qui repose sur une fonction de génération de séquence récursive. Donc ce sera:

function xrecursive($n, callable $callback, $args=null)
{
   for($i=0; $i<$n; $i++)
   {
      yield is_array($args)?
         call_user_func_array($callback, array_merge([$i], $args)):
         call_user_func_array($callback, [$i]);
   }  
}

- avec échantillon d'utilisation:

//factorial:
foreach(xrecursive(6, $f=function($n) use (&$f){return $n?$n*$f($n-1):1;}) as $i)
{
   echo('num is: '.$i.PHP_EOL);//1,1,2,6,24,120
}

- ainsi, Tout générateur , qui repose sur une fonction de génération de séquence récursive, pourrait être séparé de son implémentation. Ce n'est pas une réponse complète à la question originale (car il existe peut-être des moyens d'implémenter le comportement souhaité ) - mais en même temps, je pense que c'est une façon plus correcte d'utiliser generator dans le contexte de récursif la génération de séquences.

Si vous voulez faire un générateur, vous pouvez aussi bien utiliser la version itérative de fibonacci:

function fibonacci ($from, $to)
{
  $a = 0;
  $b = 1;
  $tmp;
  while( $to > 0 ) {
    if( $from > 0 )
      $from--;
    else
      yield $a;

    $tmp = $a + $b;
    $a=$b;
    $b=$tmp;
    $to--;
  }
}

foreach( fibonacci(10,20) as $fib ) {  
    print "$fib "; // prints "55 89 144 233 377 610 987 1597 2584 4181 " 
}

Voici un générateur récursif pour les combinaisons (ordre sans importance, sans remplacement):

<?php

function comb($set = [], $size = 0) {
    if ($size == 0) {
        // end of recursion
        yield [];
    }
    // since nothing to yield for an empty set...
    elseif ($set) {
        $prefix = [array_shift($set)];

        foreach (comb($set, $size-1) as $suffix) {
            yield array_merge($prefix, $suffix);
        }

        // same as `yield from comb($set, $size);`
        foreach (comb($set, $size) as $next) {
            yield $next;
        }
    }
}

// let's verify correctness
assert(iterator_to_array(comb([0, 1, 2, 3, 4], 3)) == [
    [0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4],
    [0, 3, 4], [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]
]);

foreach (comb([0, 1, 2, 3], 3) as $combination) {
    echo implode(", ", $combination), "\n";
}

Sorties:

0, 1, 2
0, 1, 3
0, 2, 3
1, 2, 3

Même chose sans rendement.

A récemment rencontré un problème qui nécessitait des générateurs "récursifs" ou une délégation de générateurs. J'ai fini par écrire une petite fonction qui convertit les appels de générateurs délégués en un seul générateur.

Je l'ai transformé en un paquet afin que vous puissiez simplement l'exiger avec composer, ou commander la source ici: hedronium / generator-nest .

Code:

function nested(Iterator $generator)
{
    $cur = 0;
    $gens = [$generator];

    while ($cur > -1) {
        if ($gens[$cur]->valid()) {
            $key = $gens[$cur]->key();
            $val = $gens[$cur]->current();
            $gens[$cur]->next();
            if ($val instanceof Generator) {
                $gens[] = $val;
                $cur++;
            } else {
                yield $key => $val;
            }
        } else {
            array_pop($gens);
            $cur--;
        }
    }
}

Vous l'utilisez comme:

foreach (nested(recursive_generator()) as $combination) {
    // your code
}

Commander ce lien ci-dessus. Elle présente des exemples.

Réponse courte: les générateurs récursifs sont simples. Exemple de marche à travers l'arbre:

class Node {

    public function getChildren() {
        return [ /* array of children */ ];
    }

    public function walk() {
        yield $this;

        foreach ($this->getChildren() as $child) {
            foreach ($child->walk() as $return) {
                yield $return;
            };
        }
    }
}

C'est tout.

Réponse longue sur fibonacci:

Générateur est quelque chose qui est utilisé avec foreach (generator() as $item) { ... }. Mais OP veut que la fonction fib() retourne int, mais en même temps il veut qu'elle retourne generator pour être utilisée dans foreach. C'est très confus.

Il est possible d'implémenter une solution de générateur récursif pour fibonacci. Nous avons juste besoin de mettre somewere à l'intérieur fib() Fonction une boucle ce sera en effet yield chaque membre de la séquence. Comme generator est censé être utilisé avec foreach, il semble vraiment bizarre, et je ne pense pas que ce soit efficace, mais le voici:

function fibGenerator($n) {
    if ($n < 2) {
        yield $n;
        return;
    }

    // calculating current number
    $x1 = fibGenerator($n - 1);
    $x2 = fibGenerator($n - 2);
    $result = $x1->current() + $x2->current();

    // yielding the sequence
    yield $result;
    yield $x1->current();
    yield $x2->current();

    for ($n = $n - 3; $n >= 0; $n--) {
        $res = fibGenerator($n);
        yield $res->current();
    }
}

foreach (fibGenerator(15) as $x) {
    echo $x . " ";
}

Je propose deux solutions pour le nombre de Fibonacci, avec et sans récursivité:

function fib($n)
{
    return ($n < 3) ? ($n == 0) ? 0 : 1 : fib($n - 1) + fib($n - 2);
}
function fib2()
{
    $a = 0;
    $b = 1;
    for ($i = 1; $i <= 10; $i++)
    {
        echo $a  . "\n";
        $a = $a + $b;
        $b = $a - $b;
    }
}

for ($i = 0; $i <= 10; $i++)
{
    echo fib($i) . "\n";
}

echo fib2();