Is it possible to make a.b style keywords in cpp2?

[YagaoDirac]

As programming languages are more advanced, they probably need more keywords.
a.b style for keywords allows almost infinite amount of keywords while they are absolutely impossible to conflict with any user defined var name.
While a.b style makes use of automatic completion, and can gather keywords for similar usages in the same "namespace".
I just saw people talked about the syntax for loop. Generally, if we can have more keywords, we can provide more feature for the lang. And also, if we can use keywords, it's very likely to be a better design than only with symbols. Symbols will never get any support from automatic comletion.
Do you guys still remember the joke like: auto(){()auto(()){()}.(); It's not a real code. But if you don't know what is this, you will never get any help from bing or google, or even the docs doesn't help.

[hsutter]

It's definitely possible, but this is the kind of thing that would typically arise later after the syntax has become complex and we're trying to evolve something in a crowded grammar area.

Right now the syntax is quite simple so I'm not sure we have cases where this would arise. Did you have some examples in mind?

[YagaoDirac]

I actually have, but it's a toy level language.
In cpp2, I believe I still have some examples. I don't remember the assersion keywords in cpp2. I remember you mentioned the keywords are very crowded there, and you refused to use ass, lol.
The example may look like:
cpp2_assert_eq(i, 42);
vs
a.ep(i, 42);

cpp2_yield 42;
vs
r.y 42;// r is for return, y is for yield.
or
b.y 42;// b is for branch control.

My toy proj is:
https://github.com/YagaoDirac/Doconly-Programming-Language/blob/main/Syntax%20examples.md?plain=1
I stoped right after began.
A very strong reason is to take use of the auto completion from the IDE, which actually helps a lot.
example:

[flag1] [flag2] void func()[flag3] [flag4] [flag5] 
{}

vs

void func(){}
f.get("func").set_no_drop_return().set_no_throw();// f is for function command, which is a compile time thing.

In the old way, we need to remember all the names of flags. But the new syntax take use of the help from IDE.
This example is a bit off topic. But at least we can do :

[f.flag1] [f.flag2] void func()[f.flag3] [f.flag4] [f.flag5] 
{}

In my toy proj, the best example so far is

b.if a>1{
  b.likely;
  h.print("a>1");
}
b.else{
  b.unlikely//or simply omit this line
  h.print("a<=1");
}

b is for branch control, h is for help, which is not important.
If people don't care the readability, it can be shortened into:

b.i condition{
  b.l;
//...
}
b.e{
  b.u;
//...
}

Also, people are trying to bind pmr(I don't remember the full name, it's a new feature in cpp17) to all the allocation. They are using some existing keywords. I understand it doesn't requires more keywords, but it make cpp harder to bing or google or stack overflow as people adding more features to every keywords. We really need more keywords.
Lambda expr is definitely the hardest thing to bing in cpp. It's not very possible to get the word"lambda". But if we do:
f.l(param list){func body}, where f is for function, l is for lambda, people can at least look for the link in official docs.

I really believe a.b style is a good design, but I don't have very convincing examples now.

[hsutter]

I don't remember the assersion keywords in cpp2. I remember you mentioned the keywords are very crowded there, and you refused to use ass, lol.

Actually no, that problem is in today's C++ only. 😀

Cpp2 doesn't have that problem, it uses assert... see Contracts.

[YagaoDirac]

Let me repeat one of my suggestions again. We need a way to let people iterate through all the features, so people can learn each of them if they have time. Search engines don't help, docs websites barely helps. I suggested that the compiler store a list of unused feature to a file, I know the idea is very naive. But, if a feature is very invisible to people, it's very hard to make sure people know it.
a.b style helps a bit. It's another reason.