anchor.diff:  This may be useful (and in fact is used by Scala for example) to control what types are inferred by a type inferencing algorithm during semantic checking.
   
   *Example*
  -`RETURN [1.0, 2.3, 3.0] :: LIST<NUMBER>`
  +`RETURN [1.0, 2.3, 3.0] :: LIST OF NUMBER`
   
   ==== Type cast ("unsafe downcast")
   Beyond type ascription, a type cast asserts a specific type for an expression such that it cannot be verified at compile time if evaluating that expression will always produce a value of the target type.
  
positive.code: === Background and Motivation
  
  Cypher today has an undocumented internal type system.
  In the interest of Cypher standardization 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.
  
negative.code: * Statically typed signatures enable implementations to detect possible type errors at query compilation time.
  * Statically typed signatures also allow us to add support for procedure overloading in the future.
  
  To support these goals, it is necessary to at least define all valid, supported public types, introduce syntax for them as well as syntax for type annotations.
  
  === Overview
  For the purposes of this CIP, a type system is a system of classifying expressions according to what kinds of values they may evaluate to during the execution of a Cypher query. Furthermore, for a given type system, a type annotation enables annotating terms with type expectations for later re-use in determining the type of other expressions (e.g. when determining the type of a function call expression and its arguments based on type annotations used in function signatures). The type system presented in this CIP does not include a specification of a type inferencing and checking algorithm for Cypher queries (out of scope).
  
  Cypher today has a rich type system that unifies Java implementation types into a coherent type hierarchy and an accompanying type checker that supports rich types with https://en.wikipedia.org/wiki/TypeParameter[type parameters] and https://en.wikipedia.org/wiki/Union_type[union types].
  So far it has not been possible to explicitly specify the type of an expression in a query.
  
  This CIP proposes to introduce a well defined type system, syntax for type literals and for type annotations for public
  types. Any implementation may choose to incorporate a set of internal types beyond those specified here. All such
  internal types must map cleanly onto the public type system and should generally not be made visible to end users.
  
  The details of internal types are out of scope for the purposes of this document.
  
  == Proposal
  