Bergi wrote:
Samuel Hapák schrieb:
The main idea is, that if object defines `Symbol.get` method, it gets
used to access properties of object instead of `[]` when destructuring.
Aw, when I read "extensible destructuring" I had hoped to see an
extension to the destructuring syntax, not to see how semantics of
destructuring objects are changed.
What do you think about extractor functions, like in Scala
<http://www.scala-lang.org/old/node/112>?
Instead of `unapply` or `unapplySeq` methods we'd probably use an
`@@extractor` (`Symbol.extractor`) method or so, allowing us to do
let Map({a, b, c}) = myMap;
let List(a, b, c) = myList;
const Map({author: Map({name: {first, last}, birthdate})}) = book;
which would desugar to
let [{a, b, c}] = Map[Symbol.extractor](myMap);
let [a, b, c] = List[Symbol.extractor](myList);
const [{author: __author}] = Map[Symbol.extractor](book);
const [{name: {first, last}, birthdate}] = Map[Symbol.extractor](__author);
where each extractor method would return an Iterable that is assigned to
the "arguments" of the extractor. (A Proxy to lazily destructure object
literals in there is a good idea, thanks @Claude).
This would even allow us to call functions on destructuring, think about
module imports:
// a.js
export default function factory(options) {
…
return moduleInstance;
}
// b.js
const NoOptions = {
[Symbol.extractor](factory) { return [factory()]; }
};
const WithOptions = (...args) => ({
[Symbol.extractor](factory) { return [factory(...args)]; }
});
import NoOptions(A) from "a";
import WithOptions("config")(A) from "a";
// A === moduleInstance
What do you think about that?
Nice, but as Samuel mentioned, you need to actually transform the data
so it can be fed to stock destructurer.
What I came up is the idea of "reified lvalue", the object that
describes the (complex, destucturing) lvalue used for assignment (for
example as the list of simple expression assignments, internally); and
that such object could be transformed.
Like (very rough examples; just an idea, not the spec):
let a = 4;
outer a <- input
let {a,c:{b}} = foo;
outer a <- input.a
tmp0 <- input.c
outer b <- tmp0.b
let {a,c:Map({b})} = foo;
Map[Symbol.lvalue] gets "outer b <- input.b" and transforms it to
"outer b <- input.get('b')", so the result would be:
outer a <- input.a
tmp0 <- input.c
outer b <- tmp0.get('b')
let Map(a,c:Map({b})) = foo;
Map[Symbol.lvalue] get the above descriptor and transforms it to
outer a <- input.get('a')
tmp0 <- input.get('c')
outer b <- tmp.get('b')
If things like Map[Symbol.lvalue] would be frozen (or just speculatively
supposed not to be mutated), this can as well be done at compile time,
so the resulting code could stay fast.
Bergi
Herby
_______________________________________________
es-discuss mailing list
[email protected]
https://mail.mozilla.org/listinfo/es-discuss