# Informative Comments

This section provides a brief description of each rule listed above in the normative specification.

**templateSlot** = templateReplacementSlot / templateInformationSlot\
\| A template slot is part of a template that is either replaced with a value (i.e. a templateRelacementSlot), or removed after the information it contains is interpreted (i.e. a templateInformationSlot).\
**templateReplacementSlot** = conceptReplacementSlot / expressionReplacementSlot / tokenReplacementSlot / concreteValueReplacementSlot\
\| A template replacement slot is a placeholder whose value can be completed at a subsequent time. A template replacement slot may be either a concept replacement slot, an expression replacement slot, a token replacement slot or a concrete value replacement slot.\
**c\*\*\*\*onceptReplacementSlot = "\[\[" ws "+" ws conceptReplacement \[slotName ws] "]]"**

\| A concept replacement slot starts and ends with double square brackets (i.e. "\[\[ ... ]]"). The first non-whitespace character inside the brackets must always be a plus sign (i.e. "+"), followed by the concept replacement rule and an optional slot name.\
**expressionReplacementSlot = "\[\[" ws "+" ws expressionReplacement \[slotName ws] "]]"**

\| An expression replacement slot starts and ends with double square brackets (i.e. "\[\[ ... ]]"). The first non-whitespace character inside the brackets must always be a plus sign (i.e. "+"), followed by the expression replacement rule and an optional slot name.\
**tokenReplacementSlot = "\[\[" ws "+" ws tokenReplacement \[slotName ws] "]]"**

\| A token replacement slot starts and ends with double square brackets (i.e. "\[\[ ... ]]"). The first non-whitespace character inside the brackets must always be a plus sign (i.e. "+"), followed by the token replacement rule and an optional slot name.\
**concreteValueReplacementSlot = "\[\[" ws "+" ws concreteValueReplacement \[slotName ws] "]]"**

\| A concrete value replacement slot starts and ends with double square brackets (i.e. "\[\[ ... ]]"). The first non-whitespace character inside the brackets must always be a plus sign (i.e. "+"), followed by the concrete value replacement rule and an optional slot name.\
**conceptReplacement** = "id" ws \[ "(" ws slotExpressionConstraint ws ")" ws]\
\| A concept replacement starts with the text "id", and then optionally includes an expression constraint (in round brackets) that restricts the valid values that may replace the slot.\
**expressionReplacement** = \["scg" ws] \["(" ws slotExpressionConstraint ws ")" ws]\
\| An expression replacement starts (optionally) with the text "scg", and then optionally includes an expression constraint (in round brackets) to restrict the valid values that may replace the slot. Note that "scg" is the default type of replacement slot.\
**tokenReplacement** = "tok" ws \[ "(" ws slotTokenSet ws ")" ws]

\| A token replacement starts with the text "tok", and then optionally includes a token set (in round brackets) to restrict the valid values that may replace the slot.\
**concreteValueReplacement = stringReplacement / integerReplacement / decimalReplacement / booleanReplacement**

\| A concrete value replacement may either be a string replacement, an integer replacement, a decimal replacement, or a boolean replacement.\
**stringReplacement** = "str" ws \[ "(" ws slotStringSet ws ")" ws]\
\| A string replacement starts with the text "str", and then optionally includes a string set (in round brackets) to restrict the valid values that may replace the slot.\
**integerReplacement = "int" ws \[ "(" ws slotIntegerSet ws ")" ws]**

\| An integer replacement starts with the text "int", and then optionally includes a integer set (in round brackets) to restrict the valid values that may replace the slot.\
**decimalReplacement** = "dec" ws \[ "(" ws slotDecimalSet ws ")" ws]

\| A decimal replacement starts with the text "dec", and then optionally includes a decimal set (in round brackets) to restrict the valid values that may replace the slot.\
**booleanReplacement = "bool" ws \[ "(" ws slotBooleanSet ws ")" ws]**

\| A boolean replacement starts with the text "bool", and then optionally includes a boolean set (in round brackets) to list the valid values that may replace the slot.\
**slotTokenSet** = slotToken \*(mws slotToken)

\| A slotTokenSet consists of one or more slotTokens separated by mandatory white space (i.e. mws).\
**slotStringSet** = slotStringValue \*(mws slotStringValue)\
\| A slotStringSet consists of one or more slotStringValues separated by mandatory white space (i.e. mws).\
**slotStringValue = QM stringValue QM**

\| A slotStringValue is a stringValue surrounded with double quotation marks.\
**slotIntegerSet** = ( slotIntegerValue / slotIntegerRange) \*(mws (slotIntegerValue / slotIntegerRange))\
\| A slotIntegerSet consists of one or more slotIntegerValues separated by mandatory white space (i.e. mws).\
**slotDecimalSet** = ( slotDecimalValue / slotDecimalRange) \*(mws (slotDecimalValue / slotDecimalRange))

\| A slotDecimalSet consists of one or more slotDecimals separated by mandatory white space (i.e. mws).\
**slotBooleanSe**t\*\* = slotBooleanValue _(mws slotBooleanValue)_\*

\| A slotBooleanSet consists of one or more slotBooleanValues separated by mandatory white space (i.e. mws).\
**slotBooleanValue = booleanValue**

\| A slotBooleanValue is simply a boolean value (i.e. true or false).\
**slotIntegerRange** = ( slotIntegerMinimum to \[ slotIntegerMaximum ] ) / ( to slotIntegerMaximum )

\| A slotIntegerRange includes either a slotIntegerMinimum, a slotIntegerMaximum, or both. The slotIntegerMinimum and slotIntegerMaximum are separated by a 'to' token.\
**slotIntegerMinimum** = \[ exclusiveMinimum ] slotIntegerValue

\| A slotIntegerMinimum consists of a minimum slotIntegerValue. By default the minimum is inclusive (i.e. the minimum value is a valid value in the range). However, the minimum value may be declared to be exclusive (i.e. not a valid value in the range) by preceding it with the exclusiveMinimum symbol (i.e. ">").\
**slotIntegerMaximum** = \[ exclusiveMaximum ] slotIntegerValue

\| A slotIntegerMaximum consists of a maximum slotIntegerValue. By default the maximum is inclusive (i.e. the maximum value is a valid value in the range). However, the maximum value may be declared to be exclusive (i.e. not a valid value in the range) by preceding it with the exclusiveMaximum symbol (i.e. "<").\
**slotIntegerValue = "#" \["-"/"+"] integerValue**

\| A slotIntegerValue consists of a hash symbol followed by an integer value, with an optional "+" or "-" just before the value.\
**slotDecimalRange** = ( slotDecimalMinimum to \[ slotDecimalMaximum ] ) / ( to slotDecimalMaximum )

\| A slotDecimalRange includes either a slotDecimalMinimum, a slotDecimalMaximum, or both. The slotDecimalMinimum and slotDecimalMaximum are separated by a 'to' token.\
**slotDecimalMinimum** = \[ exclusiveMinimum ] slotDecimalValue

\| A slotDecimalMinimum consists of a minimum slotDecimalValue. By default the minimum is inclusive (i.e. the minimum value is a valid value in the range). However, the minimum value may be declared to be exclusive (i.e. not a valid value in the range) by preceding it with the exclusiveMinimum symbol (i.e. ">").\
**slotDecimalMaximum** = \[ exclusiveMaximum ] slotDecimalValue

\| A slotDecimalMaximum consists of a maximum slotDecimalValue. By default the maximum is inclusive (i.e. the maximum value is a valid value in the range). However, the maximum value may be declared to be exclusive (i.e. not a valid value in the range) by preceding it with the exclusiveMaximum symbol (i.e. "<").\
**slotDecimalValue = "#" \["-"/"+"] decimalValue**

\| A slotDecimalValue consists of a hash symbol followed by a decimal value, with an optional "+" or "-" just before the value.\
**exclusiveMinimum** = ">"

\| The exclusiveMinimum symbol is ">". When used before the minimum value, it declares that this value is not a valid part of the range.\
**exclusiveMaximum** = "<"

\| The exclusiveMaximum symbol is "<". When used before the maximum value, it declares that this value is not a valid part of the range.\
**slotName** = "@" (slotStringValue / nonQuoteStringValue)

\| A slotName starts with an at symbol (i.e. "@"), followed by either a quoted or unquoted string.\
**slotToken** = definitionStatus / memberOf / constraintOperator / conjunction / disjunction / exclusion / reverseFlag / expressionComparisonOperator / numericComparisonOperator / stringComparisonOperator / booleanComparisonOperator

\| A slotToken is any token from SNOMED CT Compositional Grammar or the SNOMED CT Expression Constraint Language. This includes the definitionStatus, memberOf, constraintOperator, conjunction, disjunction, exclusion, reverseFlag, expressionComparisonOperator, numericComparisonOperator, stringComparisonOperator and booleanComparisonOperator tokens.\
**nonQuoteStringValue** = \*(%x21 / %x23-26 / %x28-3F / %x41-5A / %x5C / %x5E-7E) ; string with no ws, quotes, at or square brackets

\| A nonQuoteStringValue includes any character that is not whitespace, quotes, or the @ symbol.\
**templateInformationSlot =** "\[\[" ws slotInformation ws "]]"

\| A templateInformationSlot starts and ends with double square brackets (i.e. "\[\[ ... ]]"), and contains slotInformation.\
**slotInformation** = \[cardinality ws] \[slotName ws]

\| A slotInformation consists of either a cardinality, a slotName or both.
