Please, tell me if it´s a non-starter or if it may be something interesting.
2 - Also, all constant captures should be initialized thru initializers, in the lambda_xx internal class, allowing default construction if all captures are constants.
TLDR Sample:
x = 10;
auto a = [x,y=20];
std::cout << '(' << a.x << ',' << a.y << ')';
Longer version :
1 "Sort of" named parameters:
Sample:
given:
void rect(int x1, int y1, int x2, int y2) {...}
one can make a wrapper:
void rect( auto r ) { rect(r.x1, r.y1, r.x2, r.y2); }
and call like this :
rect( [x2=30,y1=10,x1=10,y2=30] ); // unordered members passed as a lambda
or even using concepts
template <class T>
concept rect_top_width = requires(T t) {
{ t.top } -> std::same_as<int>; { t.left } -> std::same_as<int>;
{ t.height } -> std::same_as<int>; { t.width } -> std::same_as<int>;
};
template <class T>
concept rect_4ints = requires(T t) {
{ t.x1 } -> std::same_as<int>; { t.y1 } -> std::same_as<int>;
{ t.x2 } -> std::same_as<int>; { t.y2 } -> std::same_as<int>;
};
template <class T>
concept rect_2points = requires(T t) {
{ t.a.x } -> std::same_as<int>; { t.a.y } -> std::same_as<int>;
{ t.b.x } -> std::same_as<int>; { t.b.y } -> std::same_as<int>;
};one can make different wrappers
void rect( rect_top_width auto r ) { rect(r.left, r.top, r.left + r.width, r.top + r.height); }
void rect( rect_4ints auto r ) { rect(r.x1, r.y1, r.x2, r.y2); }
void rect( rect_2points auto r ) { rect(r.a.x, r.a.y, r.b.x, r.b.y); }
rect( [height=220,top=30,left=10,width=304] ); // unordered members
rect( [b=[y=10, x=10], a=[x=80,y=80]] ); // unordered members
widget w; // assuming widget has top/left/width/height members
rect( w ); // the function rect(rect_top_width) will be called
struct point { int x, y; };
point a{10, 20}, b{50, 60};
rect( [a,b] ); // one can mimic a 'rectangle' structure without defining it
2 "Sort of" less harmless ( i hope ) auto-types in structures.
The possibility of a structure like X was proposed, in
n3897 struct X {
auto i = c; // probably not possible in auto-type
auto s = "10"sv;
auto f = 10.8;
auto foo1 = [] (auto p) { return p * 2; };
};
Allowing public member lambdas, and member const initialization:
const int c = 20;
auto x = [i=c,
s="10"sv,
f=10.8,
foo1 = [](auto v) {
return v * 2;
}];
using X = decltype(x); // X should be default constructible now
I would like to use the syntax decltype( [lambda]... ) but due to unevaluated context problems it's not possible.
Thanks
BR[]