anchor.diff:   * `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.
  +==== Container Types
  +
  +The following container types should be supported by any implementation of Cypher, both in the given material and
  +a nullable variant:
  +
  +* `LIST OF T`
  +** Lists (ordered sequences with random access) of elements of a given material or nullable type `T`. The syntax for a nullable lists of elements of type `T` is `LIST? OF T`. Note that accessing a list by index always yields a value of type `T` (as opposed to `T?`) since it is considered an error to use an index that is out of bounds.
  +** `LIST OF T2` is a subtype of `LIST OF T1` if `T2` is a subtype of `T1`. This is a valid subtyping rule 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`
  +* `MAP`
  +** Maps from string keys to values of any type, i.e. `{ name: "Svensson" }`. The type of map values is `ANY?` since it is unknown to the type system if a given map contains a certain key or not. Note also that maps do not distinguish between missing keys and keys that map to a `NULL` value. `MAP` is a parent to all property containers, like `NODE` and `RELATIONSHIP`.
  +
  +==== Graph Types
  +
  +The following graph types should be supported by any implementation of Cypher, both in the given material and
  +a nullable variant:
  +
  +* `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 in the model 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 in the model 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.
  +
  +==== Void type
  +
  +This CIP also introduces an additional nullable type called `VOID`. `VOID` is intended to be used as the return type of user defined procedures that execute without producing a result value, i.e. the return type of procedures with side effects. `VOID` is a subtype of `ANY?`. In an expression context, `NULL` is the only value that inhibits the `VOID` type, indicating a missing "real" return value (Note though that Cypher currently does not have any expressions of type `VOID` and this is merely defined here for completeness).
   
   ==== Reserved type names
   
  -In addition to the types above, the following type names are reserved by this CIP for future use:
  +In addition to the types above, the following type names are reserved by this CIP for future use, both in the given material and a nullable variant:
   
    * `BYTES`
    * `IDENTITY`
  
positive.code: *Example*
  `RETURN n.prop IS [NOT] NUMBER`
  
  ==== Union Type Support
  Cypher's current type checker tracks sets of possible types for expressions.
  This could be understood as a form of union typing.
  Union types do not map easily to the type systems of most common target languages (Java, Javascript, ...), they complicate type checking, and are not required for the work on remoting.
  This is why they have not been included in this proposal.
  They could be added instead at a later stage.
  
  
negative.code: 
  [source, ebnf]
  ----
  type annotation = term, "::", type ;
  
  type = nullable core type
       | material core type
       | container type
       ;
  
  nullable core type = material core type, "?"
                     | void type
                     ;
  
  material core type = any type
                     | scalar type
                     | temporal type
                     | graph type
                     ;
  
  any type = "ANY" ;
  
  scalar type = "BOOLEAN"
              | "STRING"
              | "NUMBER"
              | "INTEGER"
              | "FLOAT"
              ;
  
  temporal type = "DATETIME"
                | "LOCALDATETIME"
                | "DATE"
                | "TIME"
  