[SUGGESTION] Namespace definition to use += instead of =

[JohelEGP]

So after some thought of brainstorming options, include ones that include is, the one I like the best is to use exactly the declaration syntax, but with == to connote equality with an existing entity, instead of = which connotes setting the new entity's value.

A wild thought.

Maybe a namespace declaration should use += instead of =.
So ns: namespace = { would become ns: namespace += {.

+= denotes in-place addition, not definition.
But notice how : remains despite +=.
So it both (re)defines the namespace's identifier, which is valid, and adds to it.
Then all remaining uses of : /*signature*/ = would denote definition of the non re-definable kind, which is a bigger plus.

How does that fit with the current Cpp2?
What about with your idea to replace namespace with a metafunction, @hsutter?

Originally posted by @JohelEGP in #273 (comment)

[JohelEGP]

By supporting nested namespace definition, the distinction from other declarations raises.

x::y: type = { } // Error!
a::b: namespace += { } // Perfectly OK.

Originally posted by @JohelEGP in #273 (comment)

---

Then all remaining uses of : /signature/ = would denote definition of the non re-definable kind, which is a bigger plus.

Varibles can be re-assigned so I don't think : /*signature*/ = denotes something of non-redefinable kind and you can also add functions to classes.
Originally posted by @AbhinavK00 in #273 (comment)

Variables can be assigned to, yes.
But only once, the first time, may it have : indicating definition.
Other assignments are not redefinitions.

Shadowing does redefine what the identifier means for the current scope.
And is distinguished from : namespace +=, which really does append, and doesn't shadow.

// Maybe they should be defined at first with `=`
x: namespace = {}

-- Portion of #273 (comment)

I disagree.
Maybe that should be the case for the extension methods you describe.
But : is definition, and namespaces always append, so requiring = first is just needless friction.
Originally posted by @JohelEGP in #273 (comment)

[JohelEGP]

Shadowing does redefine what the identifier means for the current scope.
And is distinguished from : namespace +=, which really does append, and doesn't shadow.

Maybe the last "and doesn't shadow" is wrong.
It's still a definition, so it does introduce a name.

x: int = 0;
f: () = {
  x := 0; // Unqualified `x` no longer means `::x`.
}
a: namespace += { }
b: namespace += {
  a: namespace += { } // Unqualified `a` now means `b::a`.
}

[msadeqhe]

I like your idea, += is more expressive than = about what happens when we declare namespaces.

Maybe the last "and doesn't shadow" is wrong.
It's still a definition, so it does introduce a name.

Because shadowing happens on declarations, so = or += don't affect shadowing but : does.

[msadeqhe]

Maybe that should be the case for the extension methods you describe.

If Cpp2 would support extension methods, it would be another use case for += on types too:

t: type = {}

t: type += {
    // Extension method
    f: () = {}
}

[AbhinavK00]

In cpp, the syntax for defining and reopening a namespace is same. We can do the same in cpp2.
Instead of teaching people that "this is how you define a namespace and this is how you open it", its just same syntax for both.

[gregmarr]

@AbhinavK00 Yes, that's true, and Johel is suggesting that this "same syntax" for namespaces be += instead of =, just like the syntax for aliases is == instead of =, to point out that it's not exactly the same as a normal one-shot definition. (I'm not saying whether I agree with it or not, just clarifying the proposal.)

[AbhinavK00]

Ah ok, so here's what I think.
+= has no advantage over =. = is more consistent because it is also used with functions, variables and classes, moreover none of these has a valid : /*identifier*/ += syntax. Using += loses that consistency. I know it is inspired from == for aliases but if we went this path, then the syntax would just diverge intoname : identifier "something out of =, == or += depending on identifier instead of same := for all the things. Yes, aliases are an exception but maybe they would be fixed in future if we come up with a better syntax that is context free

[JohelEGP]

It's already context free.

Cpp2 strictly avoids this, and never requires sema to guide parsing. When I say "context-free parsing" this is the primary thing I have in mind... the compiler (and the human) can always parse the current piece of code without getting non-local information from elsewhere.
-- Extract from https://github.com/hsutter/cppfront/wiki/Design-note%3A-Unambiguous-parsing.

[AbhinavK00]

It's already context free.

I'm not talking about cpp2 has a whole. Someone on reddit recommended the following syntax for aliases

x : alias = something;

and Herb pointed that this won't be context free as the compiler would have to look up whether "something" is a class, namespace or else. The current syntax is context free as you specify upfront what you're aliasing to.
I was saying that once someone comes with a context-free syntax for aliases which is consistent with :=:, maybe Herb would change it. Sorry I should've been more clear

[realgdman]

https://github.com/hsutter/cppfront/wiki/Design-note:-Namespaces says namespaces could become partial classes.

[JohelEGP]

Yes. That's what this from the OP was alluding to:

What about with your idea to replace namespace with a metafunction, @hsutter?

[msadeqhe]

@AbhinavK00, Good point 👍. Consistency is an important factor to consider in : = vs : += for namespace declarations.

[hsutter]

Yes, namespaces and partial classes could both be reopened, so x: namespace_or_partial_class = { ... } could successively add things.

But for now namespaces are their own thing. Still, I think it's consistent to let = add, we're just setting its contents more than one time.