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_at_[hidden]>
wrote:

> Right, but it doesn't have the lambda capture functionality.
>
>
> On Tue, Jan 12, 2021 at 5:18 AM Scott Michaud <scott_at_[hidden]> 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.
>>
>>
>>