С++ 11 привязать и применить?

Функция без аргументов — это просто значение в Haskell. Вы не называете его, вы просто используете его. Поскольку нет побочных эффектов, нет и заметной разницы.

В OCaml просто нет функций без параметров, чтобы получить что-то подобное, нужно добавить фиктивный юнит-аргумент.

В С++ не так. C++, в отличие от Haskell и OCaml, поддерживает четкое различие между f и f(). bind дает вам первое, потому что вы всегда можете превратить его во второе, добавив (). Вы можете написать свою собственную оболочку для bind, которая делает это довольно легко. Идти в обратном направлении было бы немного сложнее.

Вот возможная реализация такой оболочки:

#include <functional>
#include <utility>
#include <iostream>

template <typename T>
struct is_noargs_callable {
  private:
    typedef char(&yes)[1];
    typedef char(&no)[2];

    template<typename U> 
      static yes test(decltype((std::declval<U>())())*);

    template<typename> 
      static no test(...);

  public:
    static const bool value = sizeof(test<T>(0)) == sizeof(yes);
};

template <typename T>
struct is_noargs_callable<T()> {
  static const bool value = true;
};

template <typename T>
struct is_noargs_callable<T(...)> {
  static const bool value = true;
};

template <typename T>
auto call_me_if_you_can(T t) -> typename std::enable_if<is_noargs_callable<T>::value, decltype(t())>::type
{
  return t();
}

template <typename T>
auto call_me_if_you_can(T t) -> typename std::enable_if<!is_noargs_callable<T>::value, T>::type
{
  return t; 
}

template <typename... Args>
auto apply(Args&&... args) -> decltype(call_me_if_you_can(std::bind(args...))) {
  return call_me_if_you_can(std::bind(args...));
}

// testing

void foo(int a, int b, int c) { std::cout << "foo(" << a << "," << b << "," << c << ")";  }

int main ()
{
  using namespace std::placeholders;
  std::cout << "zero : " ; apply(foo, _1, _2, _3); std::cout << " : " ; apply(foo, _1, _2, _3)(1,2,3); std::cout << std::endl;
  std::cout << "one  : " ; apply(foo, 1, _1, _2); std::cout << " : " ; apply(foo, 1, _1, _2)(2,3); std::cout << std::endl;
  std::cout << "two  : " ; apply(foo, 1, 2, _1); std::cout << " : " ; apply(foo, 1, 2, _1)(3); std::cout << std::endl;
  std::cout << "three: " ; apply(foo, 1, 2, 3);  std::cout << " : "; /* nothing to test here */ std::cout << std::endl;
}

Однако устранение разницы между f и f() только в этом месте, ИМХО, не способствует общей согласованности программирования на C++. Если вам не нравится это различие, уберите его везде (или просто используйте Haskell во благо).

Нет источников для этого, только мое мнение.

Причина, по которой это не было сделано, заключается в том, что для этого нет причин. Если вы знаете все входные данные для функции, просто вызовите ее.

И если бы вы делали что-то с шаблонами, которые привели к этому, вам все равно пришлось бы писать весь код последовательно. Особый случай здесь потребует только особого случая в другом месте.