On Sun, May 2, 2021 at 12:36 PM Bjorn Reese via Std-Proposals <std-proposals@lists.isocpp.org> wrote:
I am considering proposing the addition of type traits to check if a
type is constructible from arguments except if the argument are the
copy/move constructors of the type.

The purpose is to have a common way of writing a condition for
templated constructors:

   struct alpha {
     alpha(const alpha&);
     template <typename T>
       requires(condition-that-excludes-copy-constructor)
     alpha(T&&);
   };

Your proposal is very confused at the moment.  I recommend showing a Tony Table: what does the code for a real problem look like before your proposal, and after it?

I emphasize "for a real problem" because the code you've showed above is not real: `alpha` is an empty struct, and you didn't provide the body of the "value constructor," so it's not clear to the reader what it's planning to do with the T&& it receives.

Your code snippets in the paper are also clearly wrong; e.g.

struct alpha {
    alpha(const alpha&);
    template <typename T,
        typename = std::enable_if_t<is_value_constructible_v<T>>>
    alpha(T&&);
};

implies that "is_value_constructible_v" is a property of `T` alone, whereas I assume you meant it to depend on `alpha` as well.

In fact, from your examples, I think all you're looking for is what libc++ calls `__is_same_uncvref<T, U>` — i.e.,

template<class T, class U>
struct is_same_uncvref : is_same<remove_cvref_t<T>, remove_cvref_t<U>> {};

struct AlphableRef {
    template<class T>
        // "value-construct" from anything that's not cvref-qualified `AlphableRef`
        requires (not is_same_uncvref<T, AlphableRef>::value)
    AlphableRef(T&& t) {

Full example (which would have to go in the paper): https://godbolt.org/z/drhEadKT7

However, I don't see any need to standardize is_same_uncvref; it seems trivial to write by hand.
Notice I could also have done
    requires (not same_as<remove_cvref_t<T>, AlphableRef>)
which is almost as short.

–Arthur