Constructor Syntax

[DartBot]

This issue was originally filed by ervok...@gmail.com

---

I have an issue with the following:

class Point {
  var x, y;
  Point(this.x, this.y);
  scale(factor) => new Point(x*factor, y*factor);
  distance() => Math.sqrt(x*x + y*y);
}

The problem is that the constructor (in this case there's only one, but there may be many) includes the name of the class. This is (as far as I can tell) unnecessary duplication. Every time you rename a class, you need to change the name in multiple places.

I understand this could be solved by an IDE (which would do the work for you). However, simpler text editors have their place, too.

Please implement a different syntax, perhaps a 'new' keyword. I don't care what the exact syntax is, as long as there isn't unnecessary duplication.

[dgrove]

Removed Type-Defect label.
Added Type-Enhancement, Area-Language labels.

[DartBot]

This comment was originally written by drfibonacci@google.com

---

Added Triaged label.

[DartBot]

This comment was originally written by jon.js1....@gmail.com

---

I was put off by this realization too. Using the constructor name couples the implementation lexically to the class name, which makes things much harder to change or move around. I think it's fair to say that nobody really wants to be forced to use an IDE to be productive with this language.

I've never seen the new keyword used as the constructor name before, but given that it's already reserved and invalid in the given context in the grammar, it might make a neat intuitive name. Of course, that limits the language in the future, so maybe not such a good idea.

[DartBot]

This comment was originally written by binary...@binarysplit.com

---

VB.NET uses "New" as the name of the constructor. It generally works well.

Dart already provides a special syntax for referencing the superclass's constructor("super(args)"), and doesn't appear to allow a constructor to call other overloads of the constructor, so I don't see this having any negative effects on the grammar.

[DartBot]

This comment was originally written by er...@gmail.com

---

I forgot to add one thing, which might be obvious, but I think it's worth mentioning.

The syntax becomes especially bad if a class has a long name; code will become (unnecessarily) cluttered with copies of that long name.

class FairlyDescriptiveClassName {
  var x, y, z;
  FairlyDescriptiveClassName(this.x, this.y);
  FairlyDescriptiveClassName.withPrefix(this.z);
 } // And so on.

[DartBot]

This comment was originally written by jat@google.com

---

And that is supposed to be readable?

[gbracha]

The goal here is to make the code instantly familiar to the mainstream programmer. Doing roughly what the C++, Java etc. have done for 30 years is a conservative choice, and a deliberate one.

If you need to rename the class without an IDE, changing the constructor name is probably the least of your problems. In any case, that's easily handled with regex search/replace.

As for coupling - the built-in factory support means that you can change the implementation you are using without changing the call sites. All in all, the constructor scheme in Dart is one of its strengths, solving a very difficult issue in a way that looks familiar but does not suffer from the standard problems constructors have. We could make some adjustments as we see the experience in larger scale use, but don't count on it.

---

Set owner to @gbracha.

[DartBot]

This comment was originally written by rfab...@planalytics.com

---

I am one of those Java Developers who absolutely hate the Java way,
and I use a simple text editor (vim+pmd) with Eclipse+vwrapper for code checking,
so I feel the pain every time I rename a class and have to refactor the constructors
also. So I look at Ruby with envy... having a modern constructor syntax.

initialize()

I love Dart, so far, but think the right thing to do is the Ruby way in this case.

Why use New which is so confusing with all the other syntax highlighted 'new's in code.

Just my 2 cents.

[DartBot]

This comment was originally written by rfab...@planalytics.com

---

Of course, a 'New' can be distinguished from 'new' in color syntax highlighting,
so "New" is way better than the class name way.
I agree in principle with the first comment.

Why don't we all use Eclipse to "easily handle refactoring constructors"?
    1. Eclipse doesn't support modal editing by default.
       (I can't get the Dart Eclipse IDE to use the Eclipse vwrapper plugin.
    2. Eclipse has been unstable for me sometimes and others I know running on Linux.
    3. I prefer certain features of powerful programmable editors (vim+pmd+scripts)

[DartBot]

This comment was originally written by @MarkBennett

---

I am also in favour of adopting a standardized constructor keyword, rather than re-using the class name.

When I first began using Java I remember the constructor syntax to be confusing and counterintuitive as you'd first need to find the name of a class, then search for it's constructor.

Using a standard constructor name reduces cognitive loading, parser complexity and makes the language more accessible to plain text IDE's.

Though there are examples of languages using the constructor syntax Dart has selected, there are as many examples of languages using a standardized constructor name instead so the argument of which is more "familiar" to a "mainstream" programmer is rather dubious. There are many other places where Dart welcomes Java and C++ developers, however this is one case were it may be better to take inspiration from more modern languages like C#, Python and Ruby.

The goal of Dart is not to re-implement Java in the browser, but to be familiar and accessible to all developers with Java experience or otherwise. Using a common constructor doesn't present a significant impediment to existing Java developers, and will make the language more welcoming to new developers.

[DartBot]

This comment was originally written by dgaxho@gmail.com

---

As another day-job Java programmer I have to say this really isn't TOO big of a deal with the built in factory support, but I'd also rather have something consistent like init/new/create whatever. Then again, I wish we could just get rid of the new operator all together and just be able to do ClassName.new() or init() etc. I think that would reveal more to the dev that constructors are composable in dart and not really different from any other class method.

I'm very wary these features that look 'familiar' even though they're really not. IMO it's far more confusing to have something that looks familiar but in reality is not, than to have something that looks different (and not really very different) which implies (correctly) that it works differently and therefore it's easier to understand the differences.

[DartBot]

This comment was originally written by rtim...@gmail.com

---

new instead of $className?

class Point {
  var x, y;
  Point(this.x, this.y);
  scale(factor) => new Point(xfactor, yfactor);
  distance() => Math.sqrt(xx + yy);
}

becomes

class Point {
  var x, y;
  new (this.x, this.y);
  new from(Point other);
  scale(factor) => new Point(xfactor, yfactor);
  distance() => Math.sqrt(xx + yy);
}

[DartBot]

This comment was originally written by rfab...@planalytics.com

---

I would keep the discussion open to "New" or "new" or "initialize" instead of $className. The advantage of "new" or "New" is that they are shorter than "initialize". "Init" could be used, but is nice to leave for other programmer uses besides constructors. A disadvantage of "new" is possible confusion (including syntax highlighting, with the normal use of "new" creating new instances.

So this

class Point {
  var x, y;
  Point(this.x, this.y);
  scale(factor) => new Point(xfactor, yfactor);
  distance() => Math.sqrt(xx + yy);
}

becomes

class Point {
  var x, y;
  New(this.x, this.y);
  scale(factor) => new Point(xfactor, yfactor);
  distance() => Math.sqrt(xx + yy);
}

or

class Point {
  var x, y;
  initialize(this.x, this.y);
  scale(factor) => new Point(xfactor, yfactor);
  distance() => Math.sqrt(xx + yy);
}

The latter is my favorite as it avoids confusion of constructor and new instances,
and avoids possible syntax highlighter color differentiation issues.

[DartBot]

This comment was originally written by rfab...@planalytics.com

---

I think Scala uses "this" and Gosu uses "construct".
So there is "New/new", "initialize", "this", or "construct" for some ideas.
I agree with the first poster...
  "I don't care what the exact syntax is,
   as long as there isn't unnecessary duplication."
   To avoid the situation of every time you rename a class,
   having to change the name in multiple places.

I would vote for "initialize", but let the Dart team pick, if they are willing,
as almost anything is better than the classname.

[DartBot]

This comment was originally written by ladicek@gmail.com

---

To avoid the situation of every time you rename a class,
having to change the name in multiple places.

You still have to do that on every place you actually instantiate that class. Not having to rename constructors looks like a very minor issue to me.

If the Dart team decides to actually do this, I'd vote for using 'new', because it automatically eliminates any causes of ambiguity and confusion while not adding another keyword. 'this' would look weird when having a lot of initializing formals and other suggestions ('initialize' etc.) are valid method names.

[DartBot]

This comment was originally written by rfab...@planalytics.com

---

You still have to do that on every place you actually instantiate that class.
Not having to rename constructors looks like a very minor issue to me.

I would agree this is very minor compared with the issue of public/private access
in Dart using the "_" convention, which is so un-Java like. (Will distance Java developers)

But I would agree that you have mentioned a good "advantage" for the use of "new" or "New", (avoiding adding a keyword), and it would be fine if Dart chooses "new".

I would still vote for "initialize", to avoid confusion over new instance variables, and consider adding another "keyword" a very minor loss for the important purpose of getting constructors right (following in the Ruby tradition).

Either way is better than classname constructors.

[DartBot]

This comment was originally written by ladicek@gmail.com

---

the important purpose of getting constructors right (following in the Ruby tradition)

This is totally off topic, but I will say it anyway: I think that Dart is the first mainstream-ish language that gets constructors right -- by adding factories. Syntax isn't that important, really.

[DartBot]

This comment was originally written by rfab...@planalytics.com

---

I think that Dart is the first mainstream-ish language that gets constructors
right, by adding factories. Syntax isn't that important, really.
Not everyone agrees... or VB would not have used "New" and Ruby would not have used
"initialize"...and Gosu would not have used "construct"... and Scala would not have
used "this".

If I spend extra time fixing renamed class constructors, isn't that important?
Some new languages save me time when I have to rename classes, using "new"/"initialize"... and I like that! (I'm assuming not depending on IDE rename)

[DartBot]

This comment was originally written by ladicek@gmail.com

---

If I spend extra time fixing renamed class constructors, isn't that important?

What extra time are we talking about? Like 0.1% of all the time needed to replace the class name on all other places?

Oh and BTW: using 'initialize' would mean less duplication, but in some cases (the original poster uses a 'Point' class) longer code. Heh? :-)