Whole problem here is that `static_assert` has a design goal to be
> eager in evaluation of its condition. And changing this will reduce
> its usefulness in that case.

Out of curiousty, in what situation, changing this would reduce its usefulness?

> Here are some data to consider:
>
>     template<bool B>
>     void func() {
>       if constexpr (B) {
>         static_assert(false, "message");
>       }
>     }
>
> and
>
>     template<bool B>
>     void func;
>
>     template<>
>     void func<true>() {
>       static_assert(false, "message");
>     }
>
>     template<>
>     void func<false>() {}

Yeah, this is an example. And from my point of view, changing this would make 
the power of static_assert get weaker in `if constexpr`. But it is OK for me,
from my experience for using static_assert, it seems OK to assert evaluate lazily (after instantiation).
I am curious about if there is any realistic example tell the down side for lazily evaluate assert.

Thanks,
Chuanqi

------------------------------------------------------------------
From:Jefferson Carpenter via Std-Proposals <std-proposals@lists.isocpp.org>
Send Time:2021年6月18日(星期五) 16:09
To:std-proposals <std-proposals@lists.isocpp.org>
Cc:Jefferson Carpenter <jeffersoncarpenter2@gmail.com>
Subject:Re: [std-proposals] Static Failure - Custom Compile-Time Errors

On 6/18/2021 7:49 AM, chuanqi.xcq via Std-Proposals wrote:
> Yeah, another question is that can we use  'static_assert(false, "string");' to replace the use case? I understand the current document and implementation wouldn't work.
> But I mean, what if to change the semantics for static_assert to make `static_assert(false, "")` work for the use case you mentioned? It looks not bad to me, too.

Here are some data to consider:

     template<bool B>
     void func() {
       if constexpr (B) {
         static_assert(false, "message");
       }
     }

and

     template<bool B>
     void func;

     template<>
     void func<true>() {
       static_assert(false, "message");
     }

     template<>
     void func<false>() {}

both fail to compile.  So currently static_assert behaves similarly 
whether it is used with template specializations, or with `if constexpr` 
statements.  (Even if the code in question is never instantiated)
-- 
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals