Update [intro.defs] and [definitions] to use (roughly) substitutable

phrases as definitions.

In particular, such phrases should not begin with an article. However,
for definitions of adjectives, a noun phrase is still used, because the
English language is not compatible with ISO's requirements.

Author: zygoloid

source/intro.tex

@@ -99,7 +99,7 @@
 
 \indexdefn{access}%
 \definition{access}{defns.access}
-\defncontext{execution-time action} to read or modify the value of an object
+\defncontext{execution-time action} read or modify the value of an object
 
 \indexdefn{argument}%
 \indexdefn{argument!function call expression}
@@ -116,7 +116,7 @@
 \indexdefn{argument}%
 \indexdefn{argument!throw expression}%
 \definition{argument}{defns.argument.throw}
-\defncontext{throw expression} the operand of \tcode{throw}\iref{expr.throw}
+\defncontext{throw expression} operand of \tcode{throw}\iref{expr.throw}
 
 \indexdefn{argument}%
 \indexdefn{argument!template instantiation}%
@@ -129,9 +129,9 @@
 
 \indexdefn{block}%
 \definition{block}{defns.block}
-a thread of execution that blocks is waiting for some condition (other than
-for the implementation to execute its execution steps) to be satisfied before
-it can continue execution past the blocking operation
+wait for some condition (other than for the implementation to execute
+the execution steps of the thread of execution) to be satisfied before
+continuing execution past the blocking operation
 
 \indexdefn{behavior!conditionally-supported}%
 \definition{conditionally-supported}{defns.cond.supp}

source/lib-intro.tex

@@ -134,14 +134,14 @@
 
 \definition{arbitrary-positional stream}{defns.arbitrary.stream}
 \indexdefn{stream!arbitrary-positional}%
-a stream (described in \ref{input.output}) that can seek to any integral position within
+stream (described in \ref{input.output}) that can seek to any integral position within
 the length of the stream\\
 \begin{note} Every arbitrary-positional stream is also a repositional stream. \end{note}
 
 \definition{character}{defns.character}
 \indexdefn{character}%
 \defncontext{\ref{strings}, \ref{localization}, \ref{input.output}, and~\ref{re}}
-any object which,
+object which,
 when treated sequentially,
 can represent text\\
 \begin{note}
@@ -158,9 +158,8 @@
 
 \definition{character container type}{defns.character.container}
 \indexdefn{type!character container}%
-a class or a type used to
-represent a
-\term{character}\\
+class or a type used to
+represent a character\\
 \begin{note}
 It is used for one of the template parameters of the string,
 iostream, and regular expression class templates.
@@ -169,12 +168,12 @@
 
 \definition{comparison function}{defns.comparison}
 \indexdefn{function!comparison}%
-an operator function\iref{over.oper} for any of the equality\iref{expr.eq} or
+operator function\iref{over.oper} for any of the equality\iref{expr.eq} or
 relational\iref{expr.rel} operators
 
 \definition{component}{defns.component}
 \indexdefn{component}%
-a group of library entities directly related as members, parameters, or
+group of library entities directly related as members, parameters, or
 return types\\
 \begin{note}
 For example, the class template
@@ -188,40 +187,40 @@
 
 \definition{constant subexpression}{defns.const.subexpr}
 \indexdefn{constant subexpression}%
-an expression whose evaluation as subexpression of a
+expression whose evaluation as subexpression of a
 \grammarterm{conditional-expression}
 \tcode{CE}\iref{expr.cond} would not prevent \tcode{CE}
 from being a core constant expression\iref{expr.const}
 
 \definition{deadlock}{defns.deadlock}
 \indexdefn{deadlock}%
+situation wherein
 one or more threads are unable to continue execution because each is
 blocked waiting for one or more of the others to satisfy some condition
 
 \definition{default behavior}{defns.default.behavior.impl}
 \indexdefn{behavior!default}%
 \defncontext{implementation}
-any specific behavior provided by the implementation,
+specific behavior provided by the implementation,
 within the scope of the
 \term{required behavior}
 
 \definition{default behavior}{defns.default.behavior.func}
 \indexdefn{behavior!default}%
 \defncontext{specification}
-a description of
+description of
 \term{replacement function}
 and
 \term{handler function}
 semantics
 
 \definition{direct-non-list-initialization}{defns.direct-non-list-init}
 \indexdefn{direct-non-list-initialization}%
-a direct-initialization\iref{dcl.init}
+direct-initialization\iref{dcl.init}
 that is not list-initialization\iref{dcl.init.list}
 
 \definition{handler function}{defns.handler}
 \indexdefn{function!handler}%
-a
 \term{non-reserved function}
 whose definition may be provided by a \Cpp program\\
 \begin{note}
@@ -251,7 +250,7 @@
 
 \definition{modifier function}{defns.modifier}
 \indexdefn{function!modifier}%
-a class member function\iref{class.mfct} other than a constructor,
+class member function\iref{class.mfct} other than a constructor,
 assignment operator, or destructor
 that alters the state of an object of the class
 
@@ -266,15 +265,15 @@
 \definition{NTCTS}{defns.ntcts}
 \indexdefn{NTCTS}%
 \indexdefn{string!null-terminated character type}%
-a sequence of values that have
-\term{character type}
+sequence of values that have
+character type
 that precede the terminating null character type
 value
 \tcode{charT()}
 
 \definition{observer function}{defns.observer}
 \indexdefn{function!observer}%
-a class member function\iref{class.mfct} that accesses the state of an object of the class
+class member function\iref{class.mfct} that accesses the state of an object of the class
 but does not alter that state\\
 \begin{note}
 Observer functions are specified as
@@ -284,15 +283,15 @@
 
 \definition{referenceable type}{defns.referenceable}
 \indexdefn{type!referenceable}%
+type that is either an
 an object type, a function type that does not have cv-qualifiers or a
 \grammarterm{ref-qualifier}, or a reference type
 \begin{note} The term describes a type to which a reference can be created,
 including reference types. \end{note}
 
 \definition{replacement function}{defns.replacement}
 \indexdefn{function!replacement}%
-a
-\term{non-reserved function}
+non-reserved function
 whose definition is provided by a \Cpp program\\
 \begin{note}
 Only one definition for such a function is in effect for the duration of the program's
@@ -302,12 +301,12 @@
 
 \definition{repositional stream}{defns.repositional.stream}
 \indexdefn{stream!repositional}%
-a stream (described in \ref{input.output}) that can seek to a position that was
+stream (described in \ref{input.output}) that can seek to a position that was
 previously encountered
 
 \definition{required behavior}{defns.required.behavior}
 \indexdefn{behavior!required}%
-a description of
+description of
 \term{replacement function}
 and
 \term{handler function}
@@ -322,7 +321,7 @@
 
 \definition{reserved function}{defns.reserved.function}
 \indexdefn{function!reserved}%
-a function, specified as part of the \Cpp standard library, that must be defined by the
+function, specified as part of the \Cpp standard library, that must be defined by the
 implementation\\
 \begin{note}
 If a \Cpp program provides a definition for any reserved function, the results are undefined.%
@@ -332,18 +331,18 @@
 \definition{stable algorithm}{defns.stable}
 \indexdefn{algorithm!stable}%
 \indexdefn{stable algorithm}%
-an algorithm that preserves, as appropriate to the particular algorithm, the order
+algorithm that preserves, as appropriate to the particular algorithm, the order
 of elements\\
 \begin{note} Requirements for stable algorithms are given in~\ref{algorithm.stable}. \end{note}
 
 \definition{traits class}{defns.traits}
 \indexdefn{traits}%
-a class that encapsulates a set of types and functions necessary for class templates and
+class that encapsulates a set of types and functions necessary for class templates and
 function templates to manipulate objects of types for which they are instantiated
 
 \definition{valid but unspecified state}{defns.valid}
 \indexdefn{valid but unspecified state}%
-a value of an object that is not specified except that the object's invariants are
+value of an object that is not specified except that the object's invariants are
 met and operations on the object behave as specified for its type\\
 \begin{example} If an object \tcode{x} of type \tcode{std::vector<int>} is in a
 valid but unspecified state, \tcode{x.empty()} can be called unconditionally,