Simo Costa (2018-11-28T18:32:53.000Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}


So my proposal is to avoid those repetitions  by prefixing a dot *.* to
each parameter:

F(.par1, .par2, ..., .parN) {}

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-assignments
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20181128/0172cfcd/attachment-0001.html>
andrysimo1997 at gmail.com (2018-11-29T09:06:21.308Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-objects-assignments/
&nbsp;\
&nbsp;\
&nbsp;\
[EDIT]

It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a more general situation:
```js
f(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
f(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```
&nbsp;\
&nbsp;\
[EDIT 2]

We can go a step further.
When more than one parameters has to be inserted into an object:
```js
f(obj.par1, obj.par2, obj.parN) {}
```
we could write:
```js
f(obj.{par1, par2, parN}) {}
```

andrysimo1997 at gmail.com (2018-11-29T09:05:53.348Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-objects-assignments/
&nbsp;\
&nbsp;\
[EDIT]

It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a more general situation:
```js
f(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
f(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```
&nbsp;\
&nbsp;\
[EDIT 2]

We can go a step further.
When more than one parameters has to be inserted into an object:
```js
f(obj.par1, obj.par2, obj.parN) {}
```
we could write:
```js
f(obj.{par1, par2, parN}) {}
```

andrysimo1997 at gmail.com (2018-11-29T09:05:27.133Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-objects-assignments/
 \
 \
[EDIT]

It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a more general situation:
```js
f(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
f(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```
 \
 \
[EDIT 2]

We can go a step further.
When more than one parameters has to be inserted into an object:
```js
f(obj.par1, obj.par2, obj.parN) {}
```
we could write:
```js
f(obj.{par1, par2, parN}) {}
```

andrysimo1997 at gmail.com (2018-11-29T09:05:14.077Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-objects-assignments/
\
\
[EDIT]

It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a more general situation:
```js
f(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
f(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```
\
\
[EDIT 2]

We can go a step further.
When more than one parameters has to be inserted into an object:
```js
f(obj.par1, obj.par2, obj.parN) {}
```
we could write:
```js
f(obj.{par1, par2, parN}) {}
```

andrysimo1997 at gmail.com (2018-11-29T09:04:54.100Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-objects-assignments/
&nbsp;
&nbsp;
[EDIT]

It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a more general situation:
```js
f(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
f(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```
&nbsp;
&nbsp;
[EDIT 2]

We can go a step further.
When more than one parameters has to be inserted into an object:
```js
f(obj.par1, obj.par2, obj.parN) {}
```
we could write:
```js
f(obj.{par1, par2, parN}) {}
```

andrysimo1997 at gmail.com (2018-11-29T09:04:03.896Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-objects-assignments/

[EDIT]

It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a more general situation:
```js
f(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
f(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```


[EDIT 2]

We can go a step further.
When more than one parameters has to be inserted into an object:
```js
f(obj.par1, obj.par2, obj.parN) {}
```
we could write:
```js
f(obj.{par1, par2, parN}) {}
```

andrysimo1997 at gmail.com (2018-11-29T08:53:52.072Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-objects-assignments/

[EDIT]

It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a more general situation:
```js
f(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
f(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```

andrysimo1997 at gmail.com (2018-11-28T22:42:56.128Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-assignments

[EDIT]

It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a more general situation:
```js
f(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
f(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```

andrysimo1997 at gmail.com (2018-11-28T22:42:40.187Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-assignments

[EDIT]

It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a more general situation:
```js
F(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
F(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```

andrysimo1997 at gmail.com (2018-11-28T22:42:18.332Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-assignments

[EDIT]

It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a general situation:
```js
F(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
F(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```

andrysimo1997 at gmail.com (2018-11-28T22:42:06.036Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-assignments

[EDIT]
It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a general situation:
```js
F(obj.par1, obj.par2, obj2.parN) {}
```
equivalent to:
```js
F(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```

andrysimo1997 at gmail.com (2018-11-28T22:41:18.344Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-assignments

[EDIT]
It could be a shortcut for:
```js
F(this.par1, this.par2, ..., this.parN) {}
```
so we could create and initialize objects in a general situation:
```js
F(par1, par2, parN) {
  let or const obj = { par1, par2 };
  let or const obj2 = { parN };
}
```
equivalent to:

andrysimo1997 at gmail.com (2018-11-28T19:16:45.241Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal-fast-this-assignments
andrysimo1997 at gmail.com (2018-11-28T19:15:02.721Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal
andrysimo1997 at gmail.com (2018-11-28T18:39:14.894Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```js
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot `.` to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal
andrysimo1997 at gmail.com (2018-11-28T18:38:55.806Z)
In costructor functions and in the constructor() method in ES6 classes is
easily to fall in the following pattern:

```js
F(par1, par2, ..., parN) {
  this.par1 = par1;
  this.par2 = par2;
  ...
  this.parN = parN;
}
```

So my proposal is to avoid those repetitions  by prefixing a dot *.* to
each parameter:

```js
F(.par1, .par2, ..., .parN) {}
```

Simple but quite useful. More info here:
https://github.com/jfet97/proposal