Re: attribute. Ok, other than potentially making the definition of
the function an error (though as an attribute, it's optional anyway),
how is this distinct from the deprecation attribute?

And as other people have asked: what's the motivation for this? What
non-contrived use-case is there for this attribute?

On Tue, Mar 18, 2025 at 4:42 AM Tiago Freire via Std-Proposals
<std-proposals_at_[hidden]> wrote:
>
> I think you are operating under the assumption that "unimplemented" and "delete" are the same, when in fact it is impossible that they could be.
>
> Here's the reason:
> Attributes can be ignored, regardless of implementation it should be interpreted the same although it may not necessarily compile by means of diagnostic errors.
>
> Now think of something like a requires clause, you can generate different code depending on the validity of a requires clause, and one of those tests could be trying to call such function.
> A deleted function would cause it to fail, because it is deleted, but an unimplemented would not (remember the attribute is optional), and this is fine because we are evaluating if it there's a call interface not actually calling it, so the fact that it is unimplemented is irrelevant.
> Think of declval.
>
> Now why you would want this is a mystery, there already a lot that you can do in unvalued contexts that doesn't require this. And I don't see the value of adding a feature that intentionally makes code... well not actually valid code.
>
> ________________________________
> From: Std-Proposals <std-proposals-bounces_at_[hidden]> on behalf of Sebastian Wittmeier via Std-Proposals <std-proposals_at_[hidden]>
> Sent: Tuesday, March 18, 2025 12:13:33 PM
> To: std-proposals_at_[hidden] <std-proposals_at_[hidden]>
> Cc: Sebastian Wittmeier <wittmeier_at_[hidden]>
> Subject: Re: [std-proposals] unimplemented attribute
>
> As I understand compared to `= delete` you want to make the reason the function is not there machine-readable and distinguish from an unrelated deleted function.
>
> But all =deleted functions are unimplemented, and all [unimplemented] function would - according to your description - compile as if they were deleted.
>
> What is the difference in meaning?
>
>
>
> E.g. if one had
>
> = deleted("message")
>
> = unimplemented("message")
>
>
>
> when would one choose one or the other? Aren't they synonymous?
>
> = deleted could mean, it was there before (e.g. in an earlier version). But that is not how it is meant and used in practice.
>
> = unimplemented could mean, it is planned to be implemented in the future?
>
>
>
> -----Ursprüngliche Nachricht-----
> Von: Samuel Alonso Rodríguez via Std-Proposals <std-proposals_at_[hidden]>
> Gesendet: Di 18.03.2025 11:14
> Betreff: Re: [std-proposals] unimplemented attribute
> An: std-proposals_at_[hidden];
> CC: Samuel Alonso Rodríguez <samuelalonso26_at_[hidden]>;
> The fixed message stating that the function is unimplemented is the divergence from raw = delete, and sure, since C++26, users could simply do something like = delete(“unimplemented function!”), but the compiler outcome could differ and tools inspecting the compiler output may not be able to easily detect that
>
>
> --
> Std-Proposals mailing list
> Std-Proposals_at_[hidden]
> https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals