template<class F, class G>
auto twice(F f) {return [](G x){return f(f(x));};}

Das lässt sich so natürlich nicht kompilieren, aber ich denke, die Idee ist klar: Ich möchte später sowas schreiben können wie

double t = twice(sqrt)(16);

Das Ergebnis wäre dann sqrt(sqrt(16)) = 2.

Wie könnte ich so eine Funktion twice schreiben (ob mit Lambdas oder nicht ist mir egal).

template <unsigned N>
struct apply
{
	template <typename T, typename F>
	auto operator () (T v, F f) const -> decltype(f(apply<N - 1>()(v, f)))
	{
		return f(apply<N - 1>()(v, f));
	}
};

template <>
struct apply<0>
{
	template <typename T, typename F>
	T operator () (T v, F) const
	{
		return v;
	}
};

int main()
{
	apply<5> ap;
	double t = ap(2.0, [] (double d) { return d * 2.0; });
	std::cout << t << '\n';
}

double t = twice(twice)(sqrt)(65536); // 4-facher sqrt-Aufruf

bzw. was Äquivalents schreiben kann. Oder auch sowas:

double t = twice(twice)(twice)(sqrt)(65536); // 16-facher sqrt-Aufruf

Möglicherweise müsste man noch mehr Klammern setzen, ka, ob C++ sowas zulässt, aber wenn man den Term von links nach recht auswertet, ist es eindeutig, was gemeint ist.

@cooky: ja, das ist auch ganz nice. Aber ich möchte ineinander schachteln können. Ich brauche also eine Funktion, die eine Funktion auf eine andere Funktion abbildet. Lesbarkeit ist nicht so wichtig, es geht hier nur ums Ausprobieren.

template<class G, class F>
auto twice(F f) -> std::function<typename std::result_of<F(G)>::type(G)> {return [=](G x){return f(f(x));};}

auto mysqrt=[](double v) {return std::sqrt(v);}; //std::sqrt ist mehrfach überladen
std::cout << twice<double>(mysqrt)(65536) << std::endl;

Die explizite Angabe des Parametertyps müsste sich auch noch wegzaubern lassen.

Was für einen Parametertyp müsste ich denn angeben, wenn ich "twice<...>(twice<double>)(mysqrt)(65536)" auswerten möchte?

Anzugeben ist jeweils der Parametertyp, den die erzeugte Funktion entgegennehmen soll, also idealerweise:

twice<double>(twice<double>(mysqrt))(65536)

Darf aber auch ein anderer Typ sein, der sich implizit nach double konvertieren lässt, z.B. int.

twice<double>(twice<double>(mysqrt))(65536)

sondern

(twice<double>(twice<double>))(mysqrt)(65536)

die erzeuge Funktion von (dem ersten) twice nimmt als Typ eine Funktion von double nach double entgegen. Wie gebe ich das nun als Parameter an?

(Bei diesem Beispiel sind beide Ausdrücke äquivalent, bei 3 twice ist das aber nicht mehr der Fall)

Abgesehen davon finde ich meine Variante von oben eh hübscher, und als Funktions-Objekt kann es auch herhalten.

Sehe ich nicht so, dein Ding ist absolut unhandlich. Hier ein besserer Ansatz:

template <typename F>
struct twice_ {
  twice_(F f) : f(std::move(f)) {}
  F f;
  template <typename T, typename R = decltype(f(f(std::declval<T>())))>
  R operator () (T x) { return f(f(x)); }
};
template <typename F> twice_<F> twice(F f) { return twice_<F>(std::move(f)); }

int main()
{
  auto square = [](double x){return x*x;};
  std::transform(std::istream_iterator<double>(std::cin),
                 std::istream_iterator<double>{},
                 std::ostream_iterator<double>(std::cout, "\n"),
                 twice(twice(square))); // 4-facher square-Aufruf, hoch 16               
}

Wie würde Zeile 16 mit deinem Ansatz lauten?

twice(twice)(square)(2)

nicht schreiben. Ich denke mal, dass man sowas auch nicht mit C++ machen kann. Man bedenke, dass das linke twice mathematisch gesehen vom Typ
((d -> d) -> (d -> d)) -> ((d -> d) -> (d -> d))
ist, wobei d für double steht. Bei 3 twice verdoppelt sich nochmal die Länge des Typs.

Es ging hier übrigens nicht um eine hübsche Lösung, sondern um die Machbarkeit allgemein.

Ich stelle mir das grundsätzlich etwa so vor:

#include <cmath>
#include <iostream>

template<typename F>
struct apply_twice_type {
  F func_;

  apply_twice_type(F f) : func_(f) { }

  template<typename P>
  auto operator()(P p) const -> decltype(func_(func_(p))) { return func_(func_(p)); }
};

struct twice_type {
  template<typename F>
  apply_twice_type<F> operator()(F f) const { return apply_twice_type<F>(f); }
} const twice; // <-- twice jetzt ein Objekt

int main() {
  double (*sq)(double) = std::sqrt; // Überladene Funktion, Auflösung notwendig.
  std::cout << twice(twice)(sq)(16.0) << '\n';
}

Es gibt Vorschläge für den nächsten Standard, die Lambdas mit generischem operator() vorsehen, aber das ist wohl noch eine Weile hin. Wenn das kommt, dann könnte man diesen Mechanismus mit Lambdas auch nachbauen.

Traumhaft, wie lange es dauert, das hier zu kompilieren:

int main() { 
   auto succ = [](int x){return x+1;};
   std::cout << twice(twice)(twice)(twice)(succ)(0) << '\n'; 
}