Update terminology

Initial Execution Result > Initial Incremental Stream Result
Execution Update Result > Incremental Stream Update Result

Author: robrichard

spec/Appendix E -- Examples.md

@@ -22,15 +22,16 @@ fragment HomeWorldFragment on Person {
 ```
 
 The response to this request will be an _incremental stream_ consisting of an
-_initial execution result_ followed by one or more _execution update result_.
+_initial incremental stream result_ followed by one or more _incremental stream
+update result_.
 
-The _initial execution result_ has:
+The _initial incremental stream result_ has:
 
 - a {"data"} entry containing the results of the GraphQL operation except for
   the `@defer` and `@stream` selections;
 - a {"pending"} entry containing two _pending result_, one for the `@defer`
   selection and for the the `@stream` selection, indicating that these results
-  will be delivered in a later _execution update result_;
+  will be delivered in a later _incremental stream update result_;
 - a {"hasNext"} entry with the value {true}, indicating that the response is not
   yet complete.
 
@@ -55,9 +56,9 @@ this example.
 
 Depending on the behavior of the backend and the time at which the deferred and
 streamed resources resolve, the stream may produce results in different orders.
-In this example, our first _execution update result_ contains the deferred data
-and the first streamed list item. There is one _completed result_, indicating
-that the deferred data has been completely delivered.
+In this example, our first _incremental stream update result_ contains the
+deferred data and the first streamed list item. There is one _completed result_,
+indicating that the deferred data has been completely delivered.
 
 ```json example
 {
@@ -78,10 +79,11 @@ that the deferred data has been completely delivered.
 }
 ```
 
-The second _execution update result_ contains the final stream results. In this
-example, the underlying iterator does not close synchronously so {"hasNext"} is
-set to {true}. If this iterator did close synchronously, {"hasNext"} would be
-set to {false} and this would be the final execution update result.
+The second _incremental stream update result_ contains the final stream results.
+In this example, the underlying iterator does not close synchronously so
+{"hasNext"} is set to {true}. If this iterator did close synchronously,
+{"hasNext"} would be set to {false} and this would be the final incremental
+stream update result.
 
 ```json example
 {
@@ -95,9 +97,10 @@ set to {false} and this would be the final execution update result.
 }
 ```
 
-The third _execution update result_ contains no incremental data. {"hasNext"}
-set to {false} indicates the end of the _incremental stream_. This execution
-update result is sent when the underlying iterator of the `films` field closes.
+The third _incremental stream update result_ contains no incremental data.
+{"hasNext"} set to {false} indicates the end of the _incremental stream_. This
+incremental stream update result is sent when the underlying iterator of the
+`films` field closes.
 
 ```json example
 {
@@ -134,12 +137,12 @@ fragment NameAndHomeWorldFragment on Person {
 In this example the response is an _incremental stream_ of the following
 results.
 
-The _initial execution result_ contains the results of the `firstName` field.
-Even though it is also present in the `HomeWorldFragment`, it must be returned
-in the initial execution result because it is also defined outside of any
-fragments with the `@defer` directive. Additionally, there are two _pending
-result_ indicating that results for both `@defer`s in the query will be
-delivered in later _execution update result_.
+The _initial incremental stream result_ contains the results of the `firstName`
+field. Even though it is also present in the `HomeWorldFragment`, it must be
+returned in the initial incremental stream result because it is also defined
+outside of any fragments with the `@defer` directive. Additionally, there are
+two _pending result_ indicating that results for both `@defer`s in the query
+will be delivered in later _incremental stream update result_.
 
 ```json example
 {
@@ -156,17 +159,17 @@ delivered in later _execution update result_.
 }
 ```
 
-In this example, the first _execution update result_ contains the deferred data
-from `HomeWorldFragment`. There is one _completed result_, indicating that
-`HomeWorldFragment` has been completely delivered. Because the `homeWorld` field
-is present in two separate `@defer`s, it is separated into its own _incremental
-result_.
+In this example, the first _incremental stream update result_ contains the
+deferred data from `HomeWorldFragment`. There is one _completed result_,
+indicating that `HomeWorldFragment` has been completely delivered. Because the
+`homeWorld` field is present in two separate `@defer`s, it is separated into its
+own _incremental result_.
 
-The second _incremental result_ in this _execution update result_ contains the
-data for the `terrain` field. This _incremental result_ contains a {"subPath"}
-entry to indicate to clients that the _response position_ of this result can be
-determined by concatenating the path from the _pending result_ with id `"0"` and
-the value of this {"subPath"} entry.
+The second _incremental result_ in this _incremental stream update result_
+contains the data for the `terrain` field. This _incremental result_ contains a
+{"subPath"} entry to indicate to clients that the _response position_ of this
+result can be determined by concatenating the path from the _pending result_
+with id `"0"` and the value of this {"subPath"} entry.
 
 ```json example
 {
@@ -186,8 +189,8 @@ the value of this {"subPath"} entry.
 }
 ```
 
-The second _execution update result_ contains the remaining data from the
-`NameAndHomeWorldFragment`. `lastName` is the only remaining field from this
+The second _incremental stream update result_ contains the remaining data from
+the `NameAndHomeWorldFragment`. `lastName` is the only remaining field from this
 selection that has not been delivered in a previous result. With this field now
 delivered, clients are informed that the `NameAndHomeWorldFragment` has been
 completed by the presence of the associated _completed result_. Additionally,

spec/Section 3 -- Type System.md

@@ -2343,8 +2343,9 @@ directive @defer(
 The `@defer` directive may be provided on a fragment spread or inline fragment
 to indicate that execution of the related selection set should be deferred. When
 a request includes the `@defer` directive, it may return an _incremental stream_
-consisting of an _initial execution result_ containing all non-deferred data,
-followed by one or more _execution update result_ including deferred data.
+consisting of an _initial incremental stream result_ containing all non-deferred
+data, followed by one or more _incremental stream update result_ including
+deferred data.
 
 The `@include` and `@skip` directives take precedence over `@defer`.
 
@@ -2389,9 +2390,9 @@ directive @stream(
 
 The `@stream` directive may be provided for a field whose type incorporates a
 `List` type modifier. The directive enables returning a partial list initially,
-followed by additional items in one or more _execution update result_. If the
-field type incorporates multiple `List` type modifiers, only the outermost list
-is streamed.
+followed by additional items in one or more _incremental stream update result_.
+If the field type incorporates multiple `List` type modifiers, only the
+outermost list is streamed.
 
 Note: The mechanism through which items are streamed is implementation-defined
 and may use technologies such as asynchronous iterators.

spec/Section 7 -- Response.md

@@ -49,8 +49,8 @@ stream of _execution result_.
 :: A GraphQL request returns an _incremental stream_ when the GraphQL service
 has deferred or streamed data as a result of the `@defer` or `@stream`
 directives. When the result of the GraphQL operation is an incremental stream,
-the first value will be an _initial execution result_, followed by one or more
-_execution update result_.
+the first value will be an _initial incremental stream result_, followed by one
+or more _incremental stream update result_.
 
 ### Request Error Result
 
@@ -79,58 +79,60 @@ The _request error result_ map must not contain an entry with key {"data"}.
 The _request error result_ map may also contain an entry with key `extensions`.
 The value of this entry is described in the "Extensions" section.
 
-### Initial Execution Result
+### Initial Incremental Stream Result
 
-:: An _initial execution result_ is the first value yielded by an _incremental
-stream_.
+:: An _initial incremental stream result_ is the first value yielded by an
+_incremental stream_.
 
-An _initial execution result_ must be a map.
+An _initial incremental stream result_ must be a map.
 
-The _initial execution result_ must contain an entry with key {"data"}, and may
-contain entries with keys {"errors"} and {"extensions"}. The value of these
-entries are defined in the same way as an _execution result_ as described in the
-"Data", "Errors", and "Extensions" sections below.
+The _initial incremental stream result_ must contain an entry with key {"data"},
+and may contain entries with keys {"errors"} and {"extensions"}. The value of
+these entries are defined in the same way as an _execution result_ as described
+in the "Data", "Errors", and "Extensions" sections below.
 
-The _initial execution result_ must contain an entry with the key {"hasNext"}.
-The value of this entry must be {true}.
+The _initial incremental stream result_ must contain an entry with the key
+{"hasNext"}. The value of this entry must be {true}.
 
-The _initial execution result_ may contain an entry with the key {"pending"}.
-The value of this entry must be a non-empty list of _pending result_. Each
-_pending result_ must be a map as described in the "Pending Result" section
-below.
+The _initial incremental stream result_ may contain an entry with the key
+{"pending"}. The value of this entry must be a non-empty list of _pending
+result_. Each _pending result_ must be a map as described in the "Pending
+Result" section below.
 
-The _initial execution result_ may contain an entry with they key
+The _initial incremental stream result_ may contain an entry with they key
 {"incremental"}. The value of this entry must be a non-empty list of
 _incremental result_. Each _incremental result_ must be a map as described in
 the "Incremental Result" section below.
 
-The _initial execution result_ may contain an entry with they key {"completed"}.
-The value of this entry must be a non-empty list of _completed result_. Each
-_completed result_ must be a map as described in the "Completed Result" section
-below.
+The _initial incremental stream result_ may contain an entry with they key
+{"completed"}. The value of this entry must be a non-empty list of _completed
+result_. Each _completed result_ must be a map as described in the "Completed
+Result" section below.
 
-### Execution Update Result
+### Incremental Stream Update Result
 
-:: An _execution update result_ is the value yielded by an _incremental stream_
-for all values except the first.
+:: An _incremental stream update result_ is the value yielded by an _incremental
+stream_ for all values except the first.
 
-An _execution update result_ must be a map.
+An _incremental stream update result_ must be a map.
 
-Unlike the _initial execution result_, an _execution update result_ must not
-contain entries with keys {"data"} or {"errors"}.
+Unlike the _initial incremental stream result_, an _incremental stream update
+result_ must not contain entries with keys {"data"} or {"errors"}.
 
-An _execution update result_ may contain an entry with the key {"extensions"}.
-The value of this entry is described in the "Extensions" section.
+An _incremental stream update result_ may contain an entry with the key
+{"extensions"}. The value of this entry is described in the "Extensions"
+section.
 
-An _execution update result_ must contain an entry with the key {"hasNext"}. The
-value of this entry must be {true} for all but the last response in the
-_incremental stream_. The value of this entry must be {false} for the last
-response of the incremental stream.
+An _incremental stream update result_ must contain an entry with the key
+{"hasNext"}. The value of this entry must be {true} for all but the last
+response in the _incremental stream_. The value of this entry must be {false}
+for the last response of the incremental stream.
 
-The _initial execution result_ may contain entries with keys {"pending"},
-{"incremental"}, and/or {"completed"}. The value of these entries are defined in
-the same way as an _initial execution result_ as described in the "Pending
-Result", "Incremental Result", and "Completed Result" sections below.
+The _initial incremental stream result_ may contain entries with keys
+{"pending"}, {"incremental"}, and/or {"completed"}. The value of these entries
+are defined in the same way as an _initial incremental stream result_ as
+described in the "Pending Result", "Incremental Result", and "Completed Result"
+sections below.
 
 ### Response Position
 
@@ -389,10 +391,10 @@ discouraged.
 ### Extensions
 
 The {"extensions"} entry in an _execution result_, _request error result_,
-_initial execution result_, or an _execution update result_, if set, must have a
-map as its value. This entry is reserved for implementers to extend the protocol
-however they see fit, and hence there are no additional restrictions on its
-contents.
+_initial incremental stream result_, or an _incremental stream update result_,
+if set, must have a map as its value. This entry is reserved for implementers to
+extend the protocol however they see fit, and hence there are no additional
+restrictions on its contents.
 
 ### Pending Result
 
@@ -431,16 +433,16 @@ for different deferred fragments at the same _response position_.
 If a pending result is not returned for a `@defer` or `@stream` directive,
 clients must assume that the GraphQL service chose not to incrementally deliver
 this data, and the data can be found either in the {"data"} entry in the
-_initial execution result_, or one of the prior _execution update result_ in the
-_incremental stream_.
+_initial incremental stream result_, or one of the prior _incremental stream
+update result_ in the _incremental stream_.
 
 :: The _associated pending result_ is a specific _pending result_ associated
 with any given _incremental result_ or _completed result_. The associated
 pending result can be determined by finding the pending result where the value
 of its {"id"} entry is the same value of the {"id"} entry of the given
 incremental result or completed result. The associated pending result must
-appear in the _incremental stream_, in the same or prior _initial execution
-result_ or _execution update result_ as the given incremental result or
+appear in the _incremental stream_, in the same or prior _initial incremental
+stream result_ or _execution update result_ as the given incremental result or
 completed result.
 
 ### Incremental Result
@@ -531,8 +533,8 @@ errors. The value of this entry is described in the "Errors" section.
 :: A _completed result_ is used to communicate that the GraphQL service has
 completed the incremental delivery of the data associated with the _associated
 pending result_. The corresponding data must have been completed in the same
-_initial execution result_ or _execution update result_ in which this completed
-result appears.
+_initial incremental stream result_ or _incremental stream update result_ in
+which this completed result appears.
 
 **Completed Result Format**