Fonctions PHP récursives anonymes

Est-il possible d'avoir une fonction PHP à la fois récursive et anonyme? C'est ma tentative pour le faire fonctionner, mais il ne transmet pas le nom de la fonction.

$factorial = function( $n ) use ( $factorial ) {
    if( $n <= 1 ) return 1;
    return $factorial( $n - 1 ) * $n;
};
print $factorial( 5 );

Je suis également conscient que c'est une mauvaise façon de mettre en œuvre factorielle, c'est juste un exemple.

Pour que cela fonctionne, vous devez passer $ factorial comme référence

$factorial = function( $n ) use ( &$factorial ) {
    if( $n == 1 ) return 1;
    return $factorial( $n - 1 ) * $n;
};
print $factorial( 5 );

Je sais que ce n'est peut-être pas une approche simple, mais j'ai appris une technique appelée «correction» à partir de langages fonctionnels. La fixfonction de Haskell est plus généralement connue sous le nom de combinateur Y , qui est l'un des combinateurs à point fixe les plus connus .

Un point fixe est une valeur inchangée par une fonction: un point fixe d'une fonction f est tout x tel que x = f (x). Un combinateur à point fixe y est une fonction qui renvoie un point fixe pour toute fonction f. Puisque y (f) est un point fixe de f, nous avons y (f) = f (y (f)).

Essentiellement, le combinateur Y crée une nouvelle fonction qui prend tous les arguments de l'original, plus un argument supplémentaire qui est la fonction récursive. Comment cela fonctionne est plus évident en utilisant la notation au curry. Au lieu d'écrire des arguments entre parenthèses ( f(x,y,...)), les écrire après la fonction: f x y .... Le combinateur Y est défini comme Y f = f (Y f); ou, avec un seul argument pour la fonction récursive,Y f x = f (Y f) x .

Depuis PHP ne curry pas automatiquement les fonctions, c'est un peu un hack pour faire fixfonctionner, mais je pense que c'est intéressant.

function fix( $func )
{
    return function() use ( $func )
    {
        $args = func_get_args();
        array_unshift( $args, fix($func) );
        return call_user_func_array( $func, $args );
    };
}

$factorial = function( $func, $n ) {
    if ( $n == 1 ) return 1;
    return $func( $n - 1 ) * $n;
};
$factorial = fix( $factorial );

print $factorial( 5 );

Notez que c'est presque la même chose que les solutions de fermeture simples que d'autres ont publiées, mais la fonction fixcrée la fermeture pour vous. Les combinateurs à virgule fixe sont légèrement plus complexes que l'utilisation d'une fermeture, mais sont plus généraux et ont d'autres utilisations. Alors que la méthode de fermeture convient mieux à PHP (qui n'est pas un langage terriblement fonctionnel), le problème d'origine est plus un exercice que pour la production, donc le combinateur Y est une approche viable.

Bien que ce ne soit pas pour une utilisation pratique, l'extension de niveau C mpyw-junks / phpext-callee fournit une récursivité anonyme sans affecter de variables .

<?php

var_dump((function ($n) {
    return $n < 2 ? 1 : $n * callee()($n - 1);
})(5));

// 5! = 5 * 4 * 3 * 2 * 1 = int(120)

Dans les versions plus récentes de PHP, vous pouvez le faire:

$x = function($depth = 0) {
    if($depth++)
        return;

    $this($depth);
    echo "hi\n";
};
$x = $x->bindTo($x);
$x();

Cela peut potentiellement conduire à un comportement étrange.

Vous pouvez utiliser Y Combinator en PHP 7.1+ comme ci-dessous:

function Y
($le)
{return
    (function ($f) 
     {return
        $f($f);
     })(function ($f) use ($le) 
        {return
            $le(function ($x) use ($f) 
                {return
                    $f($f)($x);
                });
        });
}

$le =
function ($factorial)
{return
    function
    ($n) use ($factorial)
    {return
        $n < 2 ? $n
        : $n * $factorial($n - 1);
    };
};

$factorial = Y($le);

echo $factorial(1) . PHP_EOL; // 1
echo $factorial(2) . PHP_EOL; // 2
echo $factorial(5) . PHP_EOL; // 120

Jouez avec: https://3v4l.org/7AUn2

Codes source de: https://github.com/whitephp/the-little-phper/blob/master/src/chapter_9.php

Avec une classe anonyme (PHP 7+), sans définir de variable:

echo (new class {
    function __invoke($n) {
        return $n < 2 ? 1 : $n * $this($n - 1);
    }
})(5);