Using arrow functions it doesn't seems so verbose
```js
function requestInput(question) {
  return new Promise(function(resolve) {
    interface.question(question, function(input) {
      resolve(input);
    })
  })
}
```
can be written as:
```js
const requestInput = question => new Promise((resolve) => {
  interface.question(question, resolve); // You can wrap resolve in a
`unary` helper if more than 1 argument is problematic
});
```

I don't see a problem with verbosity
-- 
Augusto Moura
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20171106/d78a8200/attachment.html>

Using arrow functions it doesn't look so verbose
```js
function requestInput(question) {
  return new Promise(function(resolve) {
    interface.question(question, function(input) {
      resolve(input);
    })
  })
}
```
can be written as:
```js
const requestInput = question => new Promise((resolve) => {
  interface.question(question, resolve);
  // You can wrap resolve in a `unary` helper if more than 1 argument is problematic
});
```

I don't see a problem with verbosity here

Using arrow functions it doesn't look so verbose
```js
function requestInput(question) {
  return new Promise(function(resolve) {
    interface.question(question, function(input) {
      resolve(input);
    })
  })
}
```
can be written as:
```js
const requestInput = question => new Promise((resolve) => {
  interface.question(question, resolve);
  // You can wrap resolve in a `unary` helper if more than 1 argument is problematic
});
```

I don't see a problem with verbosity

Using arrow functions it doesn't seems so verbose
```js
function requestInput(question) {
  return new Promise(function(resolve) {
    interface.question(question, function(input) {
      resolve(input);
    })
  })
}
```
can be written as:
```js
const requestInput = question => new Promise((resolve) => {
  interface.question(question, resolve);
  // You can wrap resolve in a `unary` helper if more than 1 argument is problematic
});
```

I don't see a problem with verbosity

Using arrow functions it doesn't seems so verbose
```js
function requestInput(question) {
  return new Promise(function(resolve) {
    interface.question(question, function(input) {
      resolve(input);
    })
  })
}
```
can be written as:
```js
const requestInput = question => new Promise((resolve) => {
  interface.question(question, resolve); // You can wrap resolve in a `unary` helper if more than 1 argument is problematic
});
```

I don't see a problem with verbosity