Funções PHP recursivas anônimas

É possível ter uma função PHP recursiva e anônima? Esta é minha tentativa de fazê-lo funcionar, mas não passa o nome da função.

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

Também sei que essa é uma maneira ruim de implementar fatorial, é apenas um exemplo.

Para que funcione, você precisa passar $ fatorial como referência

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

Sei que essa pode não ser uma abordagem simples, mas aprendi sobre uma técnica chamada "correção" em linguagens funcionais. A fixfunção de Haskell é conhecida mais geralmente como o combinador Y , que é um dos combinadores de ponto fixo mais conhecidos .

Um ponto fixo é um valor inalterado por uma função: um ponto fixo de uma função f é qualquer x tal que x = f (x). Um combinador de ponto fixo y é uma função que retorna um ponto fixo para qualquer função f. Como y (f) é um ponto fixo de f, temos y (f) = f (y (f)).

Essencialmente, o combinador Y cria uma nova função que aceita todos os argumentos do original, além de um argumento adicional que é a função recursiva. Como isso funciona é mais óbvio usando a notação ao curry. Em vez de escrever argumentos entre parênteses ( f(x,y,...)), escreva-os após a função: f x y .... O combinador Y é definido como Y f = f (Y f); ou, com um único argumento para a função recorrente Y f x = f (Y f) x,.

Desde o PHP não automaticamente caril funções, é um bocado de um hack para fazer fixo trabalho, mas eu acho que é interessante.

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

Observe que isso é quase o mesmo que as soluções simples de fechamento postadas por outras pessoas, mas a função fixcria o fechamento para você. Os combinadores de ponto fixo são um pouco mais complexos do que usar um fechamento, mas são mais gerais e têm outros usos. Embora o método de fechamento seja mais adequado para PHP (que não é uma linguagem extremamente funcional), o problema original é mais um exercício do que para produção, portanto o combinador Y é uma abordagem viável.

Embora não seja para uso prático, a extensão no nível C mpyw-junks / phpext-callee fornece recursão anônima sem atribuir variáveis .

<?php

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

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

Nas versões mais recentes do PHP, você pode fazer isso:

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

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

Isso pode levar a um comportamento estranho.

Você pode usar o Y Combinator no PHP 7.1+ como abaixo:

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

Brinque com ele: https://3v4l.org/7AUn2

Códigos-fonte de: https://github.com/whitephp/the-little-phper/blob/master/src/chapter_9.php

Com uma classe anônima (PHP 7+), sem definir uma variável:

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