Fixed-point-combinators in C++

Ich bin daran interessiert, die tatsächliche Beispiele für die Verwendung von fixed-point-combinators (wie die y-combinator in C++. Haben Sie jemals einen festen Punkt combinator mit ei oder binden in real live code?

Ich fand dieses Beispiel im ei ein wenig dichten:

void egg_example()
{
    using bll::_1;
    using bll::_2;

    int r =
        fix2(
            bll::ret<int>(
                //\(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);
}

Können Sie erklären, wie das alles funktioniert?

Ist es ein schönes, einfaches Beispiel, das vielleicht mit binden, mit vielleicht weniger Abhängigkeiten als diese?

  • Wenn Sie code schreiben, der sieht, dass niemand wird jemals in der Lage sein, es zu halten, einschließlich sich selbst.
  • Mein Punkt ist nicht, dass ich wirklich schreiben wollen, fixed-point-combinators oder Lambda-Ausdrücke in C++, sondern dass vielmehr ein Beispiel jener in C++ wäre erbaulich für jemanden wie mich, der nicht allzu vertraut mit den Sprachen, in denen Sie möglicherweise mehr nützlich.
InformationsquelleAutor 1800 INFORMATION | 2008-09-30
  1. 32

    Hier ist der gleiche code umgewandelt boost::bind beachten Sie die y-combinator und seine Anwendung in der main-Funktion. Ich hoffe, das hilft.

    #include <boost/function.hpp>
#include <boost/bind.hpp>
#include <iostream>

//Y-combinator compatible factorial
int fact(boost::function<int(int)> f,int v)
{
  if(v == 0)
    return 1;
  else
    return v * f(v -1);
}

//Y-combinator for the int type
boost::function<int(int)>
    y(boost::function<int(boost::function<int(int)>,int)> f)
{
  return boost::bind(f,boost::bind(&y,f),_1);
}


int main(int argc,char** argv)
{
  boost::function<int(int)> factorial = y(fact);
  std::cout << factorial(5) << std::endl;
  return 0;
}
    • Das ist genau das, was ich suchte. Wünschte, ich könnte Stimmen, die Sie bis zweimal
    InformationsquelleAutor Ted
  2. 8
    #include <functional>
#include <iostream>

template <typename Lamba, typename Type>
auto y (std::function<Type(Lamba, Type)> f) -> std::function<Type(Type)>
{
    return std::bind(f, std::bind(&y<Lamba, Type>, f), std::placeholders::_1);
}

int main(int argc,char** argv)
{
    std::cout << y < std::function<int(int)>, int> ([](std::function<int(int)> f, int x) {
        return x == 0 ? 1 : x * f(x - 1);
    }) (5) << std::endl;
    return 0;
}
    • Funktioniert Super und ist auch reines C++ 11
    • Das einzige Problem mit dieser und mit dem boost-basierte akzeptierte Antwort ist, dass, nach meinen Lesungen über Y combinator, es ist, streng genommen, nicht erlaubt, um die Namen selbst, die in Ihrer definition.
    InformationsquelleAutor matthewtff
  3. 3

    Können Sie erklären, wie das alles funktioniert?

    fix2 ist ein y-combinator (speziell, es ist ein combinator für Funktionen mit zwei Argumente; das erste argument ist die Funktion (für den Zweck der Rekursion), das zweite argument ist eine "richtige" Funktion-argument). Es schafft rekursive Funktionen.

    bll::ret(...) erscheint zu erstellen, die in irgendeiner form ein function-Objekt, der Körper, die

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

    Dem "faul" ist vermutlich davon abhalten, sich eine unendliche Erweiterung des ersten (Funktion) argument (Lesen, auf den Unterschied zwischen faul und strengen y combinators, um zu sehen, warum).

    Der code ist ziemlich schrecklich. Anonyme Funktionen sind nice to have, aber den Hack zu arbeiten, etwa C++'s fehlende syntaktische Unterstützung, machen Sie nicht die Mühe Wert.

    InformationsquelleAutor DrPizza
Schreibe einen Kommentar