I have an idea for relaxing lambda syntax 
Please, tell me if it´s a non-starter or if it may be something interesting.

1 - Permit lambdas defined only by the capture, making '{}' optional, so auto x = [a=10, b=20] becomes a valid lambda, and when there is no {} and no '()' ( parents are already optional ) the data members become public, permitting access, and avoiding ABI problems with current lambdas.
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[]