Oh I just came up with a smelly hack for this.

Godbolt: https://godbolt.org/z/xe5oEz

On 1/12/2021 12:25 AM, Andrew Tomazos wrote:

ie like below, see how argv is captured:

class ISomeInterface
{
public:
    virtual void Function1() {}
    virtual void Function2() {}
};

void TestInterface(ISomeInterface& inObject)
{
    inObject.Function1();
    inObject.Function2();
}

int main(int argc, char** argv)
{
    TestInterface([&]: ISomeInterface {
        void Function1() override
        {
            std::cout << "One!" << argv[0] << std::endl;
        }

        virtual void Function2() override
        {
            std::cout << "Two!" << argv[1] << std::endl;
        }

    });

}

On Tue, Jan 12, 2021 at 5:20 AM Andrew Tomazos <andrewtomazos@gmail.com> wrote:

Right, but it doesn't have the lambda capture functionality.

On Tue, Jan 12, 2021 at 5:18 AM Scott Michaud <scott@loosescrew.ca> wrote:

Andrew,

Wouldn't this be equivalent to a local, unnamed class?

Godbolt: https://godbolt.org/z/ezn8va

On 1/11/2021 11:55 PM, Andrew Tomazos via Std-Proposals wrote:

I have an idea for a language feature we'll call Lambda Classes.

As placeholder syntax let's say like:

    lambda-class:

        lambda-introducer : base-specifier-list_opt { member-specification_opt }

So for example:

    auto my_lambda_class = [cap1,cap2]: {

        void f() { /*...*/; }

        void g() { /*...*/; }

    };

A lambda class is to a normal class object as a lambda function is to a normal function.

A lambda class is an expression that is introduced with the usual capture sequence, but is followed by a colon, a (possibly empty) base class list, and then a class definition body.

It constructs a new anonymous class type in the same fashion as a normal lambda, capturing any variables as specified in the lambda-introducer, derives the new class type from any bases in the base-specifier-list, and adds any members given in the member-specification, and the value of the expression is the (singular) object of that new class type.

The motivation is that there are many use cases where an API asks for an object of a class type that implements some interface - either implementing a (virtual) polymorphic interface (run-time polymorphism) in traditional OOP, or that models a certain concept (compile-time polymorphism) in template meta-programming - and in many of both of those use case families, the response is to create a single-use class is created just to adapt to that API.  Like lambda functions, lambda classes help remove a lot of the boilerplate and indirection in such use cases.

Let me know if there is any enthusiasm for this and I'll write up a proper draft.