[SUGGESTION] Requires clause for aliases

[JohelEGP]

A natural extension to 63efa6e.

Will your feature suggestion eliminate X% of security vulnerabilities of a given kind in current C++ code? No.

Will your feature suggestion automate or eliminate X% of current C++ guidance literature?

(Make it possible to) make the default:

• I.9: If an interface is a template, document its parameters using concepts
• T.10: Specify concepts for all template arguments

No longer teach:

• T.48: If your compiler does not support concepts, fake them with enable_if
• T.121: Use template metaprogramming primarily to emulate concepts

Describe alternatives you've considered.
https://cpp2.godbolt.org/z/Mr9TMo7xG:

i: <T> type
  // requires std::integral<T>
  == std::enable_if<
        std::integral<T>,
        std::make_signed<T>
      >::type::type;

[JohelEGP]

This is better dealt with after #486.

A test: https://cpp2.godbolt.org/z/bxsvexdxr.

integer_t: <T> type requires std::integral<T>           == T;
integer_v: <V: _> _ requires std::integral<decltype(V)> == V;
main: () = {
  std::ignore = integer_t<u32>(integer_v<:u32                        = 0>);
  static_assert(!std::invocable<decltype(:<T> (x: T) -> integer_t<T> = {}), std::nullptr_t>);
  static_assert(!std::invocable<decltype(:<T> (x: T) -> std::type_identity_t<decltype(integer_v<:T = nullptr>)> = {}),
                                         std::nullptr_t>);
}

[JohelEGP]

Now I want this to replace the variable

zero_v: <T> const T requires something = zero<T>::value;

with the alias

zero_v: <T> T requires something == zero<T>::value;

which currently errors with main.cpp2(1,1): error: a namespace-scope object must have an initializer: https://cpp2.godbolt.org/z/WP5434a86.

[JohelEGP]

Hmm...
For aliases, the requires's expression eats the == and the initializer.

[hsutter]

Thanks! I see that currently alias declarations don't support requires clauses at all, and then when I add them I'll require == in the constraint expression to be parenthesized.

Then this will work as you expected:

zero_v: <T> T requires something == zero<T>::value;

and this will require the parentheses:

zero_v: <T> T requires (something == something_else) == zero<T>::value;

and this will mean the second == is part of the initializer:

zero_v: <T> T requires something == something_else == zero<T>::value;
// same as:
zero_v: <T> T requires something == (something_else == zero<T>::value);

[JohelEGP]

That's what I did in #675.
Although now the grammar lies about what's part of the requires's expression.

[JohelEGP]

Resolved by commit b1c03f2.
Closing manually because a commit can't close discussions.