Consider using `-` as the discard token

[hotsphink]

It's the same as underscore, just lifted up a little bit!

I understand that let -= 1 has an existing meaning in sloppy mode, but personally I'm not sold on toplevel discards anyway. (If you really want it, then at least let - = 1 is a syntax error, so at the token level it's the same as saying + and ++ are different tokens so y = x++3 is already forbidden even though it could have meant y = x + +3.)

This doesn't address using-=new Resource. I don't know enough about that proposal to know why that couldn't be using new Resource if you don't want to name it. If you don't want a binding, why have an equals sign?

[pavitra-infocusp]

What about s/void/_/?

[ljharb]

That’s an identifier.

[hotsphink]

Since my initial description ended up complicated by the different options, let me try to spell out this proposal more clearly. I'll also assume that maintaining the existing meaning of using-=new Resource is required.

1. if - is immediately followed by =, it is a -= token (and therefore not interpreted as a discard).
2. - is the discard token.

This allows:

• let [a, -, b] = f()
• let [-, y] = f()
• let {a, b: -, ...c} = f()
• let - = f()
• using - = new Resource
• function f(-, a, -, b) { ... }
• array.map((-, i) => i)
• array.map(- => "XXX") (optional)
• array.map((-) => "XXX")
• let-=f() in sloppy mode (retains its meaning)
• using-=f() (retains its meaning)
• let {[-], g, h} = f() is still an error, fwiw.

let {a, [a]: x} = {'-': 'foo', a: '-'} still binds x to 'foo', for better or worse, but that isn't relevant here. I just wanted to let you know that I hate you all.

I would not be surprised to find that this breaks down in some obvious case, but I'm not seeing it.

[rbuckton]

I think - or any other infix token that combines with = to form a compound operator would just be a source of confusion for existing and new JS devs alike, so I would not support those tokens over void.

[hax]

What about ~? It's not a infix op, so ~= is not valid token.

using ~ = ...
const {x: ~, ...y} = ...
const [x, ~, y] = ...
(~, x) => {}
const Point(~, y) = ...
match (obj) {
  when { x: ~, y: ~ }: ...
}

[rbuckton]

~= has been suggested as an alternative to is in pattern matching, which would make it incompatible with using if we end up needing to go that route.

[ljharb]

~ is an existing bitwise operator, and it'd be very confusing imo to give it a different meaning.