Linkify "resolved value"

Author: eemeli

spec/errors.md

@@ -258,7 +258,7 @@ An **_<dfn>Unsupported Statement</dfn>_** error occurs when a message includes a
 ### Bad Selector
 
 A **_<dfn>Bad Selector</dfn>_** error occurs when a message includes a _selector_
-with a resolved value which does not support selection.
+with a _resolved value_ which does not support selection.
 
 > For example, attempting to format this message
 > would result in a _Bad Selector_ error:

spec/formatting.md

@@ -16,7 +16,7 @@ Formatting of a _message_ is defined by the following operations:
   with reference to the current _formatting context_.
   This can include multiple steps,
   such as looking up the value of a variable and calling formatting functions.
-  The form of the resolved value is implementation defined and the
+  The form of the _resolved value_ is implementation defined and the
   value might not be evaluated or formatted yet.
   However, it needs to be "formattable", i.e. it contains everything required
   by the eventual formatting.
@@ -47,7 +47,7 @@ Formatting of a _message_ is defined by the following operations:
   if the _message_ contains any _reserved statements_,
   emit an _Unsupported Statement_ error.
 
-- **_<dfn>Formatting</dfn>_** takes the resolved values of the selected _pattern_,
+- **_<dfn>Formatting</dfn>_** takes the _resolved values_ of the selected _pattern_,
   and produces the formatted result for the _message_.
   Depending on the implementation, this result could be a single concatenated string,
   an array of objects, an attributed string, or some other locally appropriate data type.
@@ -96,20 +96,20 @@ This specification allows for the same value to be used for:
 To support this, the _**resolved value**_ of each _expression_
 is an implementation-dependent value that supports some or all of the above use cases.
 
-In a _declaration_, the resolved value of the _expression_ is bound to a _variable_,
+In a _declaration_, the _resolved value_ of the _expression_ is bound to a _variable_,
 which is available for use by later _expressions_.
 Since a _variable_ can be referenced in different ways later,
 implementations SHOULD NOT immediately fully format the value for output.
 
 In an _input-declaration_, the _variable_ operand of the _variable-expression_
 identifies not only the name of the external input value,
-but also the _variable_ to which the resolved value of the _variable-expression_ is bound.
+but also the _variable_ to which the _resolved value_ of the _variable-expression_ is bound.
 
-In _selectors_, the resolved value of an _expression_ is used for _pattern selection_.
+In _selectors_, the _resolved value_ of an _expression_ is used for _pattern selection_.
 
-In a _pattern_, the resolved value of an _expression_ or _markup_ is used in its _formatting_.
+In a _pattern_, the _resolved value_ of an _expression_ or _markup_ is used in its _formatting_.
 
-The form that resolved values take is implementation-dependent,
+The form that _resolved values_ take is implementation-dependent,
 and different implementations MAY choose to perform different levels of resolution.
 
 > While this specification does not require it,
@@ -133,7 +133,7 @@ and different implementations MAY choose to perform different levels of resoluti
 > - An _expression_ could be used as a _selector_ _expression_ if
 >   calling the `selectKeys(keys)` method of its _resolved value_
 >   did not throw an error.
-> - Using a _variable reference_, the resolved value of an _expression_
+> - Using a _variable reference_, the _resolved value_ of an _expression_
 >   could be used as an _operand_ or _option_ value if
 >   calling the `getValue()` method of its _resolved value_ did not throw an error.
 >   In this use case, the `resolvedOptions()` method could also
@@ -155,20 +155,20 @@ _Markup_ is only used in _patterns_.
 
 Depending on the presence or absence of a _variable_ or _literal_ operand
 and a _function_, _private-use annotation_, or _reserved annotation_,
-the resolved value of the _expression_ is determined as follows:
+the _resolved value_ of an _expression_ is determined as follows:
 
 If the _expression_ contains a _reserved annotation_,
 an _Unsupported Expression_ error is emitted and
-a _fallback value_ is used as the resolved value of the _expression_.
+a _fallback value_ is used as the _resolved value_ of the _expression_.
 
 Else, if the _expression_ contains a _private-use annotation_,
-its resolved value is defined according to the implementation's specification.
+its _resolved value_ is defined according to the implementation's specification.
 
 Else, if the _expression_ contains an _annotation_,
-its resolved value is defined by _function resolution_.
+its _resolved value_ is defined by _function resolution_.
 
 Else, if the _expression_ consists of a _variable_,
-its resolved value is defined by _variable resolution_.
+its _resolved value_ is defined by _variable resolution_.
 An implementation MAY perform additional processing
 when resolving the value of an _expression_
 that consists only of a _variable_.
@@ -187,9 +187,9 @@ that consists only of a _variable_.
 > the pattern included the function `:datetime` with some set of default options.
 
 Else, the _expression_ consists of a _literal_.
-Its resolved value is defined by _literal resolution_.
+Its _resolved value_ is defined by _literal resolution_.
 
-> **Note**
+> [!NOTE]
 > This means that a _literal_ value with no _annotation_
 > is always treated as a string.
 > To represent values that are not strings as a _literal_,
@@ -204,13 +204,13 @@ Its resolved value is defined by _literal resolution_.
 
 ### Literal Resolution
 
-The resolved value of a _text_ or a _literal_ is
+The _resolved value_ of a _text_ or a _literal_ contains
 the character sequence of the _text_ or _literal_
 after any character escape has been converted to the escaped character.
 
 When a _literal_ is used as an _operand_
 or on the right-hand side of an _option_,
-the formatting function MUST treat its resolved value the same
+the formatting function MUST treat its _resolved value_ the same
 whether its value was originally _quoted_ or _unquoted_.
 
 > For example,
@@ -222,7 +222,7 @@ The resolution of a _text_ or _literal_ MUST resolve to a string.
 
 To resolve the value of a _variable_,
 its _name_ is used to identify either a local variable or an input variable.
-If a _declaration_ exists for the _variable_, its resolved value is used.
+If a _declaration_ exists for the _variable_, its _resolved value_ is used.
 Otherwise, the _variable_ is an implicit reference to an input value,
 and its value is looked up from the _formatting context_ _input mapping_.
 
@@ -254,11 +254,11 @@ the following steps are taken:
 
    - The current _locale_.
    - The resolved mapping of _options_.
-   - If the _expression_ includes an _operand_, its resolved value.
+   - If the _expression_ includes an _operand_, its _resolved value_.
 
    The form that resolved _operand_ and _option_ values take is implementation-defined.
 
-   A _declaration_ binds the resolved value of an _expression_
+   A _declaration_ binds the _resolved value_ of an _expression_
    to a _variable_.
    Thus, the result of one _function_ is potentially the _operand_
    of another _function_,
@@ -269,7 +269,7 @@ the following steps are taken:
    .local $n1 = {$n :number maximumFractionDigits=3}
    ```
    the value bound to `$n` is the
-   resolved value used as the _operand_
+   _resolved value_ used as the _operand_
    of the `:number` _function_
    when resolving the value of the _variable_ `$n1`.
 
@@ -287,7 +287,7 @@ the following steps are taken:
    for implementations of functions
    such that `U` can be coerced to `T`.
    Implementations of a _function_ SHOULD emit a
-   _Bad Operand_ error for _operands_ whose resolved value
+   _Bad Operand_ error for _operands_ whose _resolved value_
    or type is not supported.
 
 > [!NOTE]
@@ -351,7 +351,7 @@ the following steps are taken:
    _operand_ did not match that expected by the _function_,
    the _function_ might cause a _Bad Operand_ error to be emitted.
   
-   In all failure cases, use the _fallback value_ for the _expression_ as the resolved value.
+   In all failure cases, use the _fallback value_ for the _expression_ as its _resolved value_.
 
 #### Option Resolution
 
@@ -361,7 +361,7 @@ For each _option_:
 
 - Resolve the _identifier_ of the _option_.
 - If the _option_'s right-hand side successfully resolves to a value,
-   bind the _identifier_ of the _option_ to the resolved value in the mapping.
+   bind the _identifier_ of the _option_ to the _resolved value_ in the mapping.
 - Otherwise, bind the _identifier_ of the _option_ to an unresolved value in the mapping.
    Implementations MAY later remove this value before calling the _function_.
    (Note that an _Unresolved Variable_ error will have been emitted.)
@@ -374,7 +374,7 @@ This mapping can be empty.
 
 Unlike _functions_, the resolution of _markup_ is not customizable.
 
-The resolved value of _markup_ includes the following fields:
+The _resolved value_ of _markup_ includes the following fields:
 
 - The type of the markup: open, standalone, or close
 - The _identifier_ of the _markup_
@@ -384,7 +384,7 @@ The resolution of _markup_ MUST always succeed.
 
 ### Fallback Resolution
 
-A **_<dfn>fallback value</dfn>_** is the resolved value for an _expression_ that fails to resolve.
+A **_<dfn>fallback value</dfn>_** is the _resolved value_ for an _expression_ that fails to resolve.
 
 An _expression_ fails to resolve when:
 
@@ -547,17 +547,17 @@ or if this is not available or empty, the U+FFFD REPLACEMENT CHARACTER `�`.
 
 First, resolve the values of each _selector_:
 
-1. Let `res` be a new empty list of resolved values that support selection.
+1. Let `res` be a new empty list of _resolved values_ that support selection.
 1. For each _selector_ `sel`, in source order,
-   1. Let `rv` be the resolved value of `sel`.
+   1. Let `rv` be the _resolved value_ of `sel`.
    1. If selection is supported for `rv`:
       1. Append `rv` as the last element of the list `res`.
    1. Else:
-      1. Let `nomatch` be a resolved value for which selection always fails.
+      1. Let `nomatch` be a _resolved value_ for which selection always fails.
       1. Append `nomatch` as the last element of the list `res`.
       1. Emit a _Bad Selector_ error.
 
-The form of the resolved values is determined by each implementation,
+The form of the _resolved values_ is determined by each implementation,
 along with the manner of determining their support for selection.
 
 ### Resolve Preferences
@@ -571,9 +571,9 @@ Next, using `res`, resolve the preferential order for all message keys:
       1. Let `key` be the `var` key at position `i`.
       1. If `key` is not the catch-all key `'*'`:
          1. Assert that `key` is a _literal_.
-         1. Let `ks` be the resolved value of `key`.
+         1. Let `ks` be the _resolved value_ of `key`.
          1. Append `ks` as the last element of the list `keys`.
-   1. Let `rv` be the resolved value at index `i` of `res`.
+   1. Let `rv` be the _resolved value_ at index `i` of `res`.
    1. Let `matches` be the result of calling the method MatchSelectorKeys(`rv`, `keys`)
    1. Append `matches` as the last element of the list `pref`.
 
@@ -597,7 +597,7 @@ filter the list of _variants_ to the ones that match with some preference:
       1. If `key` is the catch-all key `'*'`:
          1. Continue the inner loop on `pref`.
       1. Assert that `key` is a _literal_.
-      1. Let `ks` be the resolved value of `key`.
+      1. Let `ks` be the _resolved value_ of `key`.
       1. Let `matches` be the list of strings at index `i` of `pref`.
       1. If `matches` includes `ks`:
          1. Continue the inner loop on `pref`.
@@ -623,7 +623,7 @@ Finally, sort the list of variants `vars` and select the _pattern_:
       1. Let `key` be the `tuple` _variant_ key at position `i`.
       1. If `key` is not the catch-all key `'*'`:
          1. Assert that `key` is a _literal_.
-         1. Let `ks` be the resolved value of `key`.
+         1. Let `ks` be the _resolved value_ of `key`.
          1. Let `matchpref` be the integer position of `ks` in `matches`.
       1. Set the `tuple` integer value as `matchpref`.
    1. Set `sortable` to be the result of calling the method `SortVariants(sortable)`.
@@ -769,7 +769,7 @@ one {{Category match for {$count}}}
 After _pattern selection_,
 each _text_ and _placeholder_ part of the selected _pattern_ is resolved and formatted.
 
-Resolved values cannot always be formatted by a given implementation.
+_Resolved values_ cannot always be formatted by a given implementation.
 When such an error occurs during _formatting_,
 an implementation SHOULD emit an appropriate _Message Function Error_ and produce a
 _fallback value_ for the _placeholder_ that produced the error.
@@ -780,8 +780,8 @@ appropriate data type or structure. Some examples of these include:
 
 - A single string concatenated from the parts of the resolved _pattern_.
 - A string with associated attributes for portions of its text.
-- A flat sequence of objects corresponding to each resolved value.
-- A hierarchical structure of objects that group spans of resolved values,
+- A flat sequence of objects corresponding to each _resolved value_.
+- A hierarchical structure of objects that group spans of _resolved values_,
   such as sequences delimited by _markup-open_ and _markup-close_ _placeholders_.
 
 Implementations SHOULD provide _formatting_ result types that match user needs,
@@ -890,7 +890,7 @@ The _Default Bidi Strategy_ is defined as follows:
    These correspond to the message having left-to-right directionality,
    right-to-left directionality, and to the message's directionality not being known.
 1. For each _expression_ `exp` in _pattern_:
-   1. Let `fmt` be the formatted string representation of the resolved value of `exp`.
+   1. Let `fmt` be the formatted string representation of the _resolved value_ of `exp`.
    1. Let `dir` be the directionality of `fmt`,
       one of « `'LTR'`, `'RTL'`, `'unknown'` », with the same meanings as for `msgdir`.
    1. If `dir` is `'LTR'`:

spec/registry.md

@@ -321,7 +321,7 @@ The function `:string` has no options.
 #### Selection
 
 When implementing [`MatchSelectorKeys(resolvedSelector, keys)`](/spec/formatting.md#resolve-preferences)
-where `resolvedSelector` is the resolved value of a _selector_ _expression_
+where `resolvedSelector` is the _resolved value_ of a _selector_ _expression_
 and `keys` is a list of strings,
 the `:string` selector performs as described below.
 
@@ -357,7 +357,7 @@ the `:string` selector performs as described below.
 
 #### Formatting
 
-The `:string` function returns the string value of the resolved value of the _operand_.
+The `:string` function returns the string value of the _resolved value_ of the _operand_.
 
 ## Numeric Value Selection and Formatting
 
@@ -646,7 +646,7 @@ such as the number of fraction, integer, or significant digits.
 
 A "digit size option" is an _option_ value that the _function_ interprets
 as a small integer value greater than or equal to zero.
-Implementations MAY define an upper limit on the resolved value 
+Implementations MAY define an upper limit on the _resolved value_ 
 of a digit size option option consistent with that implementation's practical limits.
 
 In most cases, the value of a digit size option will be a string that
@@ -668,7 +668,7 @@ Number selection has three modes:
   or to ordinal rule categories if there is no explicit match
 
 When implementing [`MatchSelectorKeys(resolvedSelector, keys)`](/spec/formatting.md#resolve-preferences)
-where `resolvedSelector` is the resolved value of a _selector_ _expression_
+where `resolvedSelector` is the _resolved value_ of a _selector_ _expression_
 and `keys` is a list of strings,
 numeric selectors perform as described below.
 
@@ -708,7 +708,7 @@ If the option `select` is set to `ordinal`, selection should be based on CLDR pl
 of type `ordinal`. See [charts](https://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html)
 for examples.
 
-Apply the rules defined by CLDR to the resolved value of the operand and the function options,
+Apply the rules defined by CLDR to the _resolved value_ of the operand and the function options,
 and return the resulting keyword.
 If no rules match, return `other`.
 
@@ -794,7 +794,7 @@ or can use a collection of _field options_ (but not both) to control the formatt
 output.
 
 If both are specified, a _Bad Option_ error MUST be emitted
-and a _fallback value_ used as the resolved value of the _expression_.
+and a _fallback value_ used as the _resolved value_ of the _expression_.
 
 > [!NOTE]
 > The names of _options_ and their _values_ were derived from the

spec/syntax.md

@@ -97,7 +97,7 @@ Attempting to parse a _message_ that is not _valid_ will result in a _Data Model
 
 A **_<dfn>message</dfn>_** is the complete template for a specific message formatting request.
 
-A **_<dfn>variable</dfn>_** is a _name_ associated to a resolved value.
+A **_<dfn>variable</dfn>_** is a _name_ associated with a _resolved value_.
 
 An **_<dfn>external variable</dfn>_** is a _variable_ 
 whose _name_ and initial value are supplied by the caller
@@ -183,7 +183,7 @@ An **_<dfn>input-declaration</dfn>_** binds a _variable_ to an external input va
 The _variable-expression_ of an _input-declaration_
 MAY include an _annotation_ that is applied to the external value.
 
-A **_<dfn>local-declaration</dfn>_** binds a _variable_ to the resolved value of an _expression_.
+A **_<dfn>local-declaration</dfn>_** binds a _variable_ to the _resolved value_ of an _expression_.
 
 For compatibility with later MessageFormat 2 specification versions,
 _declarations_ MAY also include _reserved statements_.

test/README.md

@@ -52,8 +52,8 @@ When resolving a `:test:function` expression,
 its `Input` and `DecimalPlaces` values are determined as follows:
 
 1. Let `DecimalPlaces` be 0.
-1. Let `arg` be the resolved value of the _expression_ _operand_.
-1. If `arg` is the resolved value of an _expression_
+1. Let `arg` be the _resolved value_ of the _expression_ _operand_.
+1. If `arg` is the _resolved value_ of an _expression_
    with a `:test:function`, `:test:select`, or `:test:format` _annotation_
    for which resolution has succeeded, then
    1. Let `Input` be the `Input` value of `arg`.
@@ -63,15 +63,15 @@ its `Input` and `DecimalPlaces` values are determined as follows:
    1. Let `Input` be the numerical value of `arg`.
 1. Else,
    1. Emit "bad-input" _Resolution Error_.
-   1. Use a _fallback value_ as the resolved value of the _expression_.
+   1. Use a _fallback value_ as the _resolved value_ of the _expression_.
       Further steps of this algorithm are not followed.
 1. If the `decimalPlaces` _option_ is set, then
    1. If its value resolves to a numerical integer value 0 or 1
       or their corresponding string representations `'0'` or `'1'`, then
       1. Set `DecimalPlaces` to be the numerical value of the _option_.
    1. Else if its value is not an unresolved value set by _option resolution_,
       1. Emit "bad-option" _Resolution Error_.
-      1. Use a _fallback value_ as the resolved value of the _expression_.
+      1. Use a _fallback value_ as the _resolved value_ of the _expression_.
 
 When `:test:function` is used as a _selector_,
 the behaviour of calling it as the `rv` value of MatchSelectorKeys(`rv`, `keys`)
@@ -87,7 +87,7 @@ depends on its `Input` and `DecimalPlaces` values.
 
 When an _expression_ with a `:test:function` _annotation_ is assigned to a _variable_ by a _declaration_
 and that _variable_ is used as an _option_ value,
-its resolved value is the `Input` value.
+its _resolved value_ is the `Input` value.
 
 When `:test:function` is used as a _formatter_,
 a _placeholder_ resolving to a value with a `:test:function` _expression_