also rename grouped field set -> collected fields map

Author: leebyron

spec/Section 5 -- Validation.md

@@ -259,9 +259,9 @@ query getName {
 - For each subscription operation definition {subscription} in the document:
   - Let {selectionSet} be the top level selection set on {subscription}.
   - Let {variableValues} be the empty set.
-  - Let {groupedFieldSet} be the result of {CollectFields(subscriptionType,
+  - Let {collectedFieldsMap} be the result of {CollectFields(subscriptionType,
     selectionSet, variableValues)}.
-  - {groupedFieldSet} must have exactly one entry, which must not be an
+  - {collectedFieldsMap} must have exactly one entry, which must not be an
     introspection field.
 
 **Explanatory Text**

spec/Section 6 -- Execution.md

@@ -268,10 +268,11 @@ CreateSourceEventStream(subscription, schema, variableValues, initialValue):
 - Let {subscriptionType} be the root Subscription type in {schema}.
 - Assert: {subscriptionType} is an Object type.
 - Let {selectionSet} be the top level selection set in {subscription}.
-- Let {groupedFieldSet} be the result of {CollectFields(subscriptionType,
+- Let {collectedFieldsMap} be the result of {CollectFields(subscriptionType,
   selectionSet, variableValues)}.
-- If {groupedFieldSet} does not have exactly one entry, raise a _request error_.
-- Let {fields} be the value of the first entry in {groupedFieldSet}.
+- If {collectedFieldsMap} does not have exactly one entry, raise a _request
+  error_.
+- Let {fields} be the value of the first entry in {collectedFieldsMap}.
 - Let {fieldName} be the name of the first entry in {fields}. Note: This value
   is unaffected if an alias is used.
 - Let {field} be the first entry in {fields}.
@@ -368,31 +369,32 @@ Executing the root selection set works similarly for queries (parallel),
 mutations (serial), and subscriptions (where it is executed for each event in
 the underlying Source Stream).
 
-First, the _selection set_ is collected into a _grouped field set_ which is then
-executed, returning the resulting {data} and {errors}.
+First, the _selection set_ is collected into a _collected fields map_ which is
+then executed, returning the resulting {data} and {errors}.
 
 ExecuteRootSelectionSet(variableValues, initialValue, objectType, selectionSet,
 executionMode):
 
-- Let {groupedFieldSet} be the result of {CollectFields(objectType,
+- Let {collectedFieldsMap} be the result of {CollectFields(objectType,
   selectionSet, variableValues)}.
-- Let {data} be the result of running {ExecuteCollectedFields(groupedFieldSet,
-  objectType, initialValue, variableValues)} _serially_ if {executionMode} is
-  {"serial"}, otherwise _normally_ (allowing parallelization)).
+- Let {data} be the result of running
+  {ExecuteCollectedFields(collectedFieldsMap, objectType, initialValue,
+  variableValues)} _serially_ if {executionMode} is {"serial"}, otherwise
+  _normally_ (allowing parallelization)).
 - Let {errors} be the list of all _execution error_ raised while executing the
   selection set.
 - Return an unordered map containing {data} and {errors}.
 
 ### Field Collection
 
-Before execution, each _selection set_ is converted to a _grouped field set_ by
-calling {CollectFields()}. This ensures all fields with the same response name,
-including those in referenced fragments, are executed at the same time.
+Before execution, each _selection set_ is converted to a _collected fields map_
+by calling {CollectFields()}. This ensures all fields with the same response
+name, including those in referenced fragments, are executed at the same time.
 
-:: A _grouped field set_ is a map where each entry is a _response name_ and its
-associated _field set_. A _grouped field set_ may be produced from a selection
-set via {CollectFields()} or from the selection sets of a _field set_ via
-{CollectSubfields()}.
+:: A _collected fields map_ is a map where each entry is a _response name_ and
+its associated _field set_. A _collected fields map_ may be produced from a
+selection set via {CollectFields()} or from the selection sets of a _field set_
+via {CollectSubfields()}.
 
 :: A _field set_ is an ordered set of selected fields that share the same
 _response name_ (the field alias if defined, otherwise the field's name).
@@ -404,8 +406,8 @@ Note: The order of field selections in a _field set_ is significant, hence the
 algorithms in this specification model it as an ordered set.
 
 As an example, collecting the fields of this query's selection set would result
-in a grouped field set with two entries, `"a"` and `"b"`, with two instances of
-the field `a` and one of field `b`:
+in a collected fields map with two entries, `"a"` and `"b"`, with two instances
+of the field `a` and one of field `b`:
 
 ```graphql example
 {
@@ -430,7 +432,7 @@ response in a stable and predictable order.
 CollectFields(objectType, selectionSet, variableValues, visitedFragments):
 
 - If {visitedFragments} is not provided, initialize it to the empty set.
-- Initialize {groupedFieldSet} to an empty ordered map of ordered sets.
+- Initialize {collectedFieldsMap} to an empty ordered map of ordered sets.
 - For each {selection} in {selectionSet}:
   - If {selection} provides the directive `@skip`, let {skipDirective} be that
     directive.
@@ -445,8 +447,9 @@ CollectFields(objectType, selectionSet, variableValues, visitedFragments):
   - If {selection} is a {Field}:
     - Let {responseName} be the _response name_ of {selection} (the alias if
       defined, otherwise the field name).
-    - Let {fieldsForResponseName} be the _field set_ in {groupedFieldSet} for
-      {responseName}; if no such set exists, create it as an empty set.
+    - Let {fieldsForResponseName} be the _field set_ value in
+      {collectedFieldsMap} for the key {responseName}; otherwise create it as an
+      empty ordered set.
     - Append {selection} to the {fieldsForResponseName}.
   - If {selection} is a {FragmentSpread}:
     - Let {fragmentSpreadName} be the name of {selection}.
@@ -467,8 +470,9 @@ CollectFields(objectType, selectionSet, variableValues, visitedFragments):
     - For each {fragmentGroup} in {fragmentGroupedFieldSet}:
       - Let {responseName} be the response name shared by all fields in
         {fragmentGroup}.
-      - Let {fieldsForResponseName} be the _field set_ in {groupedFieldSet} for
-        {responseName}; if no such set exists, create it as an empty set.
+      - Let {fieldsForResponseName} be the _field set_ value in
+        {collectedFieldsMap} for the key {responseName}; otherwise create it as
+        an empty ordered set.
       - Append all items in {fragmentGroup} to {fieldsForResponseName}.
   - If {selection} is an {InlineFragment}:
     - Let {fragmentType} be the type condition on {selection}.
@@ -482,10 +486,11 @@ CollectFields(objectType, selectionSet, variableValues, visitedFragments):
     - For each {fragmentGroup} in {fragmentGroupedFieldSet}:
       - Let {responseName} be the response name shared by all fields in
         {fragmentGroup}.
-      - Let {fieldsForResponseName} be the _field set_ in {groupedFieldSet} for
-        {responseName}; if no such set exists, create it as an empty set.
+      - Let {fieldsForResponseName} be the _field set_ value in
+        {collectedFieldsMap} for the key {responseName}; otherwise create it as
+        an empty ordered set.
       - Append all items in {fragmentGroup} to {fieldsForResponseName}.
-- Return {groupedFieldSet}.
+- Return {collectedFieldsMap}.
 
 DoesFragmentTypeApply(objectType, fragmentType):
 
@@ -506,8 +511,8 @@ directives may be applied in either order since they apply commutatively.
 
 In order to execute the sub-selections of a object typed field, all _selection
 sets_ of each field with the same response name of the parent _field set_ are
-merged together into a single _grouped field set_ representing the subfields to
-be executed next.
+merged together into a single _collected fields map_ representing the subfields
+to be executed next.
 
 An example operation illustrating parallel fields with the same name with
 sub-selections.
@@ -536,17 +541,17 @@ phase with the same value.
 
 CollectSubfields(objectType, fields, variableValues):
 
-- Let {groupedFieldSet} be an empty ordered map of ordered sets.
+- Let {collectedFieldsMap} be an empty ordered map of ordered sets.
 - For each {field} in {fields}:
   - Let {fieldSelectionSet} be the selection set of {field}.
   - If {fieldSelectionSet} is null or empty, continue to the next field.
   - Let {fieldGroupedFieldSet} be the result of {CollectFields(objectType,
     fieldSelectionSet, variableValues)}.
   - For each {fieldGroupedFieldSet} as {responseName} and {subfields}:
-    - Let {fieldsForResponseName} be the _field set_ in {groupedFieldSet} for
-      {responseName}; if no such set exists, create it as an empty set.
+    - Let {fieldsForResponseName} be the _field set_ value in {collectedFieldsMap} for
+      the key {responseName}; otherwise create it as an empty ordered set.
     - Add each fields in {subfields} to {fieldsForResponseName}.
-- Return {groupedFieldSet}.
+- Return {collectedFieldsMap}.
 
 Note: All the {fields} passed to {CollectSubfields()} share the same _response
 name_.
@@ -556,19 +561,19 @@ name_.
 The {CollectFields()} and {CollectSubfields()} algorithms transitively collect
 the field selections from a _selection set_ or the associated selection sets of
 a _field set_ respectively, and split them into groups by their _response name_
-to produce a _grouped field set_.
+to produce a _collected fields map_.
 
-To execute a _grouped field set_, the object type being evaluated and the
+To execute a _collected fields map_, the object type being evaluated and the
 runtime value need to be known, as well as the runtime values for any variables.
 
-Each entry in the grouped field set represents a _response name_ which produces
-an entry into a result map.
+Each entry in the collected fields map represents a _response name_ which
+produces an entry into a result map.
 
-ExecuteCollectedFields(groupedFieldSet, objectType, objectValue,
+ExecuteCollectedFields(collectedFieldsMap, objectType, objectValue,
 variableValues):
 
 - Initialize {resultMap} to an empty ordered map.
-- For each {groupedFieldSet} as {responseName} and {fields}:
+- For each {collectedFieldsMap} as {responseName} and {fields}:
   - Let {fieldName} be the name of the first entry in {fields}. Note: This value
     is unaffected if an alias is used.
   - Let {fieldType} be the return type defined for the field {fieldName} of
@@ -603,13 +608,14 @@ about this behavior.
 
 ### Normal and Serial Execution
 
-Normally the executor can execute the entries in a grouped field set in whatever
-order it chooses (normally in parallel). Because the resolution of fields other
-than top-level mutation fields must always be side effect-free and idempotent,
-the execution order must not affect the result, and hence the service has the
-freedom to execute the field entries in whatever order it deems optimal.
+Normally the executor can execute the entries in a collected fields map in
+whatever order it chooses (normally in parallel). Because the resolution of
+fields other than top-level mutation fields must always be side effect-free and
+idempotent, the execution order must not affect the result, and hence the
+service has the freedom to execute the field entries in whatever order it deems
+optimal.
 
-For example, given the following grouped field set to be executed normally:
+For example, given the following collected fields map to be executed normally:
 
 ```graphql example
 {
@@ -629,10 +635,11 @@ before `street`).
 When executing a mutation, the selections in the top most selection set will be
 executed in serial order, starting with the first appearing field textually.
 
-When executing a grouped field set serially, the executor must consider each
-entry from the grouped field set in the order provided in the grouped field set.
-It must determine the corresponding entry in the result map for each item to
-completion before it continues on to the next item in the grouped field set:
+When executing a collected fields map serially, the executor must consider each
+entry from the collected fields map in the order provided in the collected
+fields map. It must determine the corresponding entry in the result map for each
+item to completion before it continues on to the next entry in the collected
+fields map:
 
 For example, given the following mutation operation, the root _selection set_
 must be executed serially:
@@ -701,7 +708,7 @@ A correct executor must generate the following result for that _selection set_:
 
 ## Executing Fields
 
-Each field requested in the grouped field set that is defined on the selected
+Each field from the _collected fields map_ that is defined on the selected
 objectType will result in an entry in the result map. Field execution first
 coerces any provided argument values, then resolves a value for the field, and
 finally completes that value either by recursively executing another selection
@@ -830,9 +837,9 @@ CompleteValue(fieldType, fields, result, variableValues):
     - Let {objectType} be {fieldType}.
   - Otherwise if {fieldType} is an Interface or Union type.
     - Let {objectType} be {ResolveAbstractType(fieldType, result)}.
-  - Let {groupedFieldSet} be the result of calling {CollectSubfields(objectType,
-    fields, variableValues)}.
-  - Return the result of evaluating {ExecuteCollectedFields(groupedFieldSet,
+  - Let {collectedFieldsMap} be the result of calling
+    {CollectSubfields(objectType, fields, variableValues)}.
+  - Return the result of evaluating {ExecuteCollectedFields(collectedFieldsMap,
     objectType, result, variableValues)} _normally_ (allowing for
     parallelization).