Impact on the Standard

The proposal is a pure library extension.
It does not require changes to the standard components.
The extension can be implemented in C++11 and C++14.

Design Decisions

The std::y_combinator function is a helper function accepting the input callable object of type Fun and returning a callable object of type std::y_combinator_result<Fun> containing a copy of the input callable.
When called, the std::y_combinator_result<Fun> object forwards all the arguments to the copy of the input callable, prepending them by a single argument — a wrapped reference to itself.

To construct a std::y_combinator_result instance storing a reference to the input callable object, one can combine std::y_combinator with std::ref:

20.9.X.3 y_combinator_result helper function [yc.helper]

Discussion

Unlike reference_wrapper and function, y_combinator_result deliberately does not define result_type, argument_type, first_argument_type, second_argument_type typedefs.
It is generally impossible to infer the corresponding types for an arbitrary target function object type.
One can do this reliably only for function types and function pointer types.
However, functions already have a name that they can use to call themselves.
So, it is unclear why one would like to use Y combinator with them.

y_combinator_result deliberately does not support member function pointers.
The reason, as in the previous item, is the lack of sensible use cases: member functions have a name and can call themselves.

As noted by Richard Smith, an alternative way to support recursive lambdas is to extend the core language, e.g.: