On 2/19/22 15:37, Vijay Nayar wrote:

> The problem is that the parameter of the constructor actually has no
> name at all. Thus, the statement `this.val = val` simply sets the member
> variable to its own value

Wow! I've never come accross that one before. :)

> What is the main motivator to allow parameters with no names?

This is common in C++ as well. You have to have a parameter because an interface requires it but you don't really have any use for that parameter. If you name it, then there may be "unused variable" warning. So, it is common to comment out the parameter name so that it is instructive to people who look at the code:

void foo(int /* length */) {
  // ...
}

> Do they get an automatic implied name like `_` or something?

The function is compiled to take the specified type of a parameter but it is simply not used. (Names are only for source code so it doesn't matter.)

Ali

On 2/19/22 22:09, Salih Dincer wrote:

> The following doesn't work in a function outside the class:
> ```d
> TYPE foo(TYPE) { return 42; }
> ```
> The compiler gives the following error:
> ```undefined identifier TYPE```

I am not sure whether you are asking a question so apologies if I am stating the obvious. For (TYPE) to be a template parameter list, there must be the function parameter list as well:

TYPE foo(TYPE)() { return 42; }

<aside>
By the way, the fact that we can return the "int" 42 even when TYPE is e.g. 'short' is thanks to "value range propagation". The compilr sees that the manifest constant 42 fits in a short and compiles the code without complaint.

On the other hand, the following modification does not compile:

TYPE foo(TYPE)() {
  int r = 42;
  return r;  // <-- Compilation ERROR
// Error: cannot implicitly convert expression `r` of type `int` to `short`
}

void main() {
  foo!short();
}
</aside>

Getting back to the main topic, you may or may not need the function parameter list for a member function:

struct S(TYPE) {

  // This is not a template but a function
  // with the parameter name not omitted.
  // (TYPE is already known at this point.)
  TYPE foo(TYPE) {
    return 42;
  }

  // This is a member function template
  TYPE bar(TYPE2)() {
    // ...
  }
}

Ali