anchor.diff:          | LeftRel of leftNode:NodeExpr * rel:RelExpr * rightNode:NodeExpr * isUnique:bool
           | RightRel of leftNode:NodeExpr * rel:RelExpr * rightNode:NodeExpr * isUnique:bool
           | LeftOrRightRel of leftNode:NodeExpr * rel:RelExpr * rightNode:NodeExpr
  -        member x.CypherExpr =
  +        member x.CypherExprForCreate =
               match x with
               | LeftRel(lnode,rel,rnode,_) ->
                   sprintf "%s<-%s-%s" lnode.CypherExpr rel.CypherExpr rnode.CypherExpr
  
positive.code:             | LeftOrRightRel(lnode,rel,rnode) ->
                  sprintf "%s-%s-%s" lnode.CypherExpr rel.CypherExpr rnode.CypherExpr
  
          member x.Create(cypher: ICypherFluentQuery) =
              match x with
              | LeftRel(lnode,rel,rnode,isUnique)
  
negative.code:                     cypher.WithParam(paramName, value)
  
                  if isUnique then
                      cypher.CreateUnique(x.CypherExprForCreate)
                  else
                      cypher.Create(x.CypherExprForCreate)
                  |> tryFold lnode.Parameter withParamFolder
                  |> tryFold rnode.Parameter withParamFolder
                  |> tryFold rel.Parameter withParamFolder
              | _ -> failwith (sprintf "Can create this type of pattern: %A" x)
  
          member x.Merge(cypher: ICypherFluentQuery) =
              match x with
              | LeftRel(_, RelExpr.NamedValue(relName, _, relValue), _, _)
              | RightRel(_, RelExpr.NamedValue(relName, _, relValue), _, _) ->
                  let paramName = RelExpr.GenParamName relName
                  cypher.Merge(x.CypherExprForMerge)
                        .OnCreate()
                        .Set(sprintf "%s = {%s}" relName paramName)
                        .WithParam(paramName, relValue)
              | _ -> failwith (sprintf "Can MERGE this type of pattern: %A" x)
  
      let inline (|IsPredefinedMethod|_|) name (methodInfo: MethodInfo) =
          if methodInfo.Name = name &&
  