I like the idea of generating bindings from capture groups. However, how should it work with the pin operator?

const regex = /(?<left>\d+) \+ (?<right>\d+)/;

match (res) {
  when (^regex) { process(left, right); }
}

If the pin operator works and the res is then compared with the evaluated regex, then left and right is not statically analyzable.

If the pin operator does not work (maybe a runtime error when regex is not a primitive value?), this feature becomes a refactoring hazard because the regex in the WhenClause can not be reused.

We could require that for regex one must manually offers the capture groups:

const regex = /(?<left>\d+) \+ (?<right>\d+)/;

match (res) {
  when (^regex as { groups: { left, right } } ) { process(left, right); }
}

Related: #189

Closing as it works as expected. Thanks for clarifying!

The readme example has

match (arithmeticStr) {
  when (/(?<left>\d+) \+ (?<right>\d+)/) as { groups: { left, right } } { process(left, right); }
  else { ... }
}

where the as { groups: { left, right } } is after when ( ... ). However, I think it should have been

match (arithmeticStr) {
  when (/(?<left>\d+) \+ (?<right>\d+)/ as { groups: { left, right } } )  { process(left, right); }
  else { ... }
}

since it can be extended for nested cases:

match (res) {
  when ({
    input: /(?<left>\d+) \+ (?<right>\d+)/) as { groups: { left, right } },
    direction: 'N' | 'S' | 'W' | 'E',
  }) { process(left, right, direction); }
  else { ... }
}

@mpcsh @ljharb Thanks! I confused as with with in previous examples. https://github.com/tc39/proposal-pattern-matching/issues/188#issuecomment-837783929 works for me.

https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/diff.html#sec-setnfdigitoptions

I suggest we change 15. If hasSd or roundingPriority is not "auto", set needSd to true; else, set needSd to false. to 15. If hasSd is true or roundingPriority is not "auto", then set needSd to true; else, set needSd to false.

I suggest we change 16. If ( not hasSd and notation is not "compact" ) or roundingPriority is not "auto", set needFd to true; else, set needFd to false. to 16. set needFd to false. 17. If hasSd is false and notation is not "compact", then set needFd to true. 18. if roundingPriority is not "auto", then set needFd to true.

        1. Let _func_ be a new built-in function object that, when called, performs the action described by _behaviour_ using the provided arguments as the values of the corresponding parameters specified by _behaviour_. The new function object has internal slots whose names are the elements of _internalSlotsList_, and an [[InitialName]] internal slot.

per discussion.

From @FrankYFTang:

is that true, with your change passing

Symbol(12) [] {} as input to format(), formatToParts() or formatRange() will throw TypeError

I pass everything except BigInt through the ToNumber function:

https://tc39.es/ecma262/#sec-tonumber

This implies that Symbol will trigger a TypeError, as it does now, but not the other ones like [] and {}. This part of the behavior of the spec should be unchanged.

Feel free to reopen if I missed something.

From @FrankYFTang:

Also in the README.md it said

Ranges to infinity are supported, but if either value is NaN, an error is thrown. (#12)

nf.formatRange(500, 0/0); // RangeError

But I have a hard time figuring out where in the spec to throw the NaN now. I don't think ToIntlMathematicalValue will throw if the value is NaN right? https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/diff.html#sec-partitionnumberrangepattern

If x is a non-finite Number or y is is a non-finite Number, throw a RangeError exception.

What is the definition of "non-finite Number" ? Is NaN a "non-finite Number" ? I cannot tell https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/diff.html#sec-partitionnumberpattern surely won't throw if NaN because

If x is NaN, then Let n be an implementation- and locale-dependent (ILD) String value indicating the NaN value.

From @FrankYFTang:

I think this is a bug in your current spec

nf.formatRange(500, 1/0); // "3–∞" https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/diff.html#sec-partitionnumberrangepattern

1.1.21 PartitionNumberRangePattern ( numberFormat, x, y ) ... If x is a non-finite Number or y is is a non-finite Number, throw a RangeError exception.

Should it be an "and" here? and there is a double "is" (editorial issue)

ResolvePluralRange ( pluralRules, n ) should be 3 arguments instead of 2 and should be ResolvePluralRange ( pluralRules, x, y ) https://tc39.es/proposal-intl-numberformat-v3/out/pluralrules/diff.html#sec-resolvepluralrange

As of #28, the README is up to date with the latest consensus. The spec needs to be updated to reflect this.

CC @FrankYFTang @ryzokuken

I believe this is done.

@FrankYFTang LMK if my fix in 8c82d8c satisfies your suggestion.

Currently, https://tc39.es/proposal-intl-numberformat-v3/out/negotiation/diff.html#sec-getoption (notice the section ID should be changed from #sec-getoption to #sec-getstringorbooleanoption for GetStringOrBooleanOption instead of the one for the GetOption) have

1.2.12 GetStringOrBooleanOption ( options, property, values, trueValue, fallback ) The abstract operation GetStringOrBooleanOption extracts the value of the property named property from the provided options object. If the value is undefined, the operation returns fallback. If the value is true, the operation returns trueValue. If the value is falsy, the operation returns false. Otherwise, the operation converts the value to a String, checks whether it is one of a List of allowed values (which must not be undefined), and returns the stringified value.

1. Let value be ? Get(options, property).
2. If value is undefined, then return fallback.
3. If value is true, then return trueValue.
4. Let valueBoolean be ToBoolean(value).
5. If valueBoolean is false, then return valueBoolean.
6. Let value be ? ToString(value).
7. If values does not contain an element equal to value, throw a RangeError exception.
8. Return value.

I suggest we change it to the following to make it more generalized:

1.2.12 GetStringOrBooleanOption ( options, property, values, ^falseValue,^ trueValue, fallback ) The abstract operation GetStringOrBooleanOption extracts the value of the property named property from the provided options object. If the value is undefined, the operation returns fallback. If the value is true, the operation returns trueValue. If the value is false, the operation returns ^falseValue^. Otherwise, the operation converts the value to a String, checks whether it is one of a List of allowed values (which must not be undefined), and returns the stringified value.

1. Let value be ? Get(options, property).
2. If value is undefined, then return fallback.
3. If value is true, then return trueValue.
4. If value is false, then return ^falseValue^.
5. Let value be ? ToString(value).
6. If values does not contain an element equal to value, throw a RangeError exception.
7. Return value.

@sffc

@waldemarhorwat, @erights, and @msaboff have at various times raised questions about the rounding modes and how they apply to this proposal. The intent is that all rounding modes take place in decimal space, after we compute the "shortest string" form of the IEEE double. I'm opening this issue to make sure we specify this clearly in the spec.

My latest spec draft performs all arithmetic using mathematical values (MVs) instead of Numbers, which should resolve this issue.

@syg @anba thoughts?

I agree that it's more readable, but I am unsure if (1) this is a spec convention (2) it even matters.

Maybe we can ask the 262 editors about it?