Thanks for the feedback, Arthur. 

> but it does suggest that maybe you've got an XY problem here.
This is not an XY problem. I came up with this trait because I had to implement something similar in libc++ to fix an issue with overload resolution. Your point about other unary operators in the standard library is a good one. Maybe they too should be added. 

> I would also caution that your proposal would make `is_deletable_v<int*>` invariably true, even though not all `int*` values are in fact deletable. 
I agree that this may be confusing to people. 

> Do you have examples of
There is at least one (but probably several) place(s) in the standard library where implementations must implement a trait like this. Here is an example struct where "is_array_deletable" is true and the other false:

struct Foo
{
    void operator delete[] (void* ptr) { free(ptr); }
    void operator delete   (void* ptr) = delete;
};

It should not be hard to imagine the opposite. 

On Sun, Jun 2, 2019 at 11:08 AM Arthur O'Dwyer <arthur.j.odwyer@gmail.com> wrote:
On Sun, Jun 2, 2019 at 1:00 PM Zoe Carver via Std-Proposals <std-proposals@lists.isocpp.org> wrote:

Before submitting a proposal for the following type traits, I wanted to get the communities opinion. What are your thoughts on adding the following to the standard library? 


1. is_deletable: if the expression "delete decltype<T>()" is well-formed, provides the member constant value equal to true. Otherwise, value is false.


2. is_array_deletable: if the expression "delete[] decltype<T>()" is well-formed, provides the member constant value equal to true. Otherwise, value is false.


This should be a small feature with little-no impact. I have a sample implementation if that would be helpful. 


Those names do look like the right names for that particular facility. But why do you want to add them to the standard library?
I mean, the standard library doesn't have is_negatable<T>, or is_bitwise_negatable<T>, or has_sizeof<T>, or any of the other unary operators that I can think of. So why should `delete` be special-cased?

I would also caution that your proposal would make `is_deletable_v<int*>` invariably true, even though not all `int*` values are in fact deletable. Deletability is a dynamic, runtime, property of a pointer value. This isn't a killer, but it does suggest that maybe you've got an XY problem here. A new type-trait may not be the right tool for whatever underlying job you've actually got.

Do you have examples of
(A) generic-programming contexts where an `is_deletable` facility would have a beneficial effect?
(B) examples of real-world code where `is_deletable_v<T> && not is_array_deletable_v<T>`, or vice versa?
(C) examples of real-world code where `is_deletable_v<T> && not is_object_pointer_v<T>`, or vice versa?

–Arthur