On 16-09-23 10:24 AM, Felix Kling wrote:
I read these paragraphs over and over again ;) Maybe I just need someone to
explain it to me in different words.
So to apply these to my case:
- `ResolveBinding` is an *"abstract operation"* so it returns a completion
record, whose value is a *"Reference"*, even though completion records are
only supposed to have language values as value (6.2.2) (this still confuses me)
The spec is not consistent in this area. That is, these statements are not
compatible:
* Every call to an abstract operation returns a completion record.
* Every completion record's [[Value]] is a language value or ~empty~.
* Some abstract operations (e.g. ResolveBinding) need to convey values to
the caller that are neither language values nor ~empty~.
(See https://github.com/tc39/ecma262/issues/496 for more examples, and for
possible ways of resolving the inconsistency.)
- In `Let exprRef be the result of evaluating Expression`, `exprRef` is a
Reference, the completion record obtained by *"evaluating Expression"* was
implicitly unwrapped, according to 6.2.2.2: *"Any reference to a Completion
Record value that is in a context that does not explicitly require a complete
Completion Record value is equivalent to an explicit reference to the
`[[Value]] field of the Completion Record value unless the Completion Record
is an abrupt completion."`
Am I right so far?
Not entirely. Here's another way to look at it. If the implicit rule of
6.2.2.2 were made explicit, we would have something like:
Let exprRef be maybe-unwrap(the result of evaluating Expression).
where maybe-unwrap(cr) is a shorthand for:
* cr, if cr is an abrupt completion, or
* cr.[[Value]] if cr is a normal completion.
So (theoretically), for any given execution of this algorithm step, `exprRef`
is either a Reference or an abrupt completion.
In this case, things also work if you ignore 6.2.2.2 (so that `exprRef` is
always a Completion Record), because the subsequent call to GetValue() starts
with a call to ReturnIfAbrupt(), which accomplishes the unwrapping.
Then, does the sentence
The algorithms of this specification often implicitly return Completion
Records whose `[[Type]]` is `normal`.
mean that
1. Algorithms may or may not return a completion record (i.e. some do and some
don't).
2. Algorithms *always* return a completion record, but it's not always
*explicitly* stated in the algorithm.
Statement 2 would result in a similar inconsistency to the one noted above
(just replacing "abstract operation" with "algorithm").
Statement 1 doesn't have that problem, but it still has the problem of fitting
into the world in which the 'abstract operation' inconsistency exists.
-Michael
_______________________________________________
es-discuss mailing list
[email protected]
https://mail.mozilla.org/listinfo/es-discuss
