Save the list of unused language feature to a file when compile.

[YagaoDirac]

I care about a stable way to make sure that everybody can easily know all the existing features. Then they can decide to learn or not to.
Background: I wrote some python recently. I'm not very good at python. Sometimes it's hard to remember the syntax like [x*x for x in range(42)]. When I need this result, I first think of some name like "map", "iota", or some function.

Also, I also would like to suggestion something like a stats of using freq of all the features. If some feature is hardly used and important, maybe we should do something.

[hsutter]

I care about a stable way to make sure that everybody can easily know all the existing features.

Good timing -- I'm now (finally) adding Cpp2 and cppfront documentation.

It's in progress, so parts are incomplete. Besides completeness, does this give you what you're looking for?

stats of using freq of all the features

I have no immediate plans for this, and not much Cpp2 code has been written yet. But as more code is written, it could be a project for someone to scrape .cpp2 and .h2 code on GitHub and collect statistics. I haven't tried, but I assume it will be easier because of the regular context-free syntax.

Save the list of unused language feature to a file when compile.

I'm not sure what this title means?

[YagaoDirac]

I read the link a bit. I think it's very good. It's short, clear. I believe it's always good to assume people have infinite things to learn, so they only learn the most "production/cost" parts. So, short docs are always good.

I also suggest the "how the tool is designed" part. In every case, we have multiple ways to do the same thing, and usually we don't care. You can directly tell people in which way you want them to use the tools. If numpy's docs had added this part, it would be perfect in my opinion. For people work in a decent IDE, the parameter hints in IDE are usually enough. So, in my mind, docs should be like, "name", then"example"then "see also" then "parameter hints".

Also, give every syntax a percise name, and make sure it's in the tour. We can search error info, but we don't get anything useful if we paste code into google or bing directly. We can only search the name of the syntax. It must be in the tour.

Please consider writing a "multi file programming" guide. Or some people call it modular programming. I fount it's very confusing. In most languages, how to use the code that is under a specific code, and how to use the code from other files, are always confusing. I think in cpp, a best practice structure is "#include" then "pre declarition of class", then "functions", then "declaration of classes" at last. If this is also a best practice in cpp2, please tell people directly. It's very hard to figure it out.
I also think it's worthy mentioning, most language don't share multi file programming syntax/modular programming syntax. And most IDEs fail in providing help in this area. We really need the official help on this.

Btw, my another true story. I stuck in multiple file programming in c++, then in python, then in go, and recently in python the 2nd time....

[YagaoDirac]

Let me add some interesting "fighting against python grammar".
I tried to tackle the circular import problem. I have 2 classes, they need to use some inner feature of one the other. The first one can not use the second one since the second one is not parsed by the compiler when the first one needs it. Putting them into seperated files doesn't solve the problem. I don't remember any suggestion on this, so I was stucked.
After few days, I came up with an idea, what if I put them into a big class.

class a:
    class b:
        def test_the_other(self) -> None:
            self.cc:a.c = a.c()
            self.cc.test()
            pass
        def test(self) -> None:
            print("inside b")
            pass
        pass
    class c:
        def test_the_other(self) -> None:
            self.bb:a.b = a.b()
            self.bb.test()
        def test(self) -> None:
            print("inside c")
            pass
        pass
    pass#class a

bbbb = a.b()
bbbb.test_the_other()
cccc = a.c()
cccc.test_the_other()

It works...
Now the question is, why is this pattern not the by default?
I suggestion in cpp2, these patterns be suggested officially. So people don't have to figure them out again and again.

[hsutter]

I don't understand the question, sorry... Cpp2 is order-independent by default, so you can just write the types to refer to each other. This works:

a: type = {
    test  : (this, other: b) = other.b_func();
    a_func: (this)           = std::cout << "inside a_func\n";
}

b: type = {
    test  : (this, other: a) = other.a_func();
    b_func: (this)           = std::cout << "inside b_func\n";
}

main: () = {
    aa: a = ();
    bb: b = ();

    aa.a_func();     // prints "inside a_func"
    aa.test(bb);     // prints "inside b_func"

    bb.b_func();     // prints "inside b_func"
    bb.test(aa);     // prints "inside a_func"
}

Does that answer your question?

For a slightly more complex example showing initialization of object cycles, see pure2-types-order-independence-and-nesting.cpp2.

[YagaoDirac]

Oh, yeah, this looks great!!

[hsutter]

Thanks! Just checking, is this discussion ready to close?