贬低一个概念是一种改进还是一种糟糕的做法？

看起来您可以将lambda放入概念中，然后在其中编写代码。让我们以此为例。我更倾向于这些概念的标准概念，并记住这只是本例的目的-godbolt

template<class T>
concept labdified_concept =
    requires {
            [](){                 
                T t, tt; // default constructible
                T ttt{t}; // copy constructible
                tt = t; //copy assignable
                tt = std::move(t); // move assignable
            };
        };

而不是：

template<class T>
concept normal_concept = 
    std::default_initializable<T> && std::movable<T> && std::copy_constructible<T>;

模式化是一种改进还是糟糕的做法？从可读性的角度也是如此。

---

解决方案

这应该无效。允许lambdas进入未计算上下文的目的不是突然在语句上允许SFINAE。

我们在[temp.deduct]/9中确实有一些措辞清楚地说明了这一点：

出现在函数类型或模板参数中的lambda-表达式不被视为模板参数演绎的直接上下文的一部分。[注意：这样做的目的是避免要求实现处理涉及任意语句的替换失败。[示例：

template <class T>
  auto f(T) -> decltype([]() { T::invalid; } ());
void f(...);
f(0);               // error: invalid expression not part of the immediate context

template <class T, std::size_t = sizeof([]() { T::invalid; })>
  void g(T);
void g(...);
g(0);               // error: invalid expression not part of the immediate context

template <class T>
  auto h(T) -> decltype([x = T::invalid]() { });
void h(...);
h(0);               // error: invalid expression not part of the immediate context

template <class T>
  auto i(T) -> decltype([]() -> typename T::invalid { });
void i(...);
i(0);               // error: invalid expression not part of the immediate context

template <class T>
  auto j(T t) -> decltype([](auto x) -> decltype(x.invalid) { } (t));   // #1
void j(...);                                                            // #2
j(0);               // deduction fails on #1, calls #2

-结束示例]-结束备注]

我们只是没有与需求相对应的东西。GCC的行为果然出乎你的意料：

template <typename T> concept C = requires { []{ T t; }; };
struct X { X(int); };
static_assert(!C<X>); // ill-formed

因为lambda的正文在直接上下文之外，所以它不是替换失败，而是一个硬错误。