# Extended dot notation (pick notation) proposal

Jason Orendorff jason.orendorff at gmail.com
Fri Sep 23 21:50:22 UTC 2016

```On Thu, Sep 22, 2016 at 1:14 PM, Bob Myers <rtm at gol.com> wrote:

> In the proposed "pick/destructure into an object" syntax, I would use
> identical destructuring syntax
>
> ```
> obj.{foo: {bar: {qux}}}
> ```
>
> which would turn into `{qux: obj.foo.bar.qux}`.
>
> We are simply using identical destructuring syntax to destructure into an
> object instead of a variable.
>

the proposal; it's perfectly clear on this, and I should have gone back to
it.

OK, I  think I understand the proposal now. A few comments:

1.  The gist says:

> The syntax of the *Assignment Pattern* is identical.

I don't think this is right; I think you want all the right-hand sides
of all the properties in the tree to match PropertyName. In
AssignmentPattern, those can be any LeftHandSideExpression:

{text: f().q[13].name} = obj;

But that wouldn't make sense in pick notation:

obj.{text: f().q[13].name}  // ???

2.  I mentioned scoping earlier. What I mean is, in expressions like

obj.{[p]: p}

the two identifiers `p` mean different things (the first `p` is a
variable name, the second `p` a property name), which is new and subtle.
The same thing happens in `obj.{p = p}`, except the other way round.
Destructuring does just a touch of this in the shorthand case, but I never
found that confusing. This is.

3.  I wonder if this can be made more symmetrical -- as it stands, it
allows you to flatten a complex object:

// from a tree of 3 objects to one
let rect = corners.{
p0: {x: left, y: top},
p1: {x: right, y: bottom}
};

The reverse would be to add structure to a flat object. There's no way
to do that, right?

// turn the 1 object back into a tree of 3?
let corners = rect.{ ??? };

Likewise, it seems you can turn an array into a plain object, but not
the other way around?

let point = coords.[x, y];   // {x: coords[0], y: coords[1]}
let coords = point.{???};   // [point.x, point.y]

Honestly even the examples that do work seem ugly to me. I think pretty
much all the value in the proposal is in the simplest case,
`obj.{identifier, ...}`.

-j
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20160923/6f6ba90a/attachment.html>
```