Clarify meaning of extra :()= in expression

[jamadagni]

Hello. I'm new to CPP2 but am hoping it will help me write cleaner and more expressive CPP code.

My question is about the example in this page:

    func := :() = {
        std::cout << "Price = " << price$ << "\n";
    };

It is not clear to me how to read that func := :() =. “func is an auto type which is defined as…” After that is not clear to me. I thought it just meant func is an auto type which is defined as a function with the following body so I tried changing it to:

func := () {

But this gives the error:

test4b.cpp2(3,13): error: ill-formed initializer (at '(')
test4b.cpp2(3,5): error: ill-formed initializer (at 'func')
test4b.cpp2(1,1): error: unexpected text at end of Cpp2 code section (at 'main')
test4b.cpp2(1,0): error: parse failed for section starting here

So what is all that about? Sorry for my ignorance…

[DyXel]

func is a deduced thing equal to (:= or : _ =), then you are declaring an unnamed function by writing :() = { ... } which is assigned to func. The equivalent would be to just write func: () = { ... }, but keep in mind that today it is not yet possible to write regular functions within another function body.

[jamadagni]

Yes I tried to just write a local function, but:
func : () = std::cout << "Price = " << price$ << "\n";
gives:

test4b.cpp2(4,41): error: $ (capture) cannot appear here - it must appear in an anonymous expression function, a postcondition, or an interpolated string literal (at '$')

and even without the capture:
greet : () = std::cout << "Hello\n";
gives:

test4c.cpp2(2,5): error: (temporary alpha limitation) local functions like 'greet: (/*params*/) = {/*body*/}' are not currently supported - write a local variable initialized with an unnamed function like 'greet := :(/*params*/) = {/*body*/};' instead (add '=' and ';')

But really, given that CPP2 already rewrites code to overcome CPP1 limitations, why can't it just automatically rewrite the local function to a lambda?

And should that “add '=' and ';'” in the error message be somewhat modified?

1. Because an extra colon is also required

2. Is a ';' applicable after {} ?

[DyXel]

But really, given that CPP2 already rewrites code to overcome CPP1 limitations, why can't it just automatically rewrite the local function to a lambda?

I guess nobody has opened an issue about it and thus hasn't been prioritized? Other than that, not really sure if the underlying semantic differences between a capture-less lambda and a regular function make this a undesirable thing.

And should that “add '=' and ';'” in the error message be somewhat modified?

Yes and no: For your first point, yes, you need the extra colon because you are declaring 2 entities (1 variable, 1 anon function). For the second, I would say to leave as-is, since you can immediately invoke the declared lambda: :() = {}(); which is very useful under certain circumstances.

[DerpMcDerp]

Variable defintion:

X: T = expr;

// all these are the same
x: _ = expr;
X: = expr;
X := expr;
// auto x = expr;

Function definition:

// whitespace between the colon and paren doesn't matter:
x: (a) = { expr; }
x:(a) = { expr; }
// auto x(a) -> void { expr; }

Lambdas:

:(x) = { expr; }
// [](x) { expr; }

Putting all that together:

func := :() = { body; };

func: _ = ( :() = { body; } );
// auto func = []() { body; };

e.g. you're defining a deduced variable func and assigning it the lambda.

[hsutter]

Thanks, great question!

Yes, I want local functions (for my own use too) and to automate that rewrite, I just hadn't prioritized it yet. This is another prod for me to do that, thanks.

In the meantime, I've just pushed a doc change to try to make that example clearer:

I hope that will help. Thanks again.

[jamadagni]

Yes, I want local functions (for my own use too) and to automate that rewrite, I just hadn't prioritized it yet. This is another prod for me to do that, thanks.

Filed #1238. Hope it will be helpful for keeping track of this. Thanks!

I'm looking forward to CPP2 being The New C++ in the future. 💐