We all know the fearsome syntax for defining function pointers and function types, the one with the confusing parenthesis. You can find lot's of examples on the net. But here's a refresher.

typedef int (foo_type)(int);

typedef int (*foo_ptr_type)(int);

typedef foo_ptr_type (foo_getter_type)(char*);

typedef foo_type* (foo_getter_type)(char*);

typedef int (*(foo_getter_type)(char*))(int);

int (*(foo_getter)(char* name))(int)
{
  // I can't believe this thing compiled...
}

That's right, declarations I knew about as well, but this is definition. Anyway certainly not something I'd like to find in my code base, but that goes to my personal zoo of craziest C gibberish.

I've typedefed function pointers before, but never a function type. What can one do with the type of a function?

I've typedefed function pointers before, but never a function type. What can one do with the type of a function?

The are used all the time in C++. Many of the algorithmic functions take such a function. Functions that sort or search or generate or do something 'if' will all use them.

If you search through the C++ standard libraries you will find several hundred functions that take a predicate, binary predicate, unary function, binary function, or similar.

These are just the same as the prototypes above, typedefs for functions of the form bool(*UnaryPredicate)(T), bool(*BinaryPredicate)(T,T), void(*UnaryFunction)(T), void(*BinaryFunction)(T,T) or similar. The typedef looks very similar to the ones in the original post, except they are templates.

The benefit is that you can say: if(function(a,b)) and it just works. An example is the std::for_each implementation:

template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, UnaryFunction function)
{
   while (first!=last) {
      function (*first);
      ++first;
   }
   return fn; // or, since C++11: return move(fn);
}

In C++ just go through the <algorithm> header, you will find a large number of function overloads taking "Predicate" or "Function" signatures. You will find similar overloads in most of the container classes, and in many other locations through the libraries.

When people talk about using Lambda functions, this is precisely where a Lambda function is used.

These are just the same as the prototypes above, typedefs for functions of the form bool(*UnaryPredicate)(T), bool(*BinaryPredicate)(T,T), void(*UnaryFunction)(T), void(*BinaryFunction)(T,T) or similar. The typedef looks very similar to the ones in the original post, except they are templates.

Those are function pointer typedefs, not function typedefs.

would be cool if you could be like (in C):
SomeFunctionType Foo { ... }

I think the reason why function types can't be used to define functions is because there would be no way to assign argument names, so they are pretty useless by themselves, you can't return them, you can't assign them, but you can construct other types with it.