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_at_[hidden] <mailto: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]
> <mailto:scott_at_[hidden]>> wrote:
>
> Andrew,
>
> Wouldn't this be equivalent to a local, unnamed class?
>
> Godbolt: https://godbolt.org/z/ezn8va
> <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.
>>
>>