ES: Allow deconstructing objects with splats

[flying-sheep]

…for parity with ECMA7. currently we can’t do this:

x =
  a: 1
  b: 2
  c: 3

{ a, b, y... } = x
# or
{ a, b, ...y } = x

console.log a, b, y  # → 1 2 {c:3}

[vendethiel]

Seems like #815 proposed this feature but was closed for other reasons.

[lydell]

Is that really part of ES6? I've never seen it before.

[flying-sheep]

ah, you are right, it’s actually part of ES7, included in JSX. i assumed everything of JSX that isn’t <ReactElement/> syntax is a subset of ES6.

here is the implementation

/edit: babel supports it as well (demo)

[lydell]

Cool! Thanks for those links!

[flying-sheep]

no problem.

at closing of that other issue: luckily, that’s about something different (i.e. extending objects, not destructuring them)

and @jashkenas’ argument…

Splats are for lists of things

…is also not valid anymore now that ECMAscript itself uses splats for objects.

so this should be good to go!

[flying-sheep]

now it’s in the compat-table

[bbtfr]

+1 for this, it would be very helpful to write React Apps in CoffeeScript with this feature.

[reduxdj]

Hoping this is added to Coffeescript, is it going to be?

[wmertens]

So I'd also love to see {b:5, bar..., c} as the shorthand for merge({b: 5}, bar, {c: c}) and while we're at it {[foo]: bar} for _t={},_t[foo]=bar,_t, all very handy things slated for ES6/7.

Should these go into separate issues?

[lydell]

{[foo]: bar} is already possible: {"#{foo}": bar}

[wmertens]

Ooh, I didn't know about that, nicer syntax too! That just leaves the spread and rest operations...

[michaelficarra]

@lydell with the caveat that it doesn't work for symbols.

[vendethiel]

Well, since @jashkenas said he considered symbols a misfeature, I guess that's fine for coffee?

[michaelficarra]

Guess so, though I don't agree we can ignore it since standard lib APIs and even syntax depend on values with symbols as keys.

[flying-sheep]

yeah, we need a way to express this ES2015 in CS:

const iterable = {
    *[Symbol.iterator]() {
        yield 1
        yield 2
    }
}

[wmertens]

I'd just like to point out that I'm currently mostly writing JSX and that's mostly because of being able to write foo={...props, thing: 5}.

[onemanstartup]

@wmertens https://github.com/jsdf/coffee-react cofee-react supports spread attributes.

[wmertens]

@onemanstartup yeah but I don't want to write xml.
I simply set E to React.createElement and then write things like E Menubar, collapse: false, (E Item label: t.name, t.val for t in items).
Just calling functions is very nice in CS, not so much is JS.

[Jamesernator]

yeah, we need a way to express this ES2015 in CS:

const iterable = {
*Symbol.iterator {
yield 1
yield 2
}
}

This is something that should probably be an issue of its own as currently the only ways to do this are:

Not inheritable

class SomeIterable
    constructor: (...) ->
        ...
        @[Symbol.iterator] ->
            ...

Sort've defeats the original point of CoffeeScript classes:

class SomeIterable
    constructor: (...) ->

SomeIterable::[Symbol.iterator] = ->
    ...

[lydell]

@Jamesernator This is an alternative:

class SomeIterable
    constructor: (...) ->

    @::[Symbol.iterator] = ->
        ...

[pvorona]

Speaking of cjsx, one of the main feature of object splats (or rest parameters) in JSX is ability to do so:

const {propIamGonaConsume, ...others} = props
return <SomeComponent {...others}/>

As it seems to me, for now it is impossible to do in cjsx, so it would be really nice to resolve this feature request.

[pvorona]

Also, it's first time i found that JS can do something coffee can't

[Tsher]

Just use ES6 emit instead. may be coffeescript is good support to ES6 ,not ES7

obj = { x: 1, y: 2}
obj1 = {...obj, z: 3}

# ES6 emit
obj = {x: 1, y: 2}
obj1= Object.assign({}, obj, { z: 3 })

[dbackeus]

As immutable object creation in redux etc is becoming all the rage replicating the object splat in coffeescript seems quite relevant.

It would certainly be a nicer solution than using Object.assign, which is also polyfill dependent.

[gucki]

@jashkenas Would a PR get merged?

[vendethiel]

It'd certainly start a discussion :-).

[beeplin]

+1.

obj = { x: 1, y: 2}
obj1 = {...obj, z: 3}

nowadays this grammar is quite vital when writing react/redux and vue/vuex. hope coffee will be able to do this soon. :)

[benjie]

I'd be fine with this being simply passed through so Babel can interpret it, like async/await

[GeoffreyBooth]

This should be supported as part of CoffeeScript 2, which will output ES2015 spread syntax. After #4311 implements the rest operator, spread in objects should probably be the next target. Help wanted.

[beeplin]

@GeoffreyBooth, glad to see plans on CoffeeScript 2 ~ Some es6 features do become more and more vital today: import and export will be the key point of tree shaking in rollup and webpack2; some frameworks like react and vue are also designing their syntax to make max use of es6 feathers like object spread. We all like coffee and hope the new version of coffee can be going ahead of es6 again. :)

[GeoffreyBooth]

import and export are already here, in CS 1.11.

[beeplin]

wow, didn't notice that. cool!

[GeoffreyBooth]

Help wanted! I’ve started a destructuring branch for CoffeeScript 2 to output ES2015+ syntax for destructuring. I’m happy to invite contributors to this branch.

[GeoffreyBooth]

Implemented via #4493.