Change syntax to use asterisk again

Author: benjie

spec/Appendix B -- Grammar Summary.md

@@ -43,7 +43,7 @@ Token ::
 - FloatValue
 - StringValue
 
-Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | }
+Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | } \*
 
 Name ::
 
@@ -234,6 +234,11 @@ NonNullType :
 - NamedType !
 - ListType !
 
+SemanticNonNullType :
+
+- NamedType \*
+- ListType \*
+
 Directives[Const] : Directive[?Const]+
 
 Directive[Const] : @ Name Arguments[?Const]?

spec/Section 2 -- Language.md

@@ -176,7 +176,7 @@ and is {Ignored}.
 
 ### Punctuators
 
-Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | }
+Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | } \*
 
 GraphQL documents include punctuation in order to describe structure. GraphQL is
 a data description language and not a programming language, therefore GraphQL
@@ -1241,8 +1241,8 @@ NonNullType :
 
 SemanticNonNullType :
 
-- ! NamedType
-- ! ListType
+- NamedType \*
+- ListType \*
 
 GraphQL describes the types of data expected by arguments and variables. Input
 types may be lists of another input type, or a non-null variant of any other

spec/Section 3 -- Type System.md

@@ -1915,8 +1915,8 @@ _unless_ accompanied by a _field error_.
 
 The Semantic-Non-Null type wraps an underlying type, and this type acts
 identically to that wrapped type, with the exception that {null} will result in
-a field error being raised. A leading exclamation mark is used to denote a
-field that uses a Semantic-Non-Null type like this: `name: !String`.
+a field error being raised. A trailing asterisk is used to denote a field that
+uses a Semantic-Non-Null type like this: `name: String*`.
 
 Semantic-Non-Null types are only valid for use as an _output type_; they must
 not be used as an _input type_.
@@ -1955,7 +1955,7 @@ The List and Semantic-Non-Null wrapping types can compose, representing more
 complex types. The rules for result coercion of Lists and Semantic-Non-Null
 types apply in a recursive fashion.
 
-For example if the inner item type of a List is Semantic-Non-Null (e.g. `[!T]`),
+For example if the inner item type of a List is Semantic-Non-Null (e.g. `[T*]`),
 then that List may not contain any {null} items unless associated field errors
 were raised. However if the inner type of a Semantic-Non-Null is a List (e.g.
 `![T]`), then {null} is not accepted without an accompanying field error being
@@ -1965,26 +1965,26 @@ Following are examples of result coercion with various types and values:
 
 | Expected Type | Internal Value  | Coerced Result                              |
 | ------------- | --------------- | ------------------------------------------- |
-| `![Int]`      | `[1, 2, 3]`     | `[1, 2, 3]`                                 |
-| `![Int]`      | `null`          | `null` (With logged coercion error)         |
-| `![Int]`      | `[1, 2, null]`  | `[1, 2, null]`                              |
-| `![Int]`      | `[1, 2, Error]` | `[1, 2, null]` (With logged error)          |
-| `![Int!]`     | `[1, 2, 3]`     | `[1, 2, 3]`                                 |
-| `![Int!]`     | `null`          | `null` (With logged coercion error)         |
-| `![Int!]`     | `[1, 2, null]`  | `null` (With logged coercion error)         |
-| `![Int!]`     | `[1, 2, Error]` | `null` (With logged error)                  |
-| `[!Int]`      | `[1, 2, 3]`     | `[1, 2, 3]`                                 |
-| `[!Int]`      | `null`          | `null`                                      |
-| `[!Int]`      | `[1, 2, null]`  | `[1, 2, null]` (With logged coercion error) |
-| `[!Int]`      | `[1, 2, Error]` | `[1, 2, null]` (With logged error)          |
-| `[!Int]!`     | `[1, 2, 3]`     | `[1, 2, 3]`                                 |
-| `[!Int]!`     | `null`          | Error: Value cannot be null                 |
-| `[!Int]!`     | `[1, 2, null]`  | `[1, 2, null]` (With logged coercion error) |
-| `[!Int]!`     | `[1, 2, Error]` | `[1, 2, null]` (With logged error)          |
-| `![!Int]`     | `[1, 2, 3]`     | `[1, 2, 3]`                                 |
-| `![!Int]`     | `null`          | `null` (With logged coercion error)         |
-| `![!Int]`     | `[1, 2, null]`  | `[1, 2, null]` (With logged coercion error) |
-| `![!Int]`     | `[1, 2, Error]` | `[1, 2, null]` (With logged error)          |
+| `[Int]*`      | `[1, 2, 3]`     | `[1, 2, 3]`                                 |
+| `[Int]*`      | `null`          | `null` (With logged coercion error)         |
+| `[Int]*`      | `[1, 2, null]`  | `[1, 2, null]`                              |
+| `[Int]*`      | `[1, 2, Error]` | `[1, 2, null]` (With logged error)          |
+| `[Int!]*`     | `[1, 2, 3]`     | `[1, 2, 3]`                                 |
+| `[Int!]*`     | `null`          | `null` (With logged coercion error)         |
+| `[Int!]*`     | `[1, 2, null]`  | `null` (With logged coercion error)         |
+| `[Int!]*`     | `[1, 2, Error]` | `null` (With logged error)                  |
+| `[Int*]`      | `[1, 2, 3]`     | `[1, 2, 3]`                                 |
+| `[Int*]`      | `null`          | `null`                                      |
+| `[Int*]`      | `[1, 2, null]`  | `[1, 2, null]` (With logged coercion error) |
+| `[Int*]`      | `[1, 2, Error]` | `[1, 2, null]` (With logged error)          |
+| `[Int*]!`     | `[1, 2, 3]`     | `[1, 2, 3]`                                 |
+| `[Int*]!`     | `null`          | Error: Value cannot be null                 |
+| `[Int*]!`     | `[1, 2, null]`  | `[1, 2, null]` (With logged coercion error) |
+| `[Int*]!`     | `[1, 2, Error]` | `[1, 2, null]` (With logged error)          |
+| `[Int*]*`     | `[1, 2, 3]`     | `[1, 2, 3]`                                 |
+| `[Int*]*`     | `null`          | `null` (With logged coercion error)         |
+| `[Int*]*`     | `[1, 2, null]`  | `[1, 2, null]` (With logged coercion error) |
+| `[Int*]*`     | `[1, 2, Error]` | `[1, 2, null]` (With logged error)          |
 
 ## Directives
 

spec/Section 4 -- Introspection.md

@@ -461,7 +461,7 @@ RecursivelyStripSemanticNonNullTypes(type):
 - Otherwise, return {type}.
 
 Note: This algorithm recursively removes all Semantic-Non-Null type wrappers
-(e.g. `![[!Int]!]` would become `[[Int]!]`). This is to support legacy clients:
+(e.g. `[[Int*]!]*` would become `[[Int]!]`). This is to support legacy clients:
 they can safely treat a Semantic-Non-Null type as the underlying nullable type.
 
 ### The \_\_InputValue Type