CS2 Discussion: Features: Spread syntax triple dots on either right or left

[GeoffreyBooth]

CoffeeScript’s spread syntax was adopted into ES2015, but they flipped the position of the dots from the right to the left:

foo args... # foo(...args);

We can’t flip them to the left in CoffeeScript without needlessly breaking lots of legacy code, but what about allowing the dots on either side?

foo args... # foo(...args);
# or
foo ...args # foo(...args);

[mrmowgli]

+1, seems like a reasonable compromise and would allow a clean transition.

[YamiOdymel]

+1 for this, since both are doing the same thing. But is it possible to use the spread syntax with the functions so I can do things like this? (it's a very common usage in Vue.js)

export default
    name   : 'CounterBlock'
    methods:
        ...mapActions
            increment : counter.actions.increment
            set       : counter.actions.set
            fetchCount: counter.actions.fetchCount
    computed:
        ...mapGetters
            total: counter.getters.total

It would be so elegant.

---

with the current coffeescript@next:

export default {
    name: 'CounterBlock'
    methods: Object.assign {}, mapActions
            increment : counter.actions.increment,
            set       : counter.actions.set,
            fetchCount: counter.actions.fetchCount
    computed: Object.assign {}, mapGetters
            total: counter.getters.total
}

---

with ES6:

export default {
    name: 'CounterBlock',
    methods: {
        ...mapActions({
            increment : counter.actions.increment,
            set       : counter.actions.set,
            fetchCount: counter.actions.fetchCount
        })
    },
    computed: {
        ...mapGetters ({
            total: counter.getters.total
        })
    },
}

[GeoffreyBooth]

@YamiOdymel You don’t need the { after export default since 1.12.6 or 2.0.0-beta2.

It looks like you’re asking for the destructuring object spread syntax, which is in progress at jashkenas/coffeescript#4493. That PR could use some help if you have time to contribute.

My intention with the proposal for this thread is just about syntax, that ... should behave the same way whether it’s on the right or left of an identifier. This is separate from destructuring object spreads; once we add support for that, and assuming this left/right proposal is also implemented, then destructured object spreads would be possible from either the right or left.

[connec]

I'd rather not have two syntaxes for the same thing. I get the reasons for switching, but if they're so compelling maybe we should just move to leading ...?

[GeoffreyBooth]

If we're not going to have both then we need to keep with the dots on the right. No point in introducing a breaking change for this.

But why not have both? There are plenty of places where we have multiple syntaxes for the same thing.

[edemaine]

I agree that having both would be nice. I'd rather not change all my legacy code, but I see readability advantages to having it first.

[connec]

There are plenty of places where we have multiple syntaxes for the same thing.

Any examples you're thinking of? (I don't doubt there are, but I'm drawing a blank just now 😓)

I guess I wouldn't say that's a great reason for adding more 😛 I could get behind supporting both with a deprecation maybe? What if someone tried to put both? 😱

[edemaine]

Perhaps most compelling examples:

f x
f(x)

not x or y and yes
!x || y && true

this and this.foo
@ && @foo

Other examples:

[1,2,3]
[
  1
  2
  3
]

(if x then f(x)) for x in L
for x in L
  if x
    f(x)

(though these serve somewhat different roles: single-line vs. multi-line)

[GeoffreyBooth]

I was thinking of and versus &&, or versus ||, etc. would be the most relevant examples. Those follow the same principle of idiomatic CoffeeScript versus JS equivalent. We don’t deprecate &&, so I don’t know why we would deprecate either of the dot sides.

I guess I wouldn’t say that’s a great reason for adding more

Yes, though this is more of just a convenience. It is annoying when going back and forth between CS and ES to have to remember to flip the dots. Allowing the dots on the left also lets people write CS that’s closer to the generated JS, for those who care.

What if someone tried to put both?

That is a good point. I guess . . . the same as if they had put the dots on only one side? Or we could just throw an error. It’s a pretty dumb edge case.

[connec]

The boolean operators are a pretty convincing example tbf, and postfix conditionals are a similar case as well I suppose.

I think an error would be better for ... but you're right that if we can get it through the parser that should be easy enough to check. I have no idea how to make the parser accept this, though. Every time I've touched splats in the grammar I've almost immediately hit parser ambiguities 😢

[edemaine]

I'm moderately hopeful that splats at the beginning will be actually be a lot easier to avoid parser ambiguities, because the first token immediately disambiguates the case. (But I'm no expert here.)

[zdenko]

@GeoffreyBooth I added option to place spread syntax on both sides in my last commit to PR #4493.