On Monday, 11 October 2021 at 15:59:10 UTC, Atila Neves wrote:

It's a hard one. Variables implicitly declared as global in JS certainly is up there.

Pretty much anything working around the incompleteness of type qualifiers. @nogc, shared being a nightmare, the impossibility of having a proper container library, all stem from the same place.

owned as a type qualifier. Because it would fix most of the problems for which many features have been introduced. I think we could reduce the language size overall by adding this one.

On Wednesday, 13 October 2021 at 20:10:06 UTC, Imperatorn wrote:

Yes, that's what I meant.

--
/Jacob Carlborg

On Wednesday, 13 October 2021 at 19:55:29 UTC, Jacob Carlborg wrote:

(int, int) point = (x: 2, y: 4);
auto x = point.x + a;
```

This would be better if the identifier was tied to the type.

Like below:

(int x, int y) point = (2, 4);
auto x = point.x + a;

Because with your example the following fails:

(int, int) getPoint1() { return (x: 2, y: 4); }
(int, int) getPoint2(bool shouldGetPoint1) {
  if (shouldGetPoint1) return getPoint1();

  return (left: 2, top: 4); // Possible error since the named values will be different??
}
auto point1 = getPoint1();
auto point2 = getPoint2(true);
auto point3 = getPoint2(false);

writeln("%d %d", point1.x, point1.y);
writeln("%d %d", point2.left, point2.top); // Error
writeln("%d %d", point3.left, point3.top);

However it wouldn't fail if it worked like below:

(int x, int y) getPoint1() { return (2, 4); }
(int left, int top) getPoint2(bool shouldGetPoint1) {
  if (shouldGetPoint1) return getPoint1();

  return (2, 4); // Ok
}
auto point1 = getPoint1();
auto point2 = getPoint2(true);
auto point3 = getPoint2(false);

writeln("%d %d", point1.x, point1.y);
writeln("%d %d", point2.left, point2.top); // Ok
writeln("%d %d", point3.left, point3.top);

On Thursday, 14 October 2021 at 10:55:14 UTC, bauss wrote:

(int, int) point = (x: 2, y: 4);
auto x = point.x + a;
```

(int x, int y) point = (2, 4);
auto x = point.x + a;

(int, int) getPoint1() { return (x: 2, y: 4); }
(int, int) getPoint2(bool shouldGetPoint1) {
  if (shouldGetPoint1) return getPoint1();

  return (left: 2, top: 4); // Possible error since the named values will be different??
}
auto point1 = getPoint1();
auto point2 = getPoint2(true);
auto point3 = getPoint2(false);

writeln("%d %d", point1.x, point1.y);
writeln("%d %d", point2.left, point2.top); // Error
writeln("%d %d", point3.left, point3.top);

(int x, int y) getPoint1() { return (2, 4); }
(int left, int top) getPoint2(bool shouldGetPoint1) {
  if (shouldGetPoint1) return getPoint1();

  return (2, 4); // Ok
}
auto point1 = getPoint1();
auto point2 = getPoint2(true);
auto point3 = getPoint2(false);

writeln("%d %d", point1.x, point1.y);
writeln("%d %d", point2.left, point2.top); // Ok
writeln("%d %d", point3.left, point3.top);

Ofc. these are supposed to be writefln and not writeln.

On Monday, 11 October 2021 at 15:59:10 UTC, Atila Neves wrote:

Worst features in a non-toy language. This is going to be controversial, but templates. They start innocent enough, just a way for functions to work with generic arguments. But then you build templates upon templates, and suddenly IDEs get lost, auto-refactoring stops becoming a possibility because most code doesn't exist yet, and you have to read documentation to understand what the return types and input types are of method T doStuff(T, U)(T val, U min, U max);

I wouldn't say worst, but I feel like D has many features which just don't get much use. For example contracts. Sure, they sound nice in principle, and I am sure there are some users of that feature. There's nothing wrong with that, but every feature adds more complexity and bugs to fix.

Features I'd like to see in D? Named arguments and struct/associative array initializers working outside of initialization, e.g. as function arguments.

Some syntactic sugar I like from other languages:

Named constructors as a replacement for factory static methods:

class Angle {
    this.fromDegrees(float deg) { ... }
    this.fromRadians(float rad) { ... }
}

Angle a = new Angle.fromDegrees(90.0f);

Initializer fields:

class Person
{
    string firstName, lastName;
    int age;

    this(this.firstName, this.lastName, this.age);
}
Person p = new Person("Michael", "Schumacher", 52);

On Thursday, 14 October 2021 at 11:06:00 UTC, JN wrote:

class Angle {
    this.fromDegrees(float deg) { ... }
    this.fromRadians(float rad) { ... }
}

Angle a = new Angle.fromDegrees(90.0f);

You can somewhat hack your way to it, by generating static functions at compile-time.

Of course they're not real constructors, so immutable cannot be used and you can't utilize it like new Angle.fromDegrees(90.0f) and will have to do it like Angle.fromDegrees(90.0f) instead.

Example:

class Angle {
    private:
    this(){}
    @Ctor void _fromDegrees(float deg) {
        writeln("from degrees");
    }
    @Ctor void _fromRadians(float rad) {
        writeln("from radians");
    }

    mixin NamedConstructors!Angle;
}

void main()
{
    auto a = Angle.fromDegrees(90.0f);
    auto b = Angle.fromRadians(90.0f);
}

Implementation of the hacky stuff:

struct Ctor {}

template ParametersFullyQualified(alias fun)
{
    Tuple!(string,string)[] produceIndexed(T)(T[] a, T[] b)
    {
        Tuple!(string,string)[] produced = [];

        if (a.length == b.length)
        {
            foreach (i; 0 .. a.length)
            {
                produced ~= tuple(a[i], b[i]);
            }
        }

        return produced;
    }

    enum ParametersTypeArray = Parameters!(fun).stringof[1..$-1].split(", ");
    enum ParameterNamesArray = [ParameterIdentifierTuple!(fun)];
    enum ParametersFullyQualified = produceIndexed(ParametersTypeArray, ParameterNamesArray).map!(t => t[0] ~ " " ~ t[1]).join(", ");
}

mixin template NamedConstructors(T)
{
    public:
    static:
    static foreach (member; __traits(derivedMembers, T))
    {
        static if (mixin("hasUDA!(" ~ T.stringof ~ "." ~ member ~ ", Ctor)"))
        {
            mixin(T.stringof ~ " " ~ member[1 .. $] ~ "(" ~ ParametersFullyQualified!(mixin(T.stringof ~ "." ~ member)) ~ ") { auto o = new " ~ T.stringof ~ "(); o." ~ member ~ "(" ~ [ParameterIdentifierTuple!(mixin(T.stringof ~ "." ~ member))].join(", ") ~ "); return o; }");
        }
    }
}

On Monday, 11 October 2021 at 18:27:29 UTC, russhy wrote:

The enum thing works now:

```
    enum MyEnum { A, B, C}

    with(MyEnum) {
        auto e = A;
        myFunction(A);
        switch(e) {
            case A:
                break;
            default:
        }
    }
    ```