anchor.diff:  
   The sections below list all types available at the time of acceptance of this CIP.
   
  -==== Core Types
  -
  -The following should available from any implementation of Cypher
  -
  - * `Any`
  +==== Material Core Types
  +
  +The following material (non-nullable) core types should be supported by any implementation of Cypher
  +
  + * `ANY`
    ** Parent of all types
  - * `Number`
  - ** Parent of all numeric types (i.e. `Integer` and `Float`)
  - * `Boolean`
  + * `BOOLEAN`
    ** true and false
  - * `Integer`
  + * `STRING`
  + ** Unicode Strings, i.e. `"Cypher"`, and `‘text’`
  + * `NUMBER`
  + ** Parent of all numeric types (i.e. `INTEGER` and `FLOAT`)
  + * `INTEGER`
    ** Exact numbers without decimals, i.e. -3, 0, 4
  - * `Float`
  + * `FLOAT`
    ** IEEE-754 64-bit floating point numbers
  - * `Map`
  - ** Maps to values of any type, i.e. { name: "Svensson" }. Note that keys are identifiers, not strings.
  - ** This is also the supertype for `Node` and `Relationship`
  - * `List<T>`
  + * `MAP`
  + ** Maps from strings to values of any type, i.e. `{ name: "Svensson" }`. Parent to all property containers, like `NODE` and `RELATIONSHIP`
  + * `LIST OF T`
    ** Lists (ordered sequences with random access) of a given type T
  - ** `List<T1>`` is a subtype of `List<T2>`` if `T1` is a subtype of `T2`. This works since values in Cypher are immutable. Adding an element of type `T` to a `List<S>`` would produce a new list of type `List<R>``, where `R` is the nearest common supertype of `T` and `S`
  - * `Node`
  - ** A self-contained copy of a graph node containing an identity, a set of textual labels and a set of properties
  - * `String`
  - ** Unicode Strings, i.e. `"Cypher"`, and `‘text’`
  - * `Relationship`
  - ** A self-contained copy of a graph relationship that connects two nodes and contains an identity, a textual type and a set of properties
  - * `Path`
  - ** A sequence of alternating nodes and relationships
  -
  -=== Date and Time Types
  -
  -The following should available from any implementation of Cypher in accordance with _CIP2015-08-06 - Date and Time_.
  -
  - * `DateTime`
  + ** `LIST OF T2` is a subtype of `LIST OF T1` if `T2` is a subtype of `T1`. This works since values in Cypher are immutable. Adding an element of type `T` to a `LIST OF S` would produce a new list of type `LIST OF R`, where `R` is the nearest common supertype of `T` and `S`
  + * `NODE`
  + ** A `NODE` is a node in the property graph model with properties, labels, and relationships. A node is an entity and a property container and therefore also a `MAP`.
  + * `RELATIONSHIP`
  + ** A `RELATIONSHIP` is a relationship in the property graph model with properties, relationship type, a start node, and an end node. A relationship is an entity and a property container and therefore also a `MAP`.
  + * `PATH`
  + ** A path from a node `n1` to a node `ni` - corresponding to a walk in the graph from `n1` to `ni` - is a sequence `n1`, `r1`, `n2`, `r2`, ..., `r(i-1)`, `ni` of alternating nodes and relationships such that for 1 <= `j` < `i`, any `rj` contained in the path is incident with `nj` and `n(j+1)`. Additionally, a single node path is a path that starts and ends at the same node `n0` and does not contain any relationships.
  +
  +==== Date and Time Types
  +
  +The following material scalar types should be supported by any implementation of Cypher in accordance with _CIP2015-08-06 - Date and Time_.
  +
  + * `DATETIME`
    ** An instant capturing the date, the time, and the timezone.
  - * `LocalDateTime`
  + * `LOCALDATETIME`
    ** An instant capturing the date and the time, but not the time zone.
  - * `Date`
  + * `DATE`
    ** An instant capturing the date, but not the time, nor the time zone.
  - * `LocalDate`
  - ** An instant capturing the date, but not the time, nor the time zone.
  - * `LocalTime`
  + * `TIME`
  + ** An instant capturing the time of day, and the timezone, but not the date.
  + * `LOCALTIME`
    ** An instant capturing the time of day, but not the date, nor the time zone.
  - * `Duration`
  - ** A temporal amount. This captures the difference in time between two instants. It only captures the amount of time between two instants, it does not capture a start time and end time. A unit capturing the start time and end time would be a _Time Interval_ and is out of scope for this proposal.
  -
  -=== Reserved type names
  + * `DURATION`
  + ** A temporal amount. This captures the difference in time between two instants. It only captures the amount of time between two instants, it does not capture a start time and end time. A duration can be negative.
  +
  +==== Nullable Types
  +
  +The type system also provides a way to track nullability, i.e. a type may express if a given expression may be `NULL` or not. Non-nullable types are all types that do not permit `NULL` as a valid result of evaluating the underlying expression. All types specified above are material (non-nullable) types.
  +
  +Nullable types are all types that permit `NULL` as a valid result of evaluating the underlying expression. Nullable type names are formed by suffixing a material type name with a single question mark. Nullable variants of all material types should be supported by any implementation of Cypher. Note that `NULL` is not a type but a value that inhabits every nullable type.
  +
  +Every nullable type is a supertype of its underlying material type, i.e. `T?` is a supertype of `T`. By extension,
  +if `S` is a supertype of `T`, then `S?` is also a supertype of `T`. As a consequence, `ANY?` is the most generic type available within Cypher and is the supertype of every possible value.
  +
  +==== Reserved type names
   
   In addition to the types above, the following type names are reserved by this CIP for future use:
   
  - * `Bytes`
  - * `Identity`
  - * `Point`
  -
  -=== Nullability
  -
  -The type system also provides a way to track nullability, i.e. a type may express if a given expression may be `NULL` or not:
  -
  -* Non-nullable types are all types that do not permit `NULL` as a valid result of evaluating the underlying expression.
  -  All types specified above are non-nullable types.
  -* Nullable types are all types that permit `NULL` as a valid result of evaluating the underlying expression.
  -  Nullable types are formed by suffixing a non-nullable type with a question mark.
  -  Note that `NULL` is not a type but a value that inhabits every nullable type.
  -
  -As a consequence of this, `ANY?` is the most generic type available within Cypher and is the supertype of every possible value.
  -
  -==== Type Annotation
  + * `BYTES`
  + * `IDENTITY`
  + * `POINT`
  +
  +=== Type Annotation
   
   To specify the type type of a term term in future changes to the Cypher grammar, this CIP proposes using the following syntax
   
  
positive.code: 
  ==== Type Literal Use Outside of Annotations
  
  Type literals could be used in other production rules as well where this is considered more readable by future CIPs (e.g. a type test operator expr IS NUMBER).
  
  === Syntax
  
  
negative.code: === Background and Motivation
  
  Cypher today has an undocumented internal type system.
  In the interest of the http://opencypher.org[openCypher] standardization effort and to enable multiple semantically consistent implementations, it is necessary to specify and document that type system.
  Note that this is primarily an exercise of consolidation rather than exploration of the broadest type system we could support.
  
  Furthermore, in order to support currently ongoing work for allowing users to define _stored procedures_, it has become necessary to specify types explicitly within signatures.
  