É interessante queusar o nome da função como um ponteiro de função é equivalente a aplicar o endereço de operador ao nome da função!

Aqui está o exemplo.

typedef bool (*FunType)(int);
bool f(int);
int main() {
  FunType a = f;
  FunType b = &a; // Sure, here's an error.
  FunType c = &f; // This is not an error, though. 
                  // It's equivalent to the statement without "&".
                  // So we have c equals a.
  return 0;
}

Usar o nome é algo que já sabemos em array. Mas você não pode escrever algo como

int a[2];
int * b = &a; // Error!

Não parece consistente com outras partes da linguagem. Qual é a razão deste design?

Esta questão explica a semântica desse comportamento e por que ele funciona. Mas estou interessado em saber porque a linguagem foi projetada dessa maneira.

O que é mais interessante é que o tipo de função pode ser implicitamente convertido em ponteiro para si mesmo quando usado como um parâmetro, mas não será convertido em um ponteiro para si mesmo ao usar como um tipo de retorno!

Exemplo:

typedef bool FunctionType(int);
void g(FunctionType); // Implicitly converted to void g(FunctionType *).
FunctionType h(); // Error!
FunctionType * j(); // Return a function pointer to a function 
                    // that has the type of bool(int).