Combinateurs à points fixes en C ++

Je suis intéressé par des exemples concrets d’utilisation de combinateurs à point fixe (tels que le combinateur y en C ++. Avez-vous déjà utilisé un combinateur à point fixe avec egg ou une liaison dans un code réel?

J’ai trouvé cet exemple dans l’oeuf un peu dense:

void egg_example() { using bll::_1; using bll::_2; int r = fix2( bll::ret( // \(f,a) -> a == 0 ? 1 : a * f(a-1) bll::if_then_else_return( _2 == 0, 1, _2 * lazy(_1)(_2 - 1) ) ) ) (5); BOOST_CHECK(r == 5*4*3*2*1); } 

Pouvez-vous expliquer comment tout cela fonctionne?

Existe-t-il un bel exemple simple d’utilisation de bind avec peut-être moins de dépendances que celle-ci?

Voici le même code converti en boost::bind notez le combinateur y et son site d’application dans la fonction principale. J’espère que ça aide.

 #include  #include  #include  // Y-combinator compatible factorial int fact(boost::function f,int v) { if(v == 0) return 1; else return v * f(v -1); } // Y-combinator for the int type boost::function y(boost::function,int)> f) { return boost::bind(f,boost::bind(&y,f),_1); } int main(int argc,char** argv) { boost::function factorial = y(fact); std::cout << factorial(5) << std::endl; return 0; } 
 #include  #include  template  auto y (std::function f) -> std::function { return std::bind(f, std::bind(&y, f), std::placeholders::_1); } int main(int argc,char** argv) { std::cout << y < std::function, int> ([](std::function f, int x) { return x == 0 ? 1 : x * f(x - 1); }) (5) << std::endl; return 0; } 

Pouvez-vous expliquer comment tout cela fonctionne?

fix2 est un y-combinateur (en fait, c’est un combinateur pour des fonctions à deux arguments; le premier argument est la fonction (aux fins de la récursion), le second argument est un argument de fonction “correct”). Il crée des fonctions récursives.

bll :: ret (…) semble créer une forme d’object fonction dont le corps est

 if(second arg == 0) { return 1; } else { return second arg * first arg(second arg - 1); } 

Le “paresseux” est probablement là pour arrêter un développement infini du premier argument (fonction) (lisez la différence entre les combinateurs paresseux et ssortingct y pour voir pourquoi).

Le code est assez horrible. Les fonctions anonymes sont agréables à utiliser, mais le piratage permettant de contourner le manque de support syntaxique de C ++ ne les rend pas rentables.