anchor.diff:  RETURN team
   ----
   
  +However, pattern predicates have a readability advantage in narrow cases.
  +Hence, this proposal retains them while removing their confusing meaning outside boolean expression context.
  +
   == Caveats to this proposal
   
   Subqueries are powerful constructs. As such they can be difficult to understand, and difficult for a query planner to get right.
  
positive.code: 
  == Background
  
  In a way, Cypher already has existential subqueries - pattern predicates checking for the existence of subgraphs.
  This form is helpful, but not exhaustive in the types of subqueries that users want to be able to express.
  
  == Proposal
  
  To make this feature more powerful, this CIP suggests the addition of a new function `exists()`, and a keyword `EXISTS {}`, allowing for two different predicates:
  
  * Property existence checking
  * Subquery existence checking
  
  === Syntax
  
  ----
  expression = <current definition of expression>
             | property exists
             | subquery exists
             | simple subquery exists
             ;
  
  property exists = "exists", "(", expression ")"
                  ;
  
  subquery exists = "EXISTS", "{", read only clause, { read only clause }, "}" ;
  
  simple subquery exists = "EXISTS", "{", simple match, "}" ;
  
  simple match = pattern, { ",", pattern }, [ "WHERE", predicate ] ;
  
  read only clause = match
                   | unwind
                   | with
                   ;
  ----
  
  === Semantics
  
  All forms of `EXISTS {}` accomplish the same task: checking whether a particular pattern exists in the graph.
  They are expressions, and as such must be side-effect free; that is, the subqueries in `EXISTS {}` must not be updating queries.
  All forms of `EXISTS {}` are scalar expressions - they return a single boolean value, and this value is never `null`.
  
  ==== Property exists
  
  In the property checking form, any expression is accepted as the input.
  If the input expression evaluates to `null`, `exists()` will evaluate to `false`. For any other value, it will evaluate to `true`.
  This form of `exists()` is equivalent to checking for `null` using `IS NOT NULL`: `exists(expr)` is equivalent to `expr IS NOT NULL`.
  
  This form is there to make property existence checking idiomatic in Cypher - we do not want the user thinking of missing properties as checking for `null` values.
  
  ==== Subquery exists
  
  When checking for the existence of subqueries, variables and parameters from the outer query are available in the subquery.
  Variables introduced in the subquery are not available on the outside.
  
  For each matching subgraph evaluated with `EXISTS {}`, the result value must be `true` if the subquery finds at least one matching row.
  If no matches are found, `false` should be returned.
  
  The subquery used in `EXISTS {}` has to follow the following rules:
  
   * It has to be a read-only query. Updating the graph as part of a predicate is not allowed.
   * It cannot end in a `RETURN` clause, nor may it contain `UNION`.
   * When `WITH` ends the subquery, it is able to change the cardinality of the subquery.
   In other words, since the `WITH` clause may include `WHERE`, `SKIP`, and/or `LIMIT`, the clause can with these sub-clauses turn a query that produces rows into one that does not.
   * It may use nested `EXISTS {}` predicates.
  
  ==== Simple subquery exists
  
  When the subquery can be described with a single `MATCH-WHERE` clause, the `MATCH` keyword can be omitted, as in example 2A and B.
  The difference between this form and a simple pattern predicate, which is already available, is that this form allows for introducing new variables inside the `EXISTS {}` scope.
  
  === Examples
  
  _Example 1A:_
  
  Return all nodes that have a property named `slogan`.
  [source, cypher]
  ----
  MATCH (actor)
  WHERE exists(actor.slogan)
  RETURN actor
  ----
  
  _Example 2A:_
  
  Find all actors who have acted together with another actor with the same name.
  
  
negative.code: RETURN actor
  ----
  
  == What others do
  
  This is very similar to what SQL does with its `EXISTS` functionality.
  