anchor.diff:  This calls `myProc` for each input record produced by the preceding `MATCH` clause with a `name` argument obtained by evaluating `n.name` and an `id` argument obtained by evaluating `g.id * 1000 + r.id`.
   Each call results in invoking the concrete procedure implementation which may produce multiple procedure result records with a single result field `last`.
   For each of them, a new record is yielded that contains the original variables already in scope (i.e. `n`, `r`, `g`) as well as the projected result field `last` renamed as `lastLogin`.
  -Omitting the `YIELD` subclause means that no new variables are introduced into the scope.
  +Omitting the `YIELD` subclause means that no new variable bindings are introduced into the scope.
   The procedure call will still affect the cardinality.
   This means that if the procedure returns 5 rows, the incoming row will be repeated 5 times.
   
  
positive.code: 
  - Procedures returning a stream of records: `<procName>(arguments) :: (results)`
  - Arguments and results are written as comma-separated lists of `<name> :: <type>`
  - Deprecated arguments and results are prefixed with the keyword `DEPRECATED` (i.e. written as `DEPRECATED <name> :: <type>`)
  
  An actual implementation may choose to support a notion of default value for procedure arguments.
  For such a case, this CIP proposes that arguments with default values are written as `<name> = <value> :: <type>` (or `DEPRECATED <name> = <value>` respectively).
  
  ==== Procedure implementations
  
  
negative.code: ==== Calling procedures as part of a statement
  
  A procedure is called as part of a statement for each input record produced by a preceding clause.
  Each call is executed by invoking the concrete procedure implementation for the given procedure name using arguments derived by evaluating expressions over the input record and statement parameters.
  
  A call yields one record for each result record returned by invoking the concrete procedure implementation in the underlying graph database or graph processing system.
  
  A yielded record is formed by extending the current input record with new variable bindings.
  These new bindings are derived by evaluating result field projections over a given result record, the current input record, and statement parameters.
  
  Additionally, a call may also filter yielded records by a predicate.
  
  We propose new syntax that introduces a new clause for calling procedures in a Cypher statement.
  This clause for calling procedures starts with the `CALL` keyword.
  Next follows the actual call (i.e. procedure name and arguments in signature order).
  Finally the clause may end with the `YIELD` keyword followed by at least one or more chosen result field projections, and may be terminated by the `WHERE` keyword and a predicate for filtering of yielded records.
  
  A procedure call constitutes either an entire Cypher statement (i.e. is a "standalone call"), or is called as part of a larger statement (i.e. is an "in-statement call").
  In standalone calls, arguments may either be passed implicitly or explicitly.
  