Now that I am aware of Walter's stance on alias this:

"alias this has turned out to be a mistake" @ https://news.ycombinator.com/item?id=28029184

... would you, I mean the community, think is it a good idea to file a DIP to eventually get a new attribute to unambiguously label a class' default property ?

eg: @default string whatever(...);
eg: @default @property string whatever(...); /// if @property survives; that is

... or whatever you consider it should be named ?

Besides, alias this was not implemented to handle default properties albeit it seems it is common practice to (as I was previously advised to in a previous related post).

Do you think it'll be worth it ?

PS#1: From my unqualified point-of-view it seems it won't be much difficult to add it but—I can be quite wrong.

PS#2: I am not using alias this anymore; it is a double-edged sword.

On Sunday, 8 August 2021 at 00:52:43 UTC, someone wrote:

Can you please explain what a "default property" is? I have never encountered such a thing in any other programming language.

On Sunday, 8 August 2021 at 00:57:47 UTC, Paul Backus wrote:

public class cComputer {

   private string pstrID;
   private string pstrName;

   public string ID() { return pstrID; }
   public string name() { return pstrName; }

   public void ID(const string lstrID) { pstrID = lstrID; }
   public void name(const string lstrName) { pstrName = lstrName; }

   this(const string lstrID, const string lstrName) {

      pstrID = lstrID;
      pstrName = lstrName;

   }

}

public class cComputers {

   private cComputer[string] pobjComputers;

   public cComputer[string] computers() { return pobjComputers; }

}

void main() {

   cComputer lobjComputer1 = new cComputer("one", "eins");
   cComputer lobjComputer2 = new cComputer("two", "zwei");
   cComputer lobjComputer3 = new cComputer("three", "drei");

   cComputers lobjComputers = new cComputers();

   lobjComputers.computers["один"] = lobjComputer1;
   lobjComputers.computers["два"] = lobjComputer2;
   lobjComputers.computers["три"] = lobjComputer3;

   assert(lobjComputers.computers["один"].ID == "one");
   foreach (cComputer lobjComputer; lobjComputers.computers) { writeln(lobjComputer.name); }

   /// now suppose cComputer default property is name
   /// now suppose cComputers default property is computers

   assert(lobjComputers["один"] == "one");
   foreach (cComputer lobjComputer; lobjComputers) { writeln(lobjComputer); }

   /// same output ... these are default properties; gotcha ?

}

PS: the above code was typed here but not actually tested

On Sunday, 8 August 2021 at 04:51:48 UTC, someone wrote:

It might be that you were misunderstood. You're using "default property" as a term of art with a specific meaning, and the term itself looks generic enough that people can interpret it with their familiar meanings for 'default' and 'property'.

This is from Visual Basic, yeah?

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/procedures/how-to-declare-and-call-a-default-property

I've never run into like that before. And it doesn't seem well-loved in VB: "Because of these disadvantages, you should consider not defining default properties. For code readability, you should also consider always referring to all properties explicitly, even default properties."

This looks similar to that example:

struct MsgBox {
    string[] contents;
    void opIndexAssign(string s, size_t i) {
        if (contents.length <= i)
            contents.length = i + 1;
        contents[i] = s;
    }
}

void main() {
    import std.stdio : writeln;

    MsgBox x;
    x[0] = "Hello";
    x[1] = " ";
    x[2] = "World";
    writeln(x.contents);
}

On Sunday, 8 August 2021 at 05:07:17 UTC, jfondren wrote:

Probably.

Actually Visual FoxPro which had a full OOP implementation, for a lot of reasons hated VB back then, but yes, Microsoft family of developer tools have them and they were practical which is not to say they should be good, maybe they are a terrible idea, and thats why I was asking for advice beforehand.

struct MsgBox {
    string[] contents;
    void opIndexAssign(string s, size_t i) {
        if (contents.length <= i)
            contents.length = i + 1;
        contents[i] = s;
    }
}

void main() {
    import std.stdio : writeln;

    MsgBox x;
    x[0] = "Hello";
    x[1] = " ";
    x[2] = "World";
    writeln(x.contents);
}

That I don't remember. But, if they were controversial back in the day ... I think it is all said and done ... ain't it ?