-- | A Cypher model based on the OpenCypher specification (version 23), copyright Neo Technology, available at:
-- |   https://opencypher.org/resources/

module Hydra.Langs.Cypher.OpenCypher where

import qualified Hydra.Core as Core
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

data Query = 
  QueryRegular RegularQuery |
  QueryStandalone StandaloneCall
  deriving (Query -> Query -> Bool
(Query -> Query -> Bool) -> (Query -> Query -> Bool) -> Eq Query
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Query -> Query -> Bool
== :: Query -> Query -> Bool
$c/= :: Query -> Query -> Bool
/= :: Query -> Query -> Bool
Eq, Eq Query
Eq Query =>
(Query -> Query -> Ordering)
-> (Query -> Query -> Bool)
-> (Query -> Query -> Bool)
-> (Query -> Query -> Bool)
-> (Query -> Query -> Bool)
-> (Query -> Query -> Query)
-> (Query -> Query -> Query)
-> Ord Query
Query -> Query -> Bool
Query -> Query -> Ordering
Query -> Query -> Query
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Query -> Query -> Ordering
compare :: Query -> Query -> Ordering
$c< :: Query -> Query -> Bool
< :: Query -> Query -> Bool
$c<= :: Query -> Query -> Bool
<= :: Query -> Query -> Bool
$c> :: Query -> Query -> Bool
> :: Query -> Query -> Bool
$c>= :: Query -> Query -> Bool
>= :: Query -> Query -> Bool
$cmax :: Query -> Query -> Query
max :: Query -> Query -> Query
$cmin :: Query -> Query -> Query
min :: Query -> Query -> Query
Ord, ReadPrec [Query]
ReadPrec Query
Int -> ReadS Query
ReadS [Query]
(Int -> ReadS Query)
-> ReadS [Query]
-> ReadPrec Query
-> ReadPrec [Query]
-> Read Query
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Query
readsPrec :: Int -> ReadS Query
$creadList :: ReadS [Query]
readList :: ReadS [Query]
$creadPrec :: ReadPrec Query
readPrec :: ReadPrec Query
$creadListPrec :: ReadPrec [Query]
readListPrec :: ReadPrec [Query]
Read, Int -> Query -> ShowS
[Query] -> ShowS
Query -> String
(Int -> Query -> ShowS)
-> (Query -> String) -> ([Query] -> ShowS) -> Show Query
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Query -> ShowS
showsPrec :: Int -> Query -> ShowS
$cshow :: Query -> String
show :: Query -> String
$cshowList :: [Query] -> ShowS
showList :: [Query] -> ShowS
Show)

_Query :: Name
_Query = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Query")

_Query_regular :: Name
_Query_regular = (String -> Name
Core.Name String
"regular")

_Query_standalone :: Name
_Query_standalone = (String -> Name
Core.Name String
"standalone")

data RegularQuery = 
  RegularQuery {
    RegularQuery -> SingleQuery
regularQueryHead :: SingleQuery,
    RegularQuery -> [Union]
regularQueryRest :: [Union]}
  deriving (RegularQuery -> RegularQuery -> Bool
(RegularQuery -> RegularQuery -> Bool)
-> (RegularQuery -> RegularQuery -> Bool) -> Eq RegularQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RegularQuery -> RegularQuery -> Bool
== :: RegularQuery -> RegularQuery -> Bool
$c/= :: RegularQuery -> RegularQuery -> Bool
/= :: RegularQuery -> RegularQuery -> Bool
Eq, Eq RegularQuery
Eq RegularQuery =>
(RegularQuery -> RegularQuery -> Ordering)
-> (RegularQuery -> RegularQuery -> Bool)
-> (RegularQuery -> RegularQuery -> Bool)
-> (RegularQuery -> RegularQuery -> Bool)
-> (RegularQuery -> RegularQuery -> Bool)
-> (RegularQuery -> RegularQuery -> RegularQuery)
-> (RegularQuery -> RegularQuery -> RegularQuery)
-> Ord RegularQuery
RegularQuery -> RegularQuery -> Bool
RegularQuery -> RegularQuery -> Ordering
RegularQuery -> RegularQuery -> RegularQuery
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RegularQuery -> RegularQuery -> Ordering
compare :: RegularQuery -> RegularQuery -> Ordering
$c< :: RegularQuery -> RegularQuery -> Bool
< :: RegularQuery -> RegularQuery -> Bool
$c<= :: RegularQuery -> RegularQuery -> Bool
<= :: RegularQuery -> RegularQuery -> Bool
$c> :: RegularQuery -> RegularQuery -> Bool
> :: RegularQuery -> RegularQuery -> Bool
$c>= :: RegularQuery -> RegularQuery -> Bool
>= :: RegularQuery -> RegularQuery -> Bool
$cmax :: RegularQuery -> RegularQuery -> RegularQuery
max :: RegularQuery -> RegularQuery -> RegularQuery
$cmin :: RegularQuery -> RegularQuery -> RegularQuery
min :: RegularQuery -> RegularQuery -> RegularQuery
Ord, ReadPrec [RegularQuery]
ReadPrec RegularQuery
Int -> ReadS RegularQuery
ReadS [RegularQuery]
(Int -> ReadS RegularQuery)
-> ReadS [RegularQuery]
-> ReadPrec RegularQuery
-> ReadPrec [RegularQuery]
-> Read RegularQuery
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RegularQuery
readsPrec :: Int -> ReadS RegularQuery
$creadList :: ReadS [RegularQuery]
readList :: ReadS [RegularQuery]
$creadPrec :: ReadPrec RegularQuery
readPrec :: ReadPrec RegularQuery
$creadListPrec :: ReadPrec [RegularQuery]
readListPrec :: ReadPrec [RegularQuery]
Read, Int -> RegularQuery -> ShowS
[RegularQuery] -> ShowS
RegularQuery -> String
(Int -> RegularQuery -> ShowS)
-> (RegularQuery -> String)
-> ([RegularQuery] -> ShowS)
-> Show RegularQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RegularQuery -> ShowS
showsPrec :: Int -> RegularQuery -> ShowS
$cshow :: RegularQuery -> String
show :: RegularQuery -> String
$cshowList :: [RegularQuery] -> ShowS
showList :: [RegularQuery] -> ShowS
Show)

_RegularQuery :: Name
_RegularQuery = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.RegularQuery")

_RegularQuery_head :: Name
_RegularQuery_head = (String -> Name
Core.Name String
"head")

_RegularQuery_rest :: Name
_RegularQuery_rest = (String -> Name
Core.Name String
"rest")

data Union = 
  Union {
    Union -> Bool
unionAll :: Bool,
    Union -> SingleQuery
unionQuery :: SingleQuery}
  deriving (Union -> Union -> Bool
(Union -> Union -> Bool) -> (Union -> Union -> Bool) -> Eq Union
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Union -> Union -> Bool
== :: Union -> Union -> Bool
$c/= :: Union -> Union -> Bool
/= :: Union -> Union -> Bool
Eq, Eq Union
Eq Union =>
(Union -> Union -> Ordering)
-> (Union -> Union -> Bool)
-> (Union -> Union -> Bool)
-> (Union -> Union -> Bool)
-> (Union -> Union -> Bool)
-> (Union -> Union -> Union)
-> (Union -> Union -> Union)
-> Ord Union
Union -> Union -> Bool
Union -> Union -> Ordering
Union -> Union -> Union
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Union -> Union -> Ordering
compare :: Union -> Union -> Ordering
$c< :: Union -> Union -> Bool
< :: Union -> Union -> Bool
$c<= :: Union -> Union -> Bool
<= :: Union -> Union -> Bool
$c> :: Union -> Union -> Bool
> :: Union -> Union -> Bool
$c>= :: Union -> Union -> Bool
>= :: Union -> Union -> Bool
$cmax :: Union -> Union -> Union
max :: Union -> Union -> Union
$cmin :: Union -> Union -> Union
min :: Union -> Union -> Union
Ord, ReadPrec [Union]
ReadPrec Union
Int -> ReadS Union
ReadS [Union]
(Int -> ReadS Union)
-> ReadS [Union]
-> ReadPrec Union
-> ReadPrec [Union]
-> Read Union
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Union
readsPrec :: Int -> ReadS Union
$creadList :: ReadS [Union]
readList :: ReadS [Union]
$creadPrec :: ReadPrec Union
readPrec :: ReadPrec Union
$creadListPrec :: ReadPrec [Union]
readListPrec :: ReadPrec [Union]
Read, Int -> Union -> ShowS
[Union] -> ShowS
Union -> String
(Int -> Union -> ShowS)
-> (Union -> String) -> ([Union] -> ShowS) -> Show Union
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Union -> ShowS
showsPrec :: Int -> Union -> ShowS
$cshow :: Union -> String
show :: Union -> String
$cshowList :: [Union] -> ShowS
showList :: [Union] -> ShowS
Show)

_Union :: Name
_Union = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Union")

_Union_all :: Name
_Union_all = (String -> Name
Core.Name String
"all")

_Union_query :: Name
_Union_query = (String -> Name
Core.Name String
"query")

data SingleQuery = 
  SingleQuerySinglePart SinglePartQuery |
  SingleQueryMultiPart MultiPartQuery
  deriving (SingleQuery -> SingleQuery -> Bool
(SingleQuery -> SingleQuery -> Bool)
-> (SingleQuery -> SingleQuery -> Bool) -> Eq SingleQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SingleQuery -> SingleQuery -> Bool
== :: SingleQuery -> SingleQuery -> Bool
$c/= :: SingleQuery -> SingleQuery -> Bool
/= :: SingleQuery -> SingleQuery -> Bool
Eq, Eq SingleQuery
Eq SingleQuery =>
(SingleQuery -> SingleQuery -> Ordering)
-> (SingleQuery -> SingleQuery -> Bool)
-> (SingleQuery -> SingleQuery -> Bool)
-> (SingleQuery -> SingleQuery -> Bool)
-> (SingleQuery -> SingleQuery -> Bool)
-> (SingleQuery -> SingleQuery -> SingleQuery)
-> (SingleQuery -> SingleQuery -> SingleQuery)
-> Ord SingleQuery
SingleQuery -> SingleQuery -> Bool
SingleQuery -> SingleQuery -> Ordering
SingleQuery -> SingleQuery -> SingleQuery
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SingleQuery -> SingleQuery -> Ordering
compare :: SingleQuery -> SingleQuery -> Ordering
$c< :: SingleQuery -> SingleQuery -> Bool
< :: SingleQuery -> SingleQuery -> Bool
$c<= :: SingleQuery -> SingleQuery -> Bool
<= :: SingleQuery -> SingleQuery -> Bool
$c> :: SingleQuery -> SingleQuery -> Bool
> :: SingleQuery -> SingleQuery -> Bool
$c>= :: SingleQuery -> SingleQuery -> Bool
>= :: SingleQuery -> SingleQuery -> Bool
$cmax :: SingleQuery -> SingleQuery -> SingleQuery
max :: SingleQuery -> SingleQuery -> SingleQuery
$cmin :: SingleQuery -> SingleQuery -> SingleQuery
min :: SingleQuery -> SingleQuery -> SingleQuery
Ord, ReadPrec [SingleQuery]
ReadPrec SingleQuery
Int -> ReadS SingleQuery
ReadS [SingleQuery]
(Int -> ReadS SingleQuery)
-> ReadS [SingleQuery]
-> ReadPrec SingleQuery
-> ReadPrec [SingleQuery]
-> Read SingleQuery
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SingleQuery
readsPrec :: Int -> ReadS SingleQuery
$creadList :: ReadS [SingleQuery]
readList :: ReadS [SingleQuery]
$creadPrec :: ReadPrec SingleQuery
readPrec :: ReadPrec SingleQuery
$creadListPrec :: ReadPrec [SingleQuery]
readListPrec :: ReadPrec [SingleQuery]
Read, Int -> SingleQuery -> ShowS
[SingleQuery] -> ShowS
SingleQuery -> String
(Int -> SingleQuery -> ShowS)
-> (SingleQuery -> String)
-> ([SingleQuery] -> ShowS)
-> Show SingleQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SingleQuery -> ShowS
showsPrec :: Int -> SingleQuery -> ShowS
$cshow :: SingleQuery -> String
show :: SingleQuery -> String
$cshowList :: [SingleQuery] -> ShowS
showList :: [SingleQuery] -> ShowS
Show)

_SingleQuery :: Name
_SingleQuery = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.SingleQuery")

_SingleQuery_singlePart :: Name
_SingleQuery_singlePart = (String -> Name
Core.Name String
"singlePart")

_SingleQuery_multiPart :: Name
_SingleQuery_multiPart = (String -> Name
Core.Name String
"multiPart")

data SinglePartQuery = 
  SinglePartQuery {
    SinglePartQuery -> [ReadingClause]
singlePartQueryReading :: [ReadingClause],
    SinglePartQuery -> [UpdatingClause]
singlePartQueryUpdating :: [UpdatingClause],
    SinglePartQuery -> Maybe Return
singlePartQueryReturn :: (Maybe Return)}
  deriving (SinglePartQuery -> SinglePartQuery -> Bool
(SinglePartQuery -> SinglePartQuery -> Bool)
-> (SinglePartQuery -> SinglePartQuery -> Bool)
-> Eq SinglePartQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SinglePartQuery -> SinglePartQuery -> Bool
== :: SinglePartQuery -> SinglePartQuery -> Bool
$c/= :: SinglePartQuery -> SinglePartQuery -> Bool
/= :: SinglePartQuery -> SinglePartQuery -> Bool
Eq, Eq SinglePartQuery
Eq SinglePartQuery =>
(SinglePartQuery -> SinglePartQuery -> Ordering)
-> (SinglePartQuery -> SinglePartQuery -> Bool)
-> (SinglePartQuery -> SinglePartQuery -> Bool)
-> (SinglePartQuery -> SinglePartQuery -> Bool)
-> (SinglePartQuery -> SinglePartQuery -> Bool)
-> (SinglePartQuery -> SinglePartQuery -> SinglePartQuery)
-> (SinglePartQuery -> SinglePartQuery -> SinglePartQuery)
-> Ord SinglePartQuery
SinglePartQuery -> SinglePartQuery -> Bool
SinglePartQuery -> SinglePartQuery -> Ordering
SinglePartQuery -> SinglePartQuery -> SinglePartQuery
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SinglePartQuery -> SinglePartQuery -> Ordering
compare :: SinglePartQuery -> SinglePartQuery -> Ordering
$c< :: SinglePartQuery -> SinglePartQuery -> Bool
< :: SinglePartQuery -> SinglePartQuery -> Bool
$c<= :: SinglePartQuery -> SinglePartQuery -> Bool
<= :: SinglePartQuery -> SinglePartQuery -> Bool
$c> :: SinglePartQuery -> SinglePartQuery -> Bool
> :: SinglePartQuery -> SinglePartQuery -> Bool
$c>= :: SinglePartQuery -> SinglePartQuery -> Bool
>= :: SinglePartQuery -> SinglePartQuery -> Bool
$cmax :: SinglePartQuery -> SinglePartQuery -> SinglePartQuery
max :: SinglePartQuery -> SinglePartQuery -> SinglePartQuery
$cmin :: SinglePartQuery -> SinglePartQuery -> SinglePartQuery
min :: SinglePartQuery -> SinglePartQuery -> SinglePartQuery
Ord, ReadPrec [SinglePartQuery]
ReadPrec SinglePartQuery
Int -> ReadS SinglePartQuery
ReadS [SinglePartQuery]
(Int -> ReadS SinglePartQuery)
-> ReadS [SinglePartQuery]
-> ReadPrec SinglePartQuery
-> ReadPrec [SinglePartQuery]
-> Read SinglePartQuery
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SinglePartQuery
readsPrec :: Int -> ReadS SinglePartQuery
$creadList :: ReadS [SinglePartQuery]
readList :: ReadS [SinglePartQuery]
$creadPrec :: ReadPrec SinglePartQuery
readPrec :: ReadPrec SinglePartQuery
$creadListPrec :: ReadPrec [SinglePartQuery]
readListPrec :: ReadPrec [SinglePartQuery]
Read, Int -> SinglePartQuery -> ShowS
[SinglePartQuery] -> ShowS
SinglePartQuery -> String
(Int -> SinglePartQuery -> ShowS)
-> (SinglePartQuery -> String)
-> ([SinglePartQuery] -> ShowS)
-> Show SinglePartQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SinglePartQuery -> ShowS
showsPrec :: Int -> SinglePartQuery -> ShowS
$cshow :: SinglePartQuery -> String
show :: SinglePartQuery -> String
$cshowList :: [SinglePartQuery] -> ShowS
showList :: [SinglePartQuery] -> ShowS
Show)

_SinglePartQuery :: Name
_SinglePartQuery = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.SinglePartQuery")

_SinglePartQuery_reading :: Name
_SinglePartQuery_reading = (String -> Name
Core.Name String
"reading")

_SinglePartQuery_updating :: Name
_SinglePartQuery_updating = (String -> Name
Core.Name String
"updating")

_SinglePartQuery_return :: Name
_SinglePartQuery_return = (String -> Name
Core.Name String
"return")

data WithClause = 
  WithClause {
    WithClause -> [ReadingClause]
withClauseReading :: [ReadingClause],
    WithClause -> [UpdatingClause]
withClauseUpdating :: [UpdatingClause],
    WithClause -> With
withClauseWith :: With}
  deriving (WithClause -> WithClause -> Bool
(WithClause -> WithClause -> Bool)
-> (WithClause -> WithClause -> Bool) -> Eq WithClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WithClause -> WithClause -> Bool
== :: WithClause -> WithClause -> Bool
$c/= :: WithClause -> WithClause -> Bool
/= :: WithClause -> WithClause -> Bool
Eq, Eq WithClause
Eq WithClause =>
(WithClause -> WithClause -> Ordering)
-> (WithClause -> WithClause -> Bool)
-> (WithClause -> WithClause -> Bool)
-> (WithClause -> WithClause -> Bool)
-> (WithClause -> WithClause -> Bool)
-> (WithClause -> WithClause -> WithClause)
-> (WithClause -> WithClause -> WithClause)
-> Ord WithClause
WithClause -> WithClause -> Bool
WithClause -> WithClause -> Ordering
WithClause -> WithClause -> WithClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: WithClause -> WithClause -> Ordering
compare :: WithClause -> WithClause -> Ordering
$c< :: WithClause -> WithClause -> Bool
< :: WithClause -> WithClause -> Bool
$c<= :: WithClause -> WithClause -> Bool
<= :: WithClause -> WithClause -> Bool
$c> :: WithClause -> WithClause -> Bool
> :: WithClause -> WithClause -> Bool
$c>= :: WithClause -> WithClause -> Bool
>= :: WithClause -> WithClause -> Bool
$cmax :: WithClause -> WithClause -> WithClause
max :: WithClause -> WithClause -> WithClause
$cmin :: WithClause -> WithClause -> WithClause
min :: WithClause -> WithClause -> WithClause
Ord, ReadPrec [WithClause]
ReadPrec WithClause
Int -> ReadS WithClause
ReadS [WithClause]
(Int -> ReadS WithClause)
-> ReadS [WithClause]
-> ReadPrec WithClause
-> ReadPrec [WithClause]
-> Read WithClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS WithClause
readsPrec :: Int -> ReadS WithClause
$creadList :: ReadS [WithClause]
readList :: ReadS [WithClause]
$creadPrec :: ReadPrec WithClause
readPrec :: ReadPrec WithClause
$creadListPrec :: ReadPrec [WithClause]
readListPrec :: ReadPrec [WithClause]
Read, Int -> WithClause -> ShowS
[WithClause] -> ShowS
WithClause -> String
(Int -> WithClause -> ShowS)
-> (WithClause -> String)
-> ([WithClause] -> ShowS)
-> Show WithClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WithClause -> ShowS
showsPrec :: Int -> WithClause -> ShowS
$cshow :: WithClause -> String
show :: WithClause -> String
$cshowList :: [WithClause] -> ShowS
showList :: [WithClause] -> ShowS
Show)

_WithClause :: Name
_WithClause = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.WithClause")

_WithClause_reading :: Name
_WithClause_reading = (String -> Name
Core.Name String
"reading")

_WithClause_updating :: Name
_WithClause_updating = (String -> Name
Core.Name String
"updating")

_WithClause_with :: Name
_WithClause_with = (String -> Name
Core.Name String
"with")

data MultiPartQuery = 
  MultiPartQuery {
    MultiPartQuery -> [WithClause]
multiPartQueryWith :: [WithClause],
    MultiPartQuery -> SinglePartQuery
multiPartQueryBody :: SinglePartQuery}
  deriving (MultiPartQuery -> MultiPartQuery -> Bool
(MultiPartQuery -> MultiPartQuery -> Bool)
-> (MultiPartQuery -> MultiPartQuery -> Bool) -> Eq MultiPartQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MultiPartQuery -> MultiPartQuery -> Bool
== :: MultiPartQuery -> MultiPartQuery -> Bool
$c/= :: MultiPartQuery -> MultiPartQuery -> Bool
/= :: MultiPartQuery -> MultiPartQuery -> Bool
Eq, Eq MultiPartQuery
Eq MultiPartQuery =>
(MultiPartQuery -> MultiPartQuery -> Ordering)
-> (MultiPartQuery -> MultiPartQuery -> Bool)
-> (MultiPartQuery -> MultiPartQuery -> Bool)
-> (MultiPartQuery -> MultiPartQuery -> Bool)
-> (MultiPartQuery -> MultiPartQuery -> Bool)
-> (MultiPartQuery -> MultiPartQuery -> MultiPartQuery)
-> (MultiPartQuery -> MultiPartQuery -> MultiPartQuery)
-> Ord MultiPartQuery
MultiPartQuery -> MultiPartQuery -> Bool
MultiPartQuery -> MultiPartQuery -> Ordering
MultiPartQuery -> MultiPartQuery -> MultiPartQuery
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MultiPartQuery -> MultiPartQuery -> Ordering
compare :: MultiPartQuery -> MultiPartQuery -> Ordering
$c< :: MultiPartQuery -> MultiPartQuery -> Bool
< :: MultiPartQuery -> MultiPartQuery -> Bool
$c<= :: MultiPartQuery -> MultiPartQuery -> Bool
<= :: MultiPartQuery -> MultiPartQuery -> Bool
$c> :: MultiPartQuery -> MultiPartQuery -> Bool
> :: MultiPartQuery -> MultiPartQuery -> Bool
$c>= :: MultiPartQuery -> MultiPartQuery -> Bool
>= :: MultiPartQuery -> MultiPartQuery -> Bool
$cmax :: MultiPartQuery -> MultiPartQuery -> MultiPartQuery
max :: MultiPartQuery -> MultiPartQuery -> MultiPartQuery
$cmin :: MultiPartQuery -> MultiPartQuery -> MultiPartQuery
min :: MultiPartQuery -> MultiPartQuery -> MultiPartQuery
Ord, ReadPrec [MultiPartQuery]
ReadPrec MultiPartQuery
Int -> ReadS MultiPartQuery
ReadS [MultiPartQuery]
(Int -> ReadS MultiPartQuery)
-> ReadS [MultiPartQuery]
-> ReadPrec MultiPartQuery
-> ReadPrec [MultiPartQuery]
-> Read MultiPartQuery
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MultiPartQuery
readsPrec :: Int -> ReadS MultiPartQuery
$creadList :: ReadS [MultiPartQuery]
readList :: ReadS [MultiPartQuery]
$creadPrec :: ReadPrec MultiPartQuery
readPrec :: ReadPrec MultiPartQuery
$creadListPrec :: ReadPrec [MultiPartQuery]
readListPrec :: ReadPrec [MultiPartQuery]
Read, Int -> MultiPartQuery -> ShowS
[MultiPartQuery] -> ShowS
MultiPartQuery -> String
(Int -> MultiPartQuery -> ShowS)
-> (MultiPartQuery -> String)
-> ([MultiPartQuery] -> ShowS)
-> Show MultiPartQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MultiPartQuery -> ShowS
showsPrec :: Int -> MultiPartQuery -> ShowS
$cshow :: MultiPartQuery -> String
show :: MultiPartQuery -> String
$cshowList :: [MultiPartQuery] -> ShowS
showList :: [MultiPartQuery] -> ShowS
Show)

_MultiPartQuery :: Name
_MultiPartQuery = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.MultiPartQuery")

_MultiPartQuery_with :: Name
_MultiPartQuery_with = (String -> Name
Core.Name String
"with")

_MultiPartQuery_body :: Name
_MultiPartQuery_body = (String -> Name
Core.Name String
"body")

data UpdatingClause = 
  UpdatingClauseCreate Create |
  UpdatingClauseMerge Merge |
  UpdatingClauseDelete Delete |
  UpdatingClauseSet Set_ |
  UpdatingClauseRemove Remove
  deriving (UpdatingClause -> UpdatingClause -> Bool
(UpdatingClause -> UpdatingClause -> Bool)
-> (UpdatingClause -> UpdatingClause -> Bool) -> Eq UpdatingClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UpdatingClause -> UpdatingClause -> Bool
== :: UpdatingClause -> UpdatingClause -> Bool
$c/= :: UpdatingClause -> UpdatingClause -> Bool
/= :: UpdatingClause -> UpdatingClause -> Bool
Eq, Eq UpdatingClause
Eq UpdatingClause =>
(UpdatingClause -> UpdatingClause -> Ordering)
-> (UpdatingClause -> UpdatingClause -> Bool)
-> (UpdatingClause -> UpdatingClause -> Bool)
-> (UpdatingClause -> UpdatingClause -> Bool)
-> (UpdatingClause -> UpdatingClause -> Bool)
-> (UpdatingClause -> UpdatingClause -> UpdatingClause)
-> (UpdatingClause -> UpdatingClause -> UpdatingClause)
-> Ord UpdatingClause
UpdatingClause -> UpdatingClause -> Bool
UpdatingClause -> UpdatingClause -> Ordering
UpdatingClause -> UpdatingClause -> UpdatingClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UpdatingClause -> UpdatingClause -> Ordering
compare :: UpdatingClause -> UpdatingClause -> Ordering
$c< :: UpdatingClause -> UpdatingClause -> Bool
< :: UpdatingClause -> UpdatingClause -> Bool
$c<= :: UpdatingClause -> UpdatingClause -> Bool
<= :: UpdatingClause -> UpdatingClause -> Bool
$c> :: UpdatingClause -> UpdatingClause -> Bool
> :: UpdatingClause -> UpdatingClause -> Bool
$c>= :: UpdatingClause -> UpdatingClause -> Bool
>= :: UpdatingClause -> UpdatingClause -> Bool
$cmax :: UpdatingClause -> UpdatingClause -> UpdatingClause
max :: UpdatingClause -> UpdatingClause -> UpdatingClause
$cmin :: UpdatingClause -> UpdatingClause -> UpdatingClause
min :: UpdatingClause -> UpdatingClause -> UpdatingClause
Ord, ReadPrec [UpdatingClause]
ReadPrec UpdatingClause
Int -> ReadS UpdatingClause
ReadS [UpdatingClause]
(Int -> ReadS UpdatingClause)
-> ReadS [UpdatingClause]
-> ReadPrec UpdatingClause
-> ReadPrec [UpdatingClause]
-> Read UpdatingClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UpdatingClause
readsPrec :: Int -> ReadS UpdatingClause
$creadList :: ReadS [UpdatingClause]
readList :: ReadS [UpdatingClause]
$creadPrec :: ReadPrec UpdatingClause
readPrec :: ReadPrec UpdatingClause
$creadListPrec :: ReadPrec [UpdatingClause]
readListPrec :: ReadPrec [UpdatingClause]
Read, Int -> UpdatingClause -> ShowS
[UpdatingClause] -> ShowS
UpdatingClause -> String
(Int -> UpdatingClause -> ShowS)
-> (UpdatingClause -> String)
-> ([UpdatingClause] -> ShowS)
-> Show UpdatingClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UpdatingClause -> ShowS
showsPrec :: Int -> UpdatingClause -> ShowS
$cshow :: UpdatingClause -> String
show :: UpdatingClause -> String
$cshowList :: [UpdatingClause] -> ShowS
showList :: [UpdatingClause] -> ShowS
Show)

_UpdatingClause :: Name
_UpdatingClause = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.UpdatingClause")

_UpdatingClause_create :: Name
_UpdatingClause_create = (String -> Name
Core.Name String
"create")

_UpdatingClause_merge :: Name
_UpdatingClause_merge = (String -> Name
Core.Name String
"merge")

_UpdatingClause_delete :: Name
_UpdatingClause_delete = (String -> Name
Core.Name String
"delete")

_UpdatingClause_set :: Name
_UpdatingClause_set = (String -> Name
Core.Name String
"set")

_UpdatingClause_remove :: Name
_UpdatingClause_remove = (String -> Name
Core.Name String
"remove")

data ReadingClause = 
  ReadingClauseMatch Match |
  ReadingClauseUnwind Unwind |
  ReadingClauseInQueryCall InQueryCall
  deriving (ReadingClause -> ReadingClause -> Bool
(ReadingClause -> ReadingClause -> Bool)
-> (ReadingClause -> ReadingClause -> Bool) -> Eq ReadingClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReadingClause -> ReadingClause -> Bool
== :: ReadingClause -> ReadingClause -> Bool
$c/= :: ReadingClause -> ReadingClause -> Bool
/= :: ReadingClause -> ReadingClause -> Bool
Eq, Eq ReadingClause
Eq ReadingClause =>
(ReadingClause -> ReadingClause -> Ordering)
-> (ReadingClause -> ReadingClause -> Bool)
-> (ReadingClause -> ReadingClause -> Bool)
-> (ReadingClause -> ReadingClause -> Bool)
-> (ReadingClause -> ReadingClause -> Bool)
-> (ReadingClause -> ReadingClause -> ReadingClause)
-> (ReadingClause -> ReadingClause -> ReadingClause)
-> Ord ReadingClause
ReadingClause -> ReadingClause -> Bool
ReadingClause -> ReadingClause -> Ordering
ReadingClause -> ReadingClause -> ReadingClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ReadingClause -> ReadingClause -> Ordering
compare :: ReadingClause -> ReadingClause -> Ordering
$c< :: ReadingClause -> ReadingClause -> Bool
< :: ReadingClause -> ReadingClause -> Bool
$c<= :: ReadingClause -> ReadingClause -> Bool
<= :: ReadingClause -> ReadingClause -> Bool
$c> :: ReadingClause -> ReadingClause -> Bool
> :: ReadingClause -> ReadingClause -> Bool
$c>= :: ReadingClause -> ReadingClause -> Bool
>= :: ReadingClause -> ReadingClause -> Bool
$cmax :: ReadingClause -> ReadingClause -> ReadingClause
max :: ReadingClause -> ReadingClause -> ReadingClause
$cmin :: ReadingClause -> ReadingClause -> ReadingClause
min :: ReadingClause -> ReadingClause -> ReadingClause
Ord, ReadPrec [ReadingClause]
ReadPrec ReadingClause
Int -> ReadS ReadingClause
ReadS [ReadingClause]
(Int -> ReadS ReadingClause)
-> ReadS [ReadingClause]
-> ReadPrec ReadingClause
-> ReadPrec [ReadingClause]
-> Read ReadingClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ReadingClause
readsPrec :: Int -> ReadS ReadingClause
$creadList :: ReadS [ReadingClause]
readList :: ReadS [ReadingClause]
$creadPrec :: ReadPrec ReadingClause
readPrec :: ReadPrec ReadingClause
$creadListPrec :: ReadPrec [ReadingClause]
readListPrec :: ReadPrec [ReadingClause]
Read, Int -> ReadingClause -> ShowS
[ReadingClause] -> ShowS
ReadingClause -> String
(Int -> ReadingClause -> ShowS)
-> (ReadingClause -> String)
-> ([ReadingClause] -> ShowS)
-> Show ReadingClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReadingClause -> ShowS
showsPrec :: Int -> ReadingClause -> ShowS
$cshow :: ReadingClause -> String
show :: ReadingClause -> String
$cshowList :: [ReadingClause] -> ShowS
showList :: [ReadingClause] -> ShowS
Show)

_ReadingClause :: Name
_ReadingClause = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ReadingClause")

_ReadingClause_match :: Name
_ReadingClause_match = (String -> Name
Core.Name String
"match")

_ReadingClause_unwind :: Name
_ReadingClause_unwind = (String -> Name
Core.Name String
"unwind")

_ReadingClause_inQueryCall :: Name
_ReadingClause_inQueryCall = (String -> Name
Core.Name String
"inQueryCall")

data Match = 
  Match {
    Match -> Bool
matchOptional :: Bool,
    Match -> Pattern
matchPattern :: Pattern,
    Match -> Maybe Where
matchWhere :: (Maybe Where)}
  deriving (Match -> Match -> Bool
(Match -> Match -> Bool) -> (Match -> Match -> Bool) -> Eq Match
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Match -> Match -> Bool
== :: Match -> Match -> Bool
$c/= :: Match -> Match -> Bool
/= :: Match -> Match -> Bool
Eq, Eq Match
Eq Match =>
(Match -> Match -> Ordering)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Match)
-> (Match -> Match -> Match)
-> Ord Match
Match -> Match -> Bool
Match -> Match -> Ordering
Match -> Match -> Match
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Match -> Match -> Ordering
compare :: Match -> Match -> Ordering
$c< :: Match -> Match -> Bool
< :: Match -> Match -> Bool
$c<= :: Match -> Match -> Bool
<= :: Match -> Match -> Bool
$c> :: Match -> Match -> Bool
> :: Match -> Match -> Bool
$c>= :: Match -> Match -> Bool
>= :: Match -> Match -> Bool
$cmax :: Match -> Match -> Match
max :: Match -> Match -> Match
$cmin :: Match -> Match -> Match
min :: Match -> Match -> Match
Ord, ReadPrec [Match]
ReadPrec Match
Int -> ReadS Match
ReadS [Match]
(Int -> ReadS Match)
-> ReadS [Match]
-> ReadPrec Match
-> ReadPrec [Match]
-> Read Match
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Match
readsPrec :: Int -> ReadS Match
$creadList :: ReadS [Match]
readList :: ReadS [Match]
$creadPrec :: ReadPrec Match
readPrec :: ReadPrec Match
$creadListPrec :: ReadPrec [Match]
readListPrec :: ReadPrec [Match]
Read, Int -> Match -> ShowS
[Match] -> ShowS
Match -> String
(Int -> Match -> ShowS)
-> (Match -> String) -> ([Match] -> ShowS) -> Show Match
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Match -> ShowS
showsPrec :: Int -> Match -> ShowS
$cshow :: Match -> String
show :: Match -> String
$cshowList :: [Match] -> ShowS
showList :: [Match] -> ShowS
Show)

_Match :: Name
_Match = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Match")

_Match_optional :: Name
_Match_optional = (String -> Name
Core.Name String
"optional")

_Match_pattern :: Name
_Match_pattern = (String -> Name
Core.Name String
"pattern")

_Match_where :: Name
_Match_where = (String -> Name
Core.Name String
"where")

data Unwind = 
  Unwind {
    Unwind -> Expression
unwindExpression :: Expression,
    Unwind -> Variable
unwindVariable :: Variable}
  deriving (Unwind -> Unwind -> Bool
(Unwind -> Unwind -> Bool)
-> (Unwind -> Unwind -> Bool) -> Eq Unwind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Unwind -> Unwind -> Bool
== :: Unwind -> Unwind -> Bool
$c/= :: Unwind -> Unwind -> Bool
/= :: Unwind -> Unwind -> Bool
Eq, Eq Unwind
Eq Unwind =>
(Unwind -> Unwind -> Ordering)
-> (Unwind -> Unwind -> Bool)
-> (Unwind -> Unwind -> Bool)
-> (Unwind -> Unwind -> Bool)
-> (Unwind -> Unwind -> Bool)
-> (Unwind -> Unwind -> Unwind)
-> (Unwind -> Unwind -> Unwind)
-> Ord Unwind
Unwind -> Unwind -> Bool
Unwind -> Unwind -> Ordering
Unwind -> Unwind -> Unwind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Unwind -> Unwind -> Ordering
compare :: Unwind -> Unwind -> Ordering
$c< :: Unwind -> Unwind -> Bool
< :: Unwind -> Unwind -> Bool
$c<= :: Unwind -> Unwind -> Bool
<= :: Unwind -> Unwind -> Bool
$c> :: Unwind -> Unwind -> Bool
> :: Unwind -> Unwind -> Bool
$c>= :: Unwind -> Unwind -> Bool
>= :: Unwind -> Unwind -> Bool
$cmax :: Unwind -> Unwind -> Unwind
max :: Unwind -> Unwind -> Unwind
$cmin :: Unwind -> Unwind -> Unwind
min :: Unwind -> Unwind -> Unwind
Ord, ReadPrec [Unwind]
ReadPrec Unwind
Int -> ReadS Unwind
ReadS [Unwind]
(Int -> ReadS Unwind)
-> ReadS [Unwind]
-> ReadPrec Unwind
-> ReadPrec [Unwind]
-> Read Unwind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Unwind
readsPrec :: Int -> ReadS Unwind
$creadList :: ReadS [Unwind]
readList :: ReadS [Unwind]
$creadPrec :: ReadPrec Unwind
readPrec :: ReadPrec Unwind
$creadListPrec :: ReadPrec [Unwind]
readListPrec :: ReadPrec [Unwind]
Read, Int -> Unwind -> ShowS
[Unwind] -> ShowS
Unwind -> String
(Int -> Unwind -> ShowS)
-> (Unwind -> String) -> ([Unwind] -> ShowS) -> Show Unwind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Unwind -> ShowS
showsPrec :: Int -> Unwind -> ShowS
$cshow :: Unwind -> String
show :: Unwind -> String
$cshowList :: [Unwind] -> ShowS
showList :: [Unwind] -> ShowS
Show)

_Unwind :: Name
_Unwind = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Unwind")

_Unwind_expression :: Name
_Unwind_expression = (String -> Name
Core.Name String
"expression")

_Unwind_variable :: Name
_Unwind_variable = (String -> Name
Core.Name String
"variable")

data Merge = 
  Merge {
    Merge -> PatternPart
mergePatternPart :: PatternPart,
    Merge -> [MergeAction]
mergeActions :: [MergeAction]}
  deriving (Merge -> Merge -> Bool
(Merge -> Merge -> Bool) -> (Merge -> Merge -> Bool) -> Eq Merge
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Merge -> Merge -> Bool
== :: Merge -> Merge -> Bool
$c/= :: Merge -> Merge -> Bool
/= :: Merge -> Merge -> Bool
Eq, Eq Merge
Eq Merge =>
(Merge -> Merge -> Ordering)
-> (Merge -> Merge -> Bool)
-> (Merge -> Merge -> Bool)
-> (Merge -> Merge -> Bool)
-> (Merge -> Merge -> Bool)
-> (Merge -> Merge -> Merge)
-> (Merge -> Merge -> Merge)
-> Ord Merge
Merge -> Merge -> Bool
Merge -> Merge -> Ordering
Merge -> Merge -> Merge
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Merge -> Merge -> Ordering
compare :: Merge -> Merge -> Ordering
$c< :: Merge -> Merge -> Bool
< :: Merge -> Merge -> Bool
$c<= :: Merge -> Merge -> Bool
<= :: Merge -> Merge -> Bool
$c> :: Merge -> Merge -> Bool
> :: Merge -> Merge -> Bool
$c>= :: Merge -> Merge -> Bool
>= :: Merge -> Merge -> Bool
$cmax :: Merge -> Merge -> Merge
max :: Merge -> Merge -> Merge
$cmin :: Merge -> Merge -> Merge
min :: Merge -> Merge -> Merge
Ord, ReadPrec [Merge]
ReadPrec Merge
Int -> ReadS Merge
ReadS [Merge]
(Int -> ReadS Merge)
-> ReadS [Merge]
-> ReadPrec Merge
-> ReadPrec [Merge]
-> Read Merge
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Merge
readsPrec :: Int -> ReadS Merge
$creadList :: ReadS [Merge]
readList :: ReadS [Merge]
$creadPrec :: ReadPrec Merge
readPrec :: ReadPrec Merge
$creadListPrec :: ReadPrec [Merge]
readListPrec :: ReadPrec [Merge]
Read, Int -> Merge -> ShowS
[Merge] -> ShowS
Merge -> String
(Int -> Merge -> ShowS)
-> (Merge -> String) -> ([Merge] -> ShowS) -> Show Merge
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Merge -> ShowS
showsPrec :: Int -> Merge -> ShowS
$cshow :: Merge -> String
show :: Merge -> String
$cshowList :: [Merge] -> ShowS
showList :: [Merge] -> ShowS
Show)

_Merge :: Name
_Merge = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Merge")

_Merge_patternPart :: Name
_Merge_patternPart = (String -> Name
Core.Name String
"patternPart")

_Merge_actions :: Name
_Merge_actions = (String -> Name
Core.Name String
"actions")

data MatchOrCreate = 
  MatchOrCreateMatch  |
  MatchOrCreateCreate 
  deriving (MatchOrCreate -> MatchOrCreate -> Bool
(MatchOrCreate -> MatchOrCreate -> Bool)
-> (MatchOrCreate -> MatchOrCreate -> Bool) -> Eq MatchOrCreate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MatchOrCreate -> MatchOrCreate -> Bool
== :: MatchOrCreate -> MatchOrCreate -> Bool
$c/= :: MatchOrCreate -> MatchOrCreate -> Bool
/= :: MatchOrCreate -> MatchOrCreate -> Bool
Eq, Eq MatchOrCreate
Eq MatchOrCreate =>
(MatchOrCreate -> MatchOrCreate -> Ordering)
-> (MatchOrCreate -> MatchOrCreate -> Bool)
-> (MatchOrCreate -> MatchOrCreate -> Bool)
-> (MatchOrCreate -> MatchOrCreate -> Bool)
-> (MatchOrCreate -> MatchOrCreate -> Bool)
-> (MatchOrCreate -> MatchOrCreate -> MatchOrCreate)
-> (MatchOrCreate -> MatchOrCreate -> MatchOrCreate)
-> Ord MatchOrCreate
MatchOrCreate -> MatchOrCreate -> Bool
MatchOrCreate -> MatchOrCreate -> Ordering
MatchOrCreate -> MatchOrCreate -> MatchOrCreate
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MatchOrCreate -> MatchOrCreate -> Ordering
compare :: MatchOrCreate -> MatchOrCreate -> Ordering
$c< :: MatchOrCreate -> MatchOrCreate -> Bool
< :: MatchOrCreate -> MatchOrCreate -> Bool
$c<= :: MatchOrCreate -> MatchOrCreate -> Bool
<= :: MatchOrCreate -> MatchOrCreate -> Bool
$c> :: MatchOrCreate -> MatchOrCreate -> Bool
> :: MatchOrCreate -> MatchOrCreate -> Bool
$c>= :: MatchOrCreate -> MatchOrCreate -> Bool
>= :: MatchOrCreate -> MatchOrCreate -> Bool
$cmax :: MatchOrCreate -> MatchOrCreate -> MatchOrCreate
max :: MatchOrCreate -> MatchOrCreate -> MatchOrCreate
$cmin :: MatchOrCreate -> MatchOrCreate -> MatchOrCreate
min :: MatchOrCreate -> MatchOrCreate -> MatchOrCreate
Ord, ReadPrec [MatchOrCreate]
ReadPrec MatchOrCreate
Int -> ReadS MatchOrCreate
ReadS [MatchOrCreate]
(Int -> ReadS MatchOrCreate)
-> ReadS [MatchOrCreate]
-> ReadPrec MatchOrCreate
-> ReadPrec [MatchOrCreate]
-> Read MatchOrCreate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MatchOrCreate
readsPrec :: Int -> ReadS MatchOrCreate
$creadList :: ReadS [MatchOrCreate]
readList :: ReadS [MatchOrCreate]
$creadPrec :: ReadPrec MatchOrCreate
readPrec :: ReadPrec MatchOrCreate
$creadListPrec :: ReadPrec [MatchOrCreate]
readListPrec :: ReadPrec [MatchOrCreate]
Read, Int -> MatchOrCreate -> ShowS
[MatchOrCreate] -> ShowS
MatchOrCreate -> String
(Int -> MatchOrCreate -> ShowS)
-> (MatchOrCreate -> String)
-> ([MatchOrCreate] -> ShowS)
-> Show MatchOrCreate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MatchOrCreate -> ShowS
showsPrec :: Int -> MatchOrCreate -> ShowS
$cshow :: MatchOrCreate -> String
show :: MatchOrCreate -> String
$cshowList :: [MatchOrCreate] -> ShowS
showList :: [MatchOrCreate] -> ShowS
Show)

_MatchOrCreate :: Name
_MatchOrCreate = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.MatchOrCreate")

_MatchOrCreate_match :: Name
_MatchOrCreate_match = (String -> Name
Core.Name String
"match")

_MatchOrCreate_create :: Name
_MatchOrCreate_create = (String -> Name
Core.Name String
"create")

data MergeAction = 
  MergeAction {
    MergeAction -> MatchOrCreate
mergeActionAction :: MatchOrCreate,
    MergeAction -> Set_
mergeActionSet :: Set_}
  deriving (MergeAction -> MergeAction -> Bool
(MergeAction -> MergeAction -> Bool)
-> (MergeAction -> MergeAction -> Bool) -> Eq MergeAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeAction -> MergeAction -> Bool
== :: MergeAction -> MergeAction -> Bool
$c/= :: MergeAction -> MergeAction -> Bool
/= :: MergeAction -> MergeAction -> Bool
Eq, Eq MergeAction
Eq MergeAction =>
(MergeAction -> MergeAction -> Ordering)
-> (MergeAction -> MergeAction -> Bool)
-> (MergeAction -> MergeAction -> Bool)
-> (MergeAction -> MergeAction -> Bool)
-> (MergeAction -> MergeAction -> Bool)
-> (MergeAction -> MergeAction -> MergeAction)
-> (MergeAction -> MergeAction -> MergeAction)
-> Ord MergeAction
MergeAction -> MergeAction -> Bool
MergeAction -> MergeAction -> Ordering
MergeAction -> MergeAction -> MergeAction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MergeAction -> MergeAction -> Ordering
compare :: MergeAction -> MergeAction -> Ordering
$c< :: MergeAction -> MergeAction -> Bool
< :: MergeAction -> MergeAction -> Bool
$c<= :: MergeAction -> MergeAction -> Bool
<= :: MergeAction -> MergeAction -> Bool
$c> :: MergeAction -> MergeAction -> Bool
> :: MergeAction -> MergeAction -> Bool
$c>= :: MergeAction -> MergeAction -> Bool
>= :: MergeAction -> MergeAction -> Bool
$cmax :: MergeAction -> MergeAction -> MergeAction
max :: MergeAction -> MergeAction -> MergeAction
$cmin :: MergeAction -> MergeAction -> MergeAction
min :: MergeAction -> MergeAction -> MergeAction
Ord, ReadPrec [MergeAction]
ReadPrec MergeAction
Int -> ReadS MergeAction
ReadS [MergeAction]
(Int -> ReadS MergeAction)
-> ReadS [MergeAction]
-> ReadPrec MergeAction
-> ReadPrec [MergeAction]
-> Read MergeAction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MergeAction
readsPrec :: Int -> ReadS MergeAction
$creadList :: ReadS [MergeAction]
readList :: ReadS [MergeAction]
$creadPrec :: ReadPrec MergeAction
readPrec :: ReadPrec MergeAction
$creadListPrec :: ReadPrec [MergeAction]
readListPrec :: ReadPrec [MergeAction]
Read, Int -> MergeAction -> ShowS
[MergeAction] -> ShowS
MergeAction -> String
(Int -> MergeAction -> ShowS)
-> (MergeAction -> String)
-> ([MergeAction] -> ShowS)
-> Show MergeAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MergeAction -> ShowS
showsPrec :: Int -> MergeAction -> ShowS
$cshow :: MergeAction -> String
show :: MergeAction -> String
$cshowList :: [MergeAction] -> ShowS
showList :: [MergeAction] -> ShowS
Show)

_MergeAction :: Name
_MergeAction = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.MergeAction")

_MergeAction_action :: Name
_MergeAction_action = (String -> Name
Core.Name String
"action")

_MergeAction_set :: Name
_MergeAction_set = (String -> Name
Core.Name String
"set")

newtype Create = 
  Create {
    Create -> Pattern
unCreate :: Pattern}
  deriving (Create -> Create -> Bool
(Create -> Create -> Bool)
-> (Create -> Create -> Bool) -> Eq Create
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Create -> Create -> Bool
== :: Create -> Create -> Bool
$c/= :: Create -> Create -> Bool
/= :: Create -> Create -> Bool
Eq, Eq Create
Eq Create =>
(Create -> Create -> Ordering)
-> (Create -> Create -> Bool)
-> (Create -> Create -> Bool)
-> (Create -> Create -> Bool)
-> (Create -> Create -> Bool)
-> (Create -> Create -> Create)
-> (Create -> Create -> Create)
-> Ord Create
Create -> Create -> Bool
Create -> Create -> Ordering
Create -> Create -> Create
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Create -> Create -> Ordering
compare :: Create -> Create -> Ordering
$c< :: Create -> Create -> Bool
< :: Create -> Create -> Bool
$c<= :: Create -> Create -> Bool
<= :: Create -> Create -> Bool
$c> :: Create -> Create -> Bool
> :: Create -> Create -> Bool
$c>= :: Create -> Create -> Bool
>= :: Create -> Create -> Bool
$cmax :: Create -> Create -> Create
max :: Create -> Create -> Create
$cmin :: Create -> Create -> Create
min :: Create -> Create -> Create
Ord, ReadPrec [Create]
ReadPrec Create
Int -> ReadS Create
ReadS [Create]
(Int -> ReadS Create)
-> ReadS [Create]
-> ReadPrec Create
-> ReadPrec [Create]
-> Read Create
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Create
readsPrec :: Int -> ReadS Create
$creadList :: ReadS [Create]
readList :: ReadS [Create]
$creadPrec :: ReadPrec Create
readPrec :: ReadPrec Create
$creadListPrec :: ReadPrec [Create]
readListPrec :: ReadPrec [Create]
Read, Int -> Create -> ShowS
[Create] -> ShowS
Create -> String
(Int -> Create -> ShowS)
-> (Create -> String) -> ([Create] -> ShowS) -> Show Create
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Create -> ShowS
showsPrec :: Int -> Create -> ShowS
$cshow :: Create -> String
show :: Create -> String
$cshowList :: [Create] -> ShowS
showList :: [Create] -> ShowS
Show)

_Create :: Name
_Create = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Create")

newtype Set_ = 
  Set_ {
    Set_ -> [SetItem]
unSet :: [SetItem]}
  deriving (Set_ -> Set_ -> Bool
(Set_ -> Set_ -> Bool) -> (Set_ -> Set_ -> Bool) -> Eq Set_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Set_ -> Set_ -> Bool
== :: Set_ -> Set_ -> Bool
$c/= :: Set_ -> Set_ -> Bool
/= :: Set_ -> Set_ -> Bool
Eq, Eq Set_
Eq Set_ =>
(Set_ -> Set_ -> Ordering)
-> (Set_ -> Set_ -> Bool)
-> (Set_ -> Set_ -> Bool)
-> (Set_ -> Set_ -> Bool)
-> (Set_ -> Set_ -> Bool)
-> (Set_ -> Set_ -> Set_)
-> (Set_ -> Set_ -> Set_)
-> Ord Set_
Set_ -> Set_ -> Bool
Set_ -> Set_ -> Ordering
Set_ -> Set_ -> Set_
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Set_ -> Set_ -> Ordering
compare :: Set_ -> Set_ -> Ordering
$c< :: Set_ -> Set_ -> Bool
< :: Set_ -> Set_ -> Bool
$c<= :: Set_ -> Set_ -> Bool
<= :: Set_ -> Set_ -> Bool
$c> :: Set_ -> Set_ -> Bool
> :: Set_ -> Set_ -> Bool
$c>= :: Set_ -> Set_ -> Bool
>= :: Set_ -> Set_ -> Bool
$cmax :: Set_ -> Set_ -> Set_
max :: Set_ -> Set_ -> Set_
$cmin :: Set_ -> Set_ -> Set_
min :: Set_ -> Set_ -> Set_
Ord, ReadPrec [Set_]
ReadPrec Set_
Int -> ReadS Set_
ReadS [Set_]
(Int -> ReadS Set_)
-> ReadS [Set_] -> ReadPrec Set_ -> ReadPrec [Set_] -> Read Set_
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Set_
readsPrec :: Int -> ReadS Set_
$creadList :: ReadS [Set_]
readList :: ReadS [Set_]
$creadPrec :: ReadPrec Set_
readPrec :: ReadPrec Set_
$creadListPrec :: ReadPrec [Set_]
readListPrec :: ReadPrec [Set_]
Read, Int -> Set_ -> ShowS
[Set_] -> ShowS
Set_ -> String
(Int -> Set_ -> ShowS)
-> (Set_ -> String) -> ([Set_] -> ShowS) -> Show Set_
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Set_ -> ShowS
showsPrec :: Int -> Set_ -> ShowS
$cshow :: Set_ -> String
show :: Set_ -> String
$cshowList :: [Set_] -> ShowS
showList :: [Set_] -> ShowS
Show)

_Set :: Name
_Set = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Set")

data SetItem = 
  SetItemProperty PropertyEquals |
  SetItemVariableEqual VariableEquals |
  SetItemVariablePlusEqual VariablePlusEquals |
  SetItemVariableLabels VariableAndNodeLabels
  deriving (SetItem -> SetItem -> Bool
(SetItem -> SetItem -> Bool)
-> (SetItem -> SetItem -> Bool) -> Eq SetItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SetItem -> SetItem -> Bool
== :: SetItem -> SetItem -> Bool
$c/= :: SetItem -> SetItem -> Bool
/= :: SetItem -> SetItem -> Bool
Eq, Eq SetItem
Eq SetItem =>
(SetItem -> SetItem -> Ordering)
-> (SetItem -> SetItem -> Bool)
-> (SetItem -> SetItem -> Bool)
-> (SetItem -> SetItem -> Bool)
-> (SetItem -> SetItem -> Bool)
-> (SetItem -> SetItem -> SetItem)
-> (SetItem -> SetItem -> SetItem)
-> Ord SetItem
SetItem -> SetItem -> Bool
SetItem -> SetItem -> Ordering
SetItem -> SetItem -> SetItem
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SetItem -> SetItem -> Ordering
compare :: SetItem -> SetItem -> Ordering
$c< :: SetItem -> SetItem -> Bool
< :: SetItem -> SetItem -> Bool
$c<= :: SetItem -> SetItem -> Bool
<= :: SetItem -> SetItem -> Bool
$c> :: SetItem -> SetItem -> Bool
> :: SetItem -> SetItem -> Bool
$c>= :: SetItem -> SetItem -> Bool
>= :: SetItem -> SetItem -> Bool
$cmax :: SetItem -> SetItem -> SetItem
max :: SetItem -> SetItem -> SetItem
$cmin :: SetItem -> SetItem -> SetItem
min :: SetItem -> SetItem -> SetItem
Ord, ReadPrec [SetItem]
ReadPrec SetItem
Int -> ReadS SetItem
ReadS [SetItem]
(Int -> ReadS SetItem)
-> ReadS [SetItem]
-> ReadPrec SetItem
-> ReadPrec [SetItem]
-> Read SetItem
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SetItem
readsPrec :: Int -> ReadS SetItem
$creadList :: ReadS [SetItem]
readList :: ReadS [SetItem]
$creadPrec :: ReadPrec SetItem
readPrec :: ReadPrec SetItem
$creadListPrec :: ReadPrec [SetItem]
readListPrec :: ReadPrec [SetItem]
Read, Int -> SetItem -> ShowS
[SetItem] -> ShowS
SetItem -> String
(Int -> SetItem -> ShowS)
-> (SetItem -> String) -> ([SetItem] -> ShowS) -> Show SetItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SetItem -> ShowS
showsPrec :: Int -> SetItem -> ShowS
$cshow :: SetItem -> String
show :: SetItem -> String
$cshowList :: [SetItem] -> ShowS
showList :: [SetItem] -> ShowS
Show)

_SetItem :: Name
_SetItem = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.SetItem")

_SetItem_property :: Name
_SetItem_property = (String -> Name
Core.Name String
"property")

_SetItem_variableEqual :: Name
_SetItem_variableEqual = (String -> Name
Core.Name String
"variableEqual")

_SetItem_variablePlusEqual :: Name
_SetItem_variablePlusEqual = (String -> Name
Core.Name String
"variablePlusEqual")

_SetItem_variableLabels :: Name
_SetItem_variableLabels = (String -> Name
Core.Name String
"variableLabels")

data PropertyEquals = 
  PropertyEquals {
    PropertyEquals -> PropertyExpression
propertyEqualsLhs :: PropertyExpression,
    PropertyEquals -> Expression
propertyEqualsRhs :: Expression}
  deriving (PropertyEquals -> PropertyEquals -> Bool
(PropertyEquals -> PropertyEquals -> Bool)
-> (PropertyEquals -> PropertyEquals -> Bool) -> Eq PropertyEquals
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PropertyEquals -> PropertyEquals -> Bool
== :: PropertyEquals -> PropertyEquals -> Bool
$c/= :: PropertyEquals -> PropertyEquals -> Bool
/= :: PropertyEquals -> PropertyEquals -> Bool
Eq, Eq PropertyEquals
Eq PropertyEquals =>
(PropertyEquals -> PropertyEquals -> Ordering)
-> (PropertyEquals -> PropertyEquals -> Bool)
-> (PropertyEquals -> PropertyEquals -> Bool)
-> (PropertyEquals -> PropertyEquals -> Bool)
-> (PropertyEquals -> PropertyEquals -> Bool)
-> (PropertyEquals -> PropertyEquals -> PropertyEquals)
-> (PropertyEquals -> PropertyEquals -> PropertyEquals)
-> Ord PropertyEquals
PropertyEquals -> PropertyEquals -> Bool
PropertyEquals -> PropertyEquals -> Ordering
PropertyEquals -> PropertyEquals -> PropertyEquals
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PropertyEquals -> PropertyEquals -> Ordering
compare :: PropertyEquals -> PropertyEquals -> Ordering
$c< :: PropertyEquals -> PropertyEquals -> Bool
< :: PropertyEquals -> PropertyEquals -> Bool
$c<= :: PropertyEquals -> PropertyEquals -> Bool
<= :: PropertyEquals -> PropertyEquals -> Bool
$c> :: PropertyEquals -> PropertyEquals -> Bool
> :: PropertyEquals -> PropertyEquals -> Bool
$c>= :: PropertyEquals -> PropertyEquals -> Bool
>= :: PropertyEquals -> PropertyEquals -> Bool
$cmax :: PropertyEquals -> PropertyEquals -> PropertyEquals
max :: PropertyEquals -> PropertyEquals -> PropertyEquals
$cmin :: PropertyEquals -> PropertyEquals -> PropertyEquals
min :: PropertyEquals -> PropertyEquals -> PropertyEquals
Ord, ReadPrec [PropertyEquals]
ReadPrec PropertyEquals
Int -> ReadS PropertyEquals
ReadS [PropertyEquals]
(Int -> ReadS PropertyEquals)
-> ReadS [PropertyEquals]
-> ReadPrec PropertyEquals
-> ReadPrec [PropertyEquals]
-> Read PropertyEquals
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PropertyEquals
readsPrec :: Int -> ReadS PropertyEquals
$creadList :: ReadS [PropertyEquals]
readList :: ReadS [PropertyEquals]
$creadPrec :: ReadPrec PropertyEquals
readPrec :: ReadPrec PropertyEquals
$creadListPrec :: ReadPrec [PropertyEquals]
readListPrec :: ReadPrec [PropertyEquals]
Read, Int -> PropertyEquals -> ShowS
[PropertyEquals] -> ShowS
PropertyEquals -> String
(Int -> PropertyEquals -> ShowS)
-> (PropertyEquals -> String)
-> ([PropertyEquals] -> ShowS)
-> Show PropertyEquals
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PropertyEquals -> ShowS
showsPrec :: Int -> PropertyEquals -> ShowS
$cshow :: PropertyEquals -> String
show :: PropertyEquals -> String
$cshowList :: [PropertyEquals] -> ShowS
showList :: [PropertyEquals] -> ShowS
Show)

_PropertyEquals :: Name
_PropertyEquals = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PropertyEquals")

_PropertyEquals_lhs :: Name
_PropertyEquals_lhs = (String -> Name
Core.Name String
"lhs")

_PropertyEquals_rhs :: Name
_PropertyEquals_rhs = (String -> Name
Core.Name String
"rhs")

data VariableEquals = 
  VariableEquals {
    VariableEquals -> Variable
variableEqualsLhs :: Variable,
    VariableEquals -> Expression
variableEqualsRhs :: Expression}
  deriving (VariableEquals -> VariableEquals -> Bool
(VariableEquals -> VariableEquals -> Bool)
-> (VariableEquals -> VariableEquals -> Bool) -> Eq VariableEquals
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariableEquals -> VariableEquals -> Bool
== :: VariableEquals -> VariableEquals -> Bool
$c/= :: VariableEquals -> VariableEquals -> Bool
/= :: VariableEquals -> VariableEquals -> Bool
Eq, Eq VariableEquals
Eq VariableEquals =>
(VariableEquals -> VariableEquals -> Ordering)
-> (VariableEquals -> VariableEquals -> Bool)
-> (VariableEquals -> VariableEquals -> Bool)
-> (VariableEquals -> VariableEquals -> Bool)
-> (VariableEquals -> VariableEquals -> Bool)
-> (VariableEquals -> VariableEquals -> VariableEquals)
-> (VariableEquals -> VariableEquals -> VariableEquals)
-> Ord VariableEquals
VariableEquals -> VariableEquals -> Bool
VariableEquals -> VariableEquals -> Ordering
VariableEquals -> VariableEquals -> VariableEquals
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VariableEquals -> VariableEquals -> Ordering
compare :: VariableEquals -> VariableEquals -> Ordering
$c< :: VariableEquals -> VariableEquals -> Bool
< :: VariableEquals -> VariableEquals -> Bool
$c<= :: VariableEquals -> VariableEquals -> Bool
<= :: VariableEquals -> VariableEquals -> Bool
$c> :: VariableEquals -> VariableEquals -> Bool
> :: VariableEquals -> VariableEquals -> Bool
$c>= :: VariableEquals -> VariableEquals -> Bool
>= :: VariableEquals -> VariableEquals -> Bool
$cmax :: VariableEquals -> VariableEquals -> VariableEquals
max :: VariableEquals -> VariableEquals -> VariableEquals
$cmin :: VariableEquals -> VariableEquals -> VariableEquals
min :: VariableEquals -> VariableEquals -> VariableEquals
Ord, ReadPrec [VariableEquals]
ReadPrec VariableEquals
Int -> ReadS VariableEquals
ReadS [VariableEquals]
(Int -> ReadS VariableEquals)
-> ReadS [VariableEquals]
-> ReadPrec VariableEquals
-> ReadPrec [VariableEquals]
-> Read VariableEquals
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VariableEquals
readsPrec :: Int -> ReadS VariableEquals
$creadList :: ReadS [VariableEquals]
readList :: ReadS [VariableEquals]
$creadPrec :: ReadPrec VariableEquals
readPrec :: ReadPrec VariableEquals
$creadListPrec :: ReadPrec [VariableEquals]
readListPrec :: ReadPrec [VariableEquals]
Read, Int -> VariableEquals -> ShowS
[VariableEquals] -> ShowS
VariableEquals -> String
(Int -> VariableEquals -> ShowS)
-> (VariableEquals -> String)
-> ([VariableEquals] -> ShowS)
-> Show VariableEquals
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VariableEquals -> ShowS
showsPrec :: Int -> VariableEquals -> ShowS
$cshow :: VariableEquals -> String
show :: VariableEquals -> String
$cshowList :: [VariableEquals] -> ShowS
showList :: [VariableEquals] -> ShowS
Show)

_VariableEquals :: Name
_VariableEquals = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.VariableEquals")

_VariableEquals_lhs :: Name
_VariableEquals_lhs = (String -> Name
Core.Name String
"lhs")

_VariableEquals_rhs :: Name
_VariableEquals_rhs = (String -> Name
Core.Name String
"rhs")

data VariablePlusEquals = 
  VariablePlusEquals {
    VariablePlusEquals -> Variable
variablePlusEqualsLhs :: Variable,
    VariablePlusEquals -> Expression
variablePlusEqualsRhs :: Expression}
  deriving (VariablePlusEquals -> VariablePlusEquals -> Bool
(VariablePlusEquals -> VariablePlusEquals -> Bool)
-> (VariablePlusEquals -> VariablePlusEquals -> Bool)
-> Eq VariablePlusEquals
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariablePlusEquals -> VariablePlusEquals -> Bool
== :: VariablePlusEquals -> VariablePlusEquals -> Bool
$c/= :: VariablePlusEquals -> VariablePlusEquals -> Bool
/= :: VariablePlusEquals -> VariablePlusEquals -> Bool
Eq, Eq VariablePlusEquals
Eq VariablePlusEquals =>
(VariablePlusEquals -> VariablePlusEquals -> Ordering)
-> (VariablePlusEquals -> VariablePlusEquals -> Bool)
-> (VariablePlusEquals -> VariablePlusEquals -> Bool)
-> (VariablePlusEquals -> VariablePlusEquals -> Bool)
-> (VariablePlusEquals -> VariablePlusEquals -> Bool)
-> (VariablePlusEquals -> VariablePlusEquals -> VariablePlusEquals)
-> (VariablePlusEquals -> VariablePlusEquals -> VariablePlusEquals)
-> Ord VariablePlusEquals
VariablePlusEquals -> VariablePlusEquals -> Bool
VariablePlusEquals -> VariablePlusEquals -> Ordering
VariablePlusEquals -> VariablePlusEquals -> VariablePlusEquals
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VariablePlusEquals -> VariablePlusEquals -> Ordering
compare :: VariablePlusEquals -> VariablePlusEquals -> Ordering
$c< :: VariablePlusEquals -> VariablePlusEquals -> Bool
< :: VariablePlusEquals -> VariablePlusEquals -> Bool
$c<= :: VariablePlusEquals -> VariablePlusEquals -> Bool
<= :: VariablePlusEquals -> VariablePlusEquals -> Bool
$c> :: VariablePlusEquals -> VariablePlusEquals -> Bool
> :: VariablePlusEquals -> VariablePlusEquals -> Bool
$c>= :: VariablePlusEquals -> VariablePlusEquals -> Bool
>= :: VariablePlusEquals -> VariablePlusEquals -> Bool
$cmax :: VariablePlusEquals -> VariablePlusEquals -> VariablePlusEquals
max :: VariablePlusEquals -> VariablePlusEquals -> VariablePlusEquals
$cmin :: VariablePlusEquals -> VariablePlusEquals -> VariablePlusEquals
min :: VariablePlusEquals -> VariablePlusEquals -> VariablePlusEquals
Ord, ReadPrec [VariablePlusEquals]
ReadPrec VariablePlusEquals
Int -> ReadS VariablePlusEquals
ReadS [VariablePlusEquals]
(Int -> ReadS VariablePlusEquals)
-> ReadS [VariablePlusEquals]
-> ReadPrec VariablePlusEquals
-> ReadPrec [VariablePlusEquals]
-> Read VariablePlusEquals
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VariablePlusEquals
readsPrec :: Int -> ReadS VariablePlusEquals
$creadList :: ReadS [VariablePlusEquals]
readList :: ReadS [VariablePlusEquals]
$creadPrec :: ReadPrec VariablePlusEquals
readPrec :: ReadPrec VariablePlusEquals
$creadListPrec :: ReadPrec [VariablePlusEquals]
readListPrec :: ReadPrec [VariablePlusEquals]
Read, Int -> VariablePlusEquals -> ShowS
[VariablePlusEquals] -> ShowS
VariablePlusEquals -> String
(Int -> VariablePlusEquals -> ShowS)
-> (VariablePlusEquals -> String)
-> ([VariablePlusEquals] -> ShowS)
-> Show VariablePlusEquals
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VariablePlusEquals -> ShowS
showsPrec :: Int -> VariablePlusEquals -> ShowS
$cshow :: VariablePlusEquals -> String
show :: VariablePlusEquals -> String
$cshowList :: [VariablePlusEquals] -> ShowS
showList :: [VariablePlusEquals] -> ShowS
Show)

_VariablePlusEquals :: Name
_VariablePlusEquals = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.VariablePlusEquals")

_VariablePlusEquals_lhs :: Name
_VariablePlusEquals_lhs = (String -> Name
Core.Name String
"lhs")

_VariablePlusEquals_rhs :: Name
_VariablePlusEquals_rhs = (String -> Name
Core.Name String
"rhs")

data VariableAndNodeLabels = 
  VariableAndNodeLabels {
    VariableAndNodeLabels -> Variable
variableAndNodeLabelsVariable :: Variable,
    VariableAndNodeLabels -> NodeLabels
variableAndNodeLabelsLabels :: NodeLabels}
  deriving (VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
(VariableAndNodeLabels -> VariableAndNodeLabels -> Bool)
-> (VariableAndNodeLabels -> VariableAndNodeLabels -> Bool)
-> Eq VariableAndNodeLabels
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
== :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
$c/= :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
/= :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
Eq, Eq VariableAndNodeLabels
Eq VariableAndNodeLabels =>
(VariableAndNodeLabels -> VariableAndNodeLabels -> Ordering)
-> (VariableAndNodeLabels -> VariableAndNodeLabels -> Bool)
-> (VariableAndNodeLabels -> VariableAndNodeLabels -> Bool)
-> (VariableAndNodeLabels -> VariableAndNodeLabels -> Bool)
-> (VariableAndNodeLabels -> VariableAndNodeLabels -> Bool)
-> (VariableAndNodeLabels
    -> VariableAndNodeLabels -> VariableAndNodeLabels)
-> (VariableAndNodeLabels
    -> VariableAndNodeLabels -> VariableAndNodeLabels)
-> Ord VariableAndNodeLabels
VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
VariableAndNodeLabels -> VariableAndNodeLabels -> Ordering
VariableAndNodeLabels
-> VariableAndNodeLabels -> VariableAndNodeLabels
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VariableAndNodeLabels -> VariableAndNodeLabels -> Ordering
compare :: VariableAndNodeLabels -> VariableAndNodeLabels -> Ordering
$c< :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
< :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
$c<= :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
<= :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
$c> :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
> :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
$c>= :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
>= :: VariableAndNodeLabels -> VariableAndNodeLabels -> Bool
$cmax :: VariableAndNodeLabels
-> VariableAndNodeLabels -> VariableAndNodeLabels
max :: VariableAndNodeLabels
-> VariableAndNodeLabels -> VariableAndNodeLabels
$cmin :: VariableAndNodeLabels
-> VariableAndNodeLabels -> VariableAndNodeLabels
min :: VariableAndNodeLabels
-> VariableAndNodeLabels -> VariableAndNodeLabels
Ord, ReadPrec [VariableAndNodeLabels]
ReadPrec VariableAndNodeLabels
Int -> ReadS VariableAndNodeLabels
ReadS [VariableAndNodeLabels]
(Int -> ReadS VariableAndNodeLabels)
-> ReadS [VariableAndNodeLabels]
-> ReadPrec VariableAndNodeLabels
-> ReadPrec [VariableAndNodeLabels]
-> Read VariableAndNodeLabels
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VariableAndNodeLabels
readsPrec :: Int -> ReadS VariableAndNodeLabels
$creadList :: ReadS [VariableAndNodeLabels]
readList :: ReadS [VariableAndNodeLabels]
$creadPrec :: ReadPrec VariableAndNodeLabels
readPrec :: ReadPrec VariableAndNodeLabels
$creadListPrec :: ReadPrec [VariableAndNodeLabels]
readListPrec :: ReadPrec [VariableAndNodeLabels]
Read, Int -> VariableAndNodeLabels -> ShowS
[VariableAndNodeLabels] -> ShowS
VariableAndNodeLabels -> String
(Int -> VariableAndNodeLabels -> ShowS)
-> (VariableAndNodeLabels -> String)
-> ([VariableAndNodeLabels] -> ShowS)
-> Show VariableAndNodeLabels
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VariableAndNodeLabels -> ShowS
showsPrec :: Int -> VariableAndNodeLabels -> ShowS
$cshow :: VariableAndNodeLabels -> String
show :: VariableAndNodeLabels -> String
$cshowList :: [VariableAndNodeLabels] -> ShowS
showList :: [VariableAndNodeLabels] -> ShowS
Show)

_VariableAndNodeLabels :: Name
_VariableAndNodeLabels = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.VariableAndNodeLabels")

_VariableAndNodeLabels_variable :: Name
_VariableAndNodeLabels_variable = (String -> Name
Core.Name String
"variable")

_VariableAndNodeLabels_labels :: Name
_VariableAndNodeLabels_labels = (String -> Name
Core.Name String
"labels")

data Delete = 
  Delete {
    Delete -> Bool
deleteDetach :: Bool,
    Delete -> [Expression]
deleteExpressions :: [Expression]}
  deriving (Delete -> Delete -> Bool
(Delete -> Delete -> Bool)
-> (Delete -> Delete -> Bool) -> Eq Delete
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Delete -> Delete -> Bool
== :: Delete -> Delete -> Bool
$c/= :: Delete -> Delete -> Bool
/= :: Delete -> Delete -> Bool
Eq, Eq Delete
Eq Delete =>
(Delete -> Delete -> Ordering)
-> (Delete -> Delete -> Bool)
-> (Delete -> Delete -> Bool)
-> (Delete -> Delete -> Bool)
-> (Delete -> Delete -> Bool)
-> (Delete -> Delete -> Delete)
-> (Delete -> Delete -> Delete)
-> Ord Delete
Delete -> Delete -> Bool
Delete -> Delete -> Ordering
Delete -> Delete -> Delete
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Delete -> Delete -> Ordering
compare :: Delete -> Delete -> Ordering
$c< :: Delete -> Delete -> Bool
< :: Delete -> Delete -> Bool
$c<= :: Delete -> Delete -> Bool
<= :: Delete -> Delete -> Bool
$c> :: Delete -> Delete -> Bool
> :: Delete -> Delete -> Bool
$c>= :: Delete -> Delete -> Bool
>= :: Delete -> Delete -> Bool
$cmax :: Delete -> Delete -> Delete
max :: Delete -> Delete -> Delete
$cmin :: Delete -> Delete -> Delete
min :: Delete -> Delete -> Delete
Ord, ReadPrec [Delete]
ReadPrec Delete
Int -> ReadS Delete
ReadS [Delete]
(Int -> ReadS Delete)
-> ReadS [Delete]
-> ReadPrec Delete
-> ReadPrec [Delete]
-> Read Delete
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Delete
readsPrec :: Int -> ReadS Delete
$creadList :: ReadS [Delete]
readList :: ReadS [Delete]
$creadPrec :: ReadPrec Delete
readPrec :: ReadPrec Delete
$creadListPrec :: ReadPrec [Delete]
readListPrec :: ReadPrec [Delete]
Read, Int -> Delete -> ShowS
[Delete] -> ShowS
Delete -> String
(Int -> Delete -> ShowS)
-> (Delete -> String) -> ([Delete] -> ShowS) -> Show Delete
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Delete -> ShowS
showsPrec :: Int -> Delete -> ShowS
$cshow :: Delete -> String
show :: Delete -> String
$cshowList :: [Delete] -> ShowS
showList :: [Delete] -> ShowS
Show)

_Delete :: Name
_Delete = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Delete")

_Delete_detach :: Name
_Delete_detach = (String -> Name
Core.Name String
"detach")

_Delete_expressions :: Name
_Delete_expressions = (String -> Name
Core.Name String
"expressions")

newtype Remove = 
  Remove {
    Remove -> [RemoveItem]
unRemove :: [RemoveItem]}
  deriving (Remove -> Remove -> Bool
(Remove -> Remove -> Bool)
-> (Remove -> Remove -> Bool) -> Eq Remove
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Remove -> Remove -> Bool
== :: Remove -> Remove -> Bool
$c/= :: Remove -> Remove -> Bool
/= :: Remove -> Remove -> Bool
Eq, Eq Remove
Eq Remove =>
(Remove -> Remove -> Ordering)
-> (Remove -> Remove -> Bool)
-> (Remove -> Remove -> Bool)
-> (Remove -> Remove -> Bool)
-> (Remove -> Remove -> Bool)
-> (Remove -> Remove -> Remove)
-> (Remove -> Remove -> Remove)
-> Ord Remove
Remove -> Remove -> Bool
Remove -> Remove -> Ordering
Remove -> Remove -> Remove
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Remove -> Remove -> Ordering
compare :: Remove -> Remove -> Ordering
$c< :: Remove -> Remove -> Bool
< :: Remove -> Remove -> Bool
$c<= :: Remove -> Remove -> Bool
<= :: Remove -> Remove -> Bool
$c> :: Remove -> Remove -> Bool
> :: Remove -> Remove -> Bool
$c>= :: Remove -> Remove -> Bool
>= :: Remove -> Remove -> Bool
$cmax :: Remove -> Remove -> Remove
max :: Remove -> Remove -> Remove
$cmin :: Remove -> Remove -> Remove
min :: Remove -> Remove -> Remove
Ord, ReadPrec [Remove]
ReadPrec Remove
Int -> ReadS Remove
ReadS [Remove]
(Int -> ReadS Remove)
-> ReadS [Remove]
-> ReadPrec Remove
-> ReadPrec [Remove]
-> Read Remove
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Remove
readsPrec :: Int -> ReadS Remove
$creadList :: ReadS [Remove]
readList :: ReadS [Remove]
$creadPrec :: ReadPrec Remove
readPrec :: ReadPrec Remove
$creadListPrec :: ReadPrec [Remove]
readListPrec :: ReadPrec [Remove]
Read, Int -> Remove -> ShowS
[Remove] -> ShowS
Remove -> String
(Int -> Remove -> ShowS)
-> (Remove -> String) -> ([Remove] -> ShowS) -> Show Remove
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Remove -> ShowS
showsPrec :: Int -> Remove -> ShowS
$cshow :: Remove -> String
show :: Remove -> String
$cshowList :: [Remove] -> ShowS
showList :: [Remove] -> ShowS
Show)

_Remove :: Name
_Remove = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Remove")

data RemoveItem = 
  RemoveItemVariableLabels VariableAndNodeLabels |
  RemoveItemProperty PropertyExpression
  deriving (RemoveItem -> RemoveItem -> Bool
(RemoveItem -> RemoveItem -> Bool)
-> (RemoveItem -> RemoveItem -> Bool) -> Eq RemoveItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RemoveItem -> RemoveItem -> Bool
== :: RemoveItem -> RemoveItem -> Bool
$c/= :: RemoveItem -> RemoveItem -> Bool
/= :: RemoveItem -> RemoveItem -> Bool
Eq, Eq RemoveItem
Eq RemoveItem =>
(RemoveItem -> RemoveItem -> Ordering)
-> (RemoveItem -> RemoveItem -> Bool)
-> (RemoveItem -> RemoveItem -> Bool)
-> (RemoveItem -> RemoveItem -> Bool)
-> (RemoveItem -> RemoveItem -> Bool)
-> (RemoveItem -> RemoveItem -> RemoveItem)
-> (RemoveItem -> RemoveItem -> RemoveItem)
-> Ord RemoveItem
RemoveItem -> RemoveItem -> Bool
RemoveItem -> RemoveItem -> Ordering
RemoveItem -> RemoveItem -> RemoveItem
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RemoveItem -> RemoveItem -> Ordering
compare :: RemoveItem -> RemoveItem -> Ordering
$c< :: RemoveItem -> RemoveItem -> Bool
< :: RemoveItem -> RemoveItem -> Bool
$c<= :: RemoveItem -> RemoveItem -> Bool
<= :: RemoveItem -> RemoveItem -> Bool
$c> :: RemoveItem -> RemoveItem -> Bool
> :: RemoveItem -> RemoveItem -> Bool
$c>= :: RemoveItem -> RemoveItem -> Bool
>= :: RemoveItem -> RemoveItem -> Bool
$cmax :: RemoveItem -> RemoveItem -> RemoveItem
max :: RemoveItem -> RemoveItem -> RemoveItem
$cmin :: RemoveItem -> RemoveItem -> RemoveItem
min :: RemoveItem -> RemoveItem -> RemoveItem
Ord, ReadPrec [RemoveItem]
ReadPrec RemoveItem
Int -> ReadS RemoveItem
ReadS [RemoveItem]
(Int -> ReadS RemoveItem)
-> ReadS [RemoveItem]
-> ReadPrec RemoveItem
-> ReadPrec [RemoveItem]
-> Read RemoveItem
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RemoveItem
readsPrec :: Int -> ReadS RemoveItem
$creadList :: ReadS [RemoveItem]
readList :: ReadS [RemoveItem]
$creadPrec :: ReadPrec RemoveItem
readPrec :: ReadPrec RemoveItem
$creadListPrec :: ReadPrec [RemoveItem]
readListPrec :: ReadPrec [RemoveItem]
Read, Int -> RemoveItem -> ShowS
[RemoveItem] -> ShowS
RemoveItem -> String
(Int -> RemoveItem -> ShowS)
-> (RemoveItem -> String)
-> ([RemoveItem] -> ShowS)
-> Show RemoveItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RemoveItem -> ShowS
showsPrec :: Int -> RemoveItem -> ShowS
$cshow :: RemoveItem -> String
show :: RemoveItem -> String
$cshowList :: [RemoveItem] -> ShowS
showList :: [RemoveItem] -> ShowS
Show)

_RemoveItem :: Name
_RemoveItem = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.RemoveItem")

_RemoveItem_variableLabels :: Name
_RemoveItem_variableLabels = (String -> Name
Core.Name String
"variableLabels")

_RemoveItem_property :: Name
_RemoveItem_property = (String -> Name
Core.Name String
"property")

data InQueryCall = 
  InQueryCall {
    InQueryCall -> ExplicitProcedureInvocation
inQueryCallCall :: ExplicitProcedureInvocation,
    InQueryCall -> Maybe YieldItems
inQueryCallYieldItems :: (Maybe YieldItems)}
  deriving (InQueryCall -> InQueryCall -> Bool
(InQueryCall -> InQueryCall -> Bool)
-> (InQueryCall -> InQueryCall -> Bool) -> Eq InQueryCall
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InQueryCall -> InQueryCall -> Bool
== :: InQueryCall -> InQueryCall -> Bool
$c/= :: InQueryCall -> InQueryCall -> Bool
/= :: InQueryCall -> InQueryCall -> Bool
Eq, Eq InQueryCall
Eq InQueryCall =>
(InQueryCall -> InQueryCall -> Ordering)
-> (InQueryCall -> InQueryCall -> Bool)
-> (InQueryCall -> InQueryCall -> Bool)
-> (InQueryCall -> InQueryCall -> Bool)
-> (InQueryCall -> InQueryCall -> Bool)
-> (InQueryCall -> InQueryCall -> InQueryCall)
-> (InQueryCall -> InQueryCall -> InQueryCall)
-> Ord InQueryCall
InQueryCall -> InQueryCall -> Bool
InQueryCall -> InQueryCall -> Ordering
InQueryCall -> InQueryCall -> InQueryCall
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InQueryCall -> InQueryCall -> Ordering
compare :: InQueryCall -> InQueryCall -> Ordering
$c< :: InQueryCall -> InQueryCall -> Bool
< :: InQueryCall -> InQueryCall -> Bool
$c<= :: InQueryCall -> InQueryCall -> Bool
<= :: InQueryCall -> InQueryCall -> Bool
$c> :: InQueryCall -> InQueryCall -> Bool
> :: InQueryCall -> InQueryCall -> Bool
$c>= :: InQueryCall -> InQueryCall -> Bool
>= :: InQueryCall -> InQueryCall -> Bool
$cmax :: InQueryCall -> InQueryCall -> InQueryCall
max :: InQueryCall -> InQueryCall -> InQueryCall
$cmin :: InQueryCall -> InQueryCall -> InQueryCall
min :: InQueryCall -> InQueryCall -> InQueryCall
Ord, ReadPrec [InQueryCall]
ReadPrec InQueryCall
Int -> ReadS InQueryCall
ReadS [InQueryCall]
(Int -> ReadS InQueryCall)
-> ReadS [InQueryCall]
-> ReadPrec InQueryCall
-> ReadPrec [InQueryCall]
-> Read InQueryCall
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InQueryCall
readsPrec :: Int -> ReadS InQueryCall
$creadList :: ReadS [InQueryCall]
readList :: ReadS [InQueryCall]
$creadPrec :: ReadPrec InQueryCall
readPrec :: ReadPrec InQueryCall
$creadListPrec :: ReadPrec [InQueryCall]
readListPrec :: ReadPrec [InQueryCall]
Read, Int -> InQueryCall -> ShowS
[InQueryCall] -> ShowS
InQueryCall -> String
(Int -> InQueryCall -> ShowS)
-> (InQueryCall -> String)
-> ([InQueryCall] -> ShowS)
-> Show InQueryCall
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InQueryCall -> ShowS
showsPrec :: Int -> InQueryCall -> ShowS
$cshow :: InQueryCall -> String
show :: InQueryCall -> String
$cshowList :: [InQueryCall] -> ShowS
showList :: [InQueryCall] -> ShowS
Show)

_InQueryCall :: Name
_InQueryCall = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.InQueryCall")

_InQueryCall_call :: Name
_InQueryCall_call = (String -> Name
Core.Name String
"call")

_InQueryCall_yieldItems :: Name
_InQueryCall_yieldItems = (String -> Name
Core.Name String
"yieldItems")

data ProcedureInvocation = 
  ProcedureInvocationExplicit ExplicitProcedureInvocation |
  ProcedureInvocationImplicit ImplicitProcedureInvocation
  deriving (ProcedureInvocation -> ProcedureInvocation -> Bool
(ProcedureInvocation -> ProcedureInvocation -> Bool)
-> (ProcedureInvocation -> ProcedureInvocation -> Bool)
-> Eq ProcedureInvocation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProcedureInvocation -> ProcedureInvocation -> Bool
== :: ProcedureInvocation -> ProcedureInvocation -> Bool
$c/= :: ProcedureInvocation -> ProcedureInvocation -> Bool
/= :: ProcedureInvocation -> ProcedureInvocation -> Bool
Eq, Eq ProcedureInvocation
Eq ProcedureInvocation =>
(ProcedureInvocation -> ProcedureInvocation -> Ordering)
-> (ProcedureInvocation -> ProcedureInvocation -> Bool)
-> (ProcedureInvocation -> ProcedureInvocation -> Bool)
-> (ProcedureInvocation -> ProcedureInvocation -> Bool)
-> (ProcedureInvocation -> ProcedureInvocation -> Bool)
-> (ProcedureInvocation
    -> ProcedureInvocation -> ProcedureInvocation)
-> (ProcedureInvocation
    -> ProcedureInvocation -> ProcedureInvocation)
-> Ord ProcedureInvocation
ProcedureInvocation -> ProcedureInvocation -> Bool
ProcedureInvocation -> ProcedureInvocation -> Ordering
ProcedureInvocation -> ProcedureInvocation -> ProcedureInvocation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ProcedureInvocation -> ProcedureInvocation -> Ordering
compare :: ProcedureInvocation -> ProcedureInvocation -> Ordering
$c< :: ProcedureInvocation -> ProcedureInvocation -> Bool
< :: ProcedureInvocation -> ProcedureInvocation -> Bool
$c<= :: ProcedureInvocation -> ProcedureInvocation -> Bool
<= :: ProcedureInvocation -> ProcedureInvocation -> Bool
$c> :: ProcedureInvocation -> ProcedureInvocation -> Bool
> :: ProcedureInvocation -> ProcedureInvocation -> Bool
$c>= :: ProcedureInvocation -> ProcedureInvocation -> Bool
>= :: ProcedureInvocation -> ProcedureInvocation -> Bool
$cmax :: ProcedureInvocation -> ProcedureInvocation -> ProcedureInvocation
max :: ProcedureInvocation -> ProcedureInvocation -> ProcedureInvocation
$cmin :: ProcedureInvocation -> ProcedureInvocation -> ProcedureInvocation
min :: ProcedureInvocation -> ProcedureInvocation -> ProcedureInvocation
Ord, ReadPrec [ProcedureInvocation]
ReadPrec ProcedureInvocation
Int -> ReadS ProcedureInvocation
ReadS [ProcedureInvocation]
(Int -> ReadS ProcedureInvocation)
-> ReadS [ProcedureInvocation]
-> ReadPrec ProcedureInvocation
-> ReadPrec [ProcedureInvocation]
-> Read ProcedureInvocation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ProcedureInvocation
readsPrec :: Int -> ReadS ProcedureInvocation
$creadList :: ReadS [ProcedureInvocation]
readList :: ReadS [ProcedureInvocation]
$creadPrec :: ReadPrec ProcedureInvocation
readPrec :: ReadPrec ProcedureInvocation
$creadListPrec :: ReadPrec [ProcedureInvocation]
readListPrec :: ReadPrec [ProcedureInvocation]
Read, Int -> ProcedureInvocation -> ShowS
[ProcedureInvocation] -> ShowS
ProcedureInvocation -> String
(Int -> ProcedureInvocation -> ShowS)
-> (ProcedureInvocation -> String)
-> ([ProcedureInvocation] -> ShowS)
-> Show ProcedureInvocation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProcedureInvocation -> ShowS
showsPrec :: Int -> ProcedureInvocation -> ShowS
$cshow :: ProcedureInvocation -> String
show :: ProcedureInvocation -> String
$cshowList :: [ProcedureInvocation] -> ShowS
showList :: [ProcedureInvocation] -> ShowS
Show)

_ProcedureInvocation :: Name
_ProcedureInvocation = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ProcedureInvocation")

_ProcedureInvocation_explicit :: Name
_ProcedureInvocation_explicit = (String -> Name
Core.Name String
"explicit")

_ProcedureInvocation_implicit :: Name
_ProcedureInvocation_implicit = (String -> Name
Core.Name String
"implicit")

data StarOrYieldItems = 
  StarOrYieldItemsStar  |
  StarOrYieldItemsItems YieldItems
  deriving (StarOrYieldItems -> StarOrYieldItems -> Bool
(StarOrYieldItems -> StarOrYieldItems -> Bool)
-> (StarOrYieldItems -> StarOrYieldItems -> Bool)
-> Eq StarOrYieldItems
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StarOrYieldItems -> StarOrYieldItems -> Bool
== :: StarOrYieldItems -> StarOrYieldItems -> Bool
$c/= :: StarOrYieldItems -> StarOrYieldItems -> Bool
/= :: StarOrYieldItems -> StarOrYieldItems -> Bool
Eq, Eq StarOrYieldItems
Eq StarOrYieldItems =>
(StarOrYieldItems -> StarOrYieldItems -> Ordering)
-> (StarOrYieldItems -> StarOrYieldItems -> Bool)
-> (StarOrYieldItems -> StarOrYieldItems -> Bool)
-> (StarOrYieldItems -> StarOrYieldItems -> Bool)
-> (StarOrYieldItems -> StarOrYieldItems -> Bool)
-> (StarOrYieldItems -> StarOrYieldItems -> StarOrYieldItems)
-> (StarOrYieldItems -> StarOrYieldItems -> StarOrYieldItems)
-> Ord StarOrYieldItems
StarOrYieldItems -> StarOrYieldItems -> Bool
StarOrYieldItems -> StarOrYieldItems -> Ordering
StarOrYieldItems -> StarOrYieldItems -> StarOrYieldItems
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StarOrYieldItems -> StarOrYieldItems -> Ordering
compare :: StarOrYieldItems -> StarOrYieldItems -> Ordering
$c< :: StarOrYieldItems -> StarOrYieldItems -> Bool
< :: StarOrYieldItems -> StarOrYieldItems -> Bool
$c<= :: StarOrYieldItems -> StarOrYieldItems -> Bool
<= :: StarOrYieldItems -> StarOrYieldItems -> Bool
$c> :: StarOrYieldItems -> StarOrYieldItems -> Bool
> :: StarOrYieldItems -> StarOrYieldItems -> Bool
$c>= :: StarOrYieldItems -> StarOrYieldItems -> Bool
>= :: StarOrYieldItems -> StarOrYieldItems -> Bool
$cmax :: StarOrYieldItems -> StarOrYieldItems -> StarOrYieldItems
max :: StarOrYieldItems -> StarOrYieldItems -> StarOrYieldItems
$cmin :: StarOrYieldItems -> StarOrYieldItems -> StarOrYieldItems
min :: StarOrYieldItems -> StarOrYieldItems -> StarOrYieldItems
Ord, ReadPrec [StarOrYieldItems]
ReadPrec StarOrYieldItems
Int -> ReadS StarOrYieldItems
ReadS [StarOrYieldItems]
(Int -> ReadS StarOrYieldItems)
-> ReadS [StarOrYieldItems]
-> ReadPrec StarOrYieldItems
-> ReadPrec [StarOrYieldItems]
-> Read StarOrYieldItems
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StarOrYieldItems
readsPrec :: Int -> ReadS StarOrYieldItems
$creadList :: ReadS [StarOrYieldItems]
readList :: ReadS [StarOrYieldItems]
$creadPrec :: ReadPrec StarOrYieldItems
readPrec :: ReadPrec StarOrYieldItems
$creadListPrec :: ReadPrec [StarOrYieldItems]
readListPrec :: ReadPrec [StarOrYieldItems]
Read, Int -> StarOrYieldItems -> ShowS
[StarOrYieldItems] -> ShowS
StarOrYieldItems -> String
(Int -> StarOrYieldItems -> ShowS)
-> (StarOrYieldItems -> String)
-> ([StarOrYieldItems] -> ShowS)
-> Show StarOrYieldItems
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StarOrYieldItems -> ShowS
showsPrec :: Int -> StarOrYieldItems -> ShowS
$cshow :: StarOrYieldItems -> String
show :: StarOrYieldItems -> String
$cshowList :: [StarOrYieldItems] -> ShowS
showList :: [StarOrYieldItems] -> ShowS
Show)

_StarOrYieldItems :: Name
_StarOrYieldItems = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.StarOrYieldItems")

_StarOrYieldItems_star :: Name
_StarOrYieldItems_star = (String -> Name
Core.Name String
"star")

_StarOrYieldItems_items :: Name
_StarOrYieldItems_items = (String -> Name
Core.Name String
"items")

data StandaloneCall = 
  StandaloneCall {
    StandaloneCall -> ProcedureInvocation
standaloneCallCall :: ProcedureInvocation,
    StandaloneCall -> Maybe StarOrYieldItems
standaloneCallYieldItems :: (Maybe StarOrYieldItems)}
  deriving (StandaloneCall -> StandaloneCall -> Bool
(StandaloneCall -> StandaloneCall -> Bool)
-> (StandaloneCall -> StandaloneCall -> Bool) -> Eq StandaloneCall
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StandaloneCall -> StandaloneCall -> Bool
== :: StandaloneCall -> StandaloneCall -> Bool
$c/= :: StandaloneCall -> StandaloneCall -> Bool
/= :: StandaloneCall -> StandaloneCall -> Bool
Eq, Eq StandaloneCall
Eq StandaloneCall =>
(StandaloneCall -> StandaloneCall -> Ordering)
-> (StandaloneCall -> StandaloneCall -> Bool)
-> (StandaloneCall -> StandaloneCall -> Bool)
-> (StandaloneCall -> StandaloneCall -> Bool)
-> (StandaloneCall -> StandaloneCall -> Bool)
-> (StandaloneCall -> StandaloneCall -> StandaloneCall)
-> (StandaloneCall -> StandaloneCall -> StandaloneCall)
-> Ord StandaloneCall
StandaloneCall -> StandaloneCall -> Bool
StandaloneCall -> StandaloneCall -> Ordering
StandaloneCall -> StandaloneCall -> StandaloneCall
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StandaloneCall -> StandaloneCall -> Ordering
compare :: StandaloneCall -> StandaloneCall -> Ordering
$c< :: StandaloneCall -> StandaloneCall -> Bool
< :: StandaloneCall -> StandaloneCall -> Bool
$c<= :: StandaloneCall -> StandaloneCall -> Bool
<= :: StandaloneCall -> StandaloneCall -> Bool
$c> :: StandaloneCall -> StandaloneCall -> Bool
> :: StandaloneCall -> StandaloneCall -> Bool
$c>= :: StandaloneCall -> StandaloneCall -> Bool
>= :: StandaloneCall -> StandaloneCall -> Bool
$cmax :: StandaloneCall -> StandaloneCall -> StandaloneCall
max :: StandaloneCall -> StandaloneCall -> StandaloneCall
$cmin :: StandaloneCall -> StandaloneCall -> StandaloneCall
min :: StandaloneCall -> StandaloneCall -> StandaloneCall
Ord, ReadPrec [StandaloneCall]
ReadPrec StandaloneCall
Int -> ReadS StandaloneCall
ReadS [StandaloneCall]
(Int -> ReadS StandaloneCall)
-> ReadS [StandaloneCall]
-> ReadPrec StandaloneCall
-> ReadPrec [StandaloneCall]
-> Read StandaloneCall
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StandaloneCall
readsPrec :: Int -> ReadS StandaloneCall
$creadList :: ReadS [StandaloneCall]
readList :: ReadS [StandaloneCall]
$creadPrec :: ReadPrec StandaloneCall
readPrec :: ReadPrec StandaloneCall
$creadListPrec :: ReadPrec [StandaloneCall]
readListPrec :: ReadPrec [StandaloneCall]
Read, Int -> StandaloneCall -> ShowS
[StandaloneCall] -> ShowS
StandaloneCall -> String
(Int -> StandaloneCall -> ShowS)
-> (StandaloneCall -> String)
-> ([StandaloneCall] -> ShowS)
-> Show StandaloneCall
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StandaloneCall -> ShowS
showsPrec :: Int -> StandaloneCall -> ShowS
$cshow :: StandaloneCall -> String
show :: StandaloneCall -> String
$cshowList :: [StandaloneCall] -> ShowS
showList :: [StandaloneCall] -> ShowS
Show)

_StandaloneCall :: Name
_StandaloneCall = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.StandaloneCall")

_StandaloneCall_call :: Name
_StandaloneCall_call = (String -> Name
Core.Name String
"call")

_StandaloneCall_yieldItems :: Name
_StandaloneCall_yieldItems = (String -> Name
Core.Name String
"yieldItems")

data YieldItems = 
  YieldItems {
    YieldItems -> [YieldItem]
yieldItemsItems :: [YieldItem],
    YieldItems -> Maybe Where
yieldItemsWhere :: (Maybe Where)}
  deriving (YieldItems -> YieldItems -> Bool
(YieldItems -> YieldItems -> Bool)
-> (YieldItems -> YieldItems -> Bool) -> Eq YieldItems
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: YieldItems -> YieldItems -> Bool
== :: YieldItems -> YieldItems -> Bool
$c/= :: YieldItems -> YieldItems -> Bool
/= :: YieldItems -> YieldItems -> Bool
Eq, Eq YieldItems
Eq YieldItems =>
(YieldItems -> YieldItems -> Ordering)
-> (YieldItems -> YieldItems -> Bool)
-> (YieldItems -> YieldItems -> Bool)
-> (YieldItems -> YieldItems -> Bool)
-> (YieldItems -> YieldItems -> Bool)
-> (YieldItems -> YieldItems -> YieldItems)
-> (YieldItems -> YieldItems -> YieldItems)
-> Ord YieldItems
YieldItems -> YieldItems -> Bool
YieldItems -> YieldItems -> Ordering
YieldItems -> YieldItems -> YieldItems
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: YieldItems -> YieldItems -> Ordering
compare :: YieldItems -> YieldItems -> Ordering
$c< :: YieldItems -> YieldItems -> Bool
< :: YieldItems -> YieldItems -> Bool
$c<= :: YieldItems -> YieldItems -> Bool
<= :: YieldItems -> YieldItems -> Bool
$c> :: YieldItems -> YieldItems -> Bool
> :: YieldItems -> YieldItems -> Bool
$c>= :: YieldItems -> YieldItems -> Bool
>= :: YieldItems -> YieldItems -> Bool
$cmax :: YieldItems -> YieldItems -> YieldItems
max :: YieldItems -> YieldItems -> YieldItems
$cmin :: YieldItems -> YieldItems -> YieldItems
min :: YieldItems -> YieldItems -> YieldItems
Ord, ReadPrec [YieldItems]
ReadPrec YieldItems
Int -> ReadS YieldItems
ReadS [YieldItems]
(Int -> ReadS YieldItems)
-> ReadS [YieldItems]
-> ReadPrec YieldItems
-> ReadPrec [YieldItems]
-> Read YieldItems
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS YieldItems
readsPrec :: Int -> ReadS YieldItems
$creadList :: ReadS [YieldItems]
readList :: ReadS [YieldItems]
$creadPrec :: ReadPrec YieldItems
readPrec :: ReadPrec YieldItems
$creadListPrec :: ReadPrec [YieldItems]
readListPrec :: ReadPrec [YieldItems]
Read, Int -> YieldItems -> ShowS
[YieldItems] -> ShowS
YieldItems -> String
(Int -> YieldItems -> ShowS)
-> (YieldItems -> String)
-> ([YieldItems] -> ShowS)
-> Show YieldItems
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> YieldItems -> ShowS
showsPrec :: Int -> YieldItems -> ShowS
$cshow :: YieldItems -> String
show :: YieldItems -> String
$cshowList :: [YieldItems] -> ShowS
showList :: [YieldItems] -> ShowS
Show)

_YieldItems :: Name
_YieldItems = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.YieldItems")

_YieldItems_items :: Name
_YieldItems_items = (String -> Name
Core.Name String
"items")

_YieldItems_where :: Name
_YieldItems_where = (String -> Name
Core.Name String
"where")

data YieldItem = 
  YieldItem {
    YieldItem -> Maybe ProcedureResultField
yieldItemField :: (Maybe ProcedureResultField),
    YieldItem -> Variable
yieldItemVariable :: Variable}
  deriving (YieldItem -> YieldItem -> Bool
(YieldItem -> YieldItem -> Bool)
-> (YieldItem -> YieldItem -> Bool) -> Eq YieldItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: YieldItem -> YieldItem -> Bool
== :: YieldItem -> YieldItem -> Bool
$c/= :: YieldItem -> YieldItem -> Bool
/= :: YieldItem -> YieldItem -> Bool
Eq, Eq YieldItem
Eq YieldItem =>
(YieldItem -> YieldItem -> Ordering)
-> (YieldItem -> YieldItem -> Bool)
-> (YieldItem -> YieldItem -> Bool)
-> (YieldItem -> YieldItem -> Bool)
-> (YieldItem -> YieldItem -> Bool)
-> (YieldItem -> YieldItem -> YieldItem)
-> (YieldItem -> YieldItem -> YieldItem)
-> Ord YieldItem
YieldItem -> YieldItem -> Bool
YieldItem -> YieldItem -> Ordering
YieldItem -> YieldItem -> YieldItem
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: YieldItem -> YieldItem -> Ordering
compare :: YieldItem -> YieldItem -> Ordering
$c< :: YieldItem -> YieldItem -> Bool
< :: YieldItem -> YieldItem -> Bool
$c<= :: YieldItem -> YieldItem -> Bool
<= :: YieldItem -> YieldItem -> Bool
$c> :: YieldItem -> YieldItem -> Bool
> :: YieldItem -> YieldItem -> Bool
$c>= :: YieldItem -> YieldItem -> Bool
>= :: YieldItem -> YieldItem -> Bool
$cmax :: YieldItem -> YieldItem -> YieldItem
max :: YieldItem -> YieldItem -> YieldItem
$cmin :: YieldItem -> YieldItem -> YieldItem
min :: YieldItem -> YieldItem -> YieldItem
Ord, ReadPrec [YieldItem]
ReadPrec YieldItem
Int -> ReadS YieldItem
ReadS [YieldItem]
(Int -> ReadS YieldItem)
-> ReadS [YieldItem]
-> ReadPrec YieldItem
-> ReadPrec [YieldItem]
-> Read YieldItem
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS YieldItem
readsPrec :: Int -> ReadS YieldItem
$creadList :: ReadS [YieldItem]
readList :: ReadS [YieldItem]
$creadPrec :: ReadPrec YieldItem
readPrec :: ReadPrec YieldItem
$creadListPrec :: ReadPrec [YieldItem]
readListPrec :: ReadPrec [YieldItem]
Read, Int -> YieldItem -> ShowS
[YieldItem] -> ShowS
YieldItem -> String
(Int -> YieldItem -> ShowS)
-> (YieldItem -> String)
-> ([YieldItem] -> ShowS)
-> Show YieldItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> YieldItem -> ShowS
showsPrec :: Int -> YieldItem -> ShowS
$cshow :: YieldItem -> String
show :: YieldItem -> String
$cshowList :: [YieldItem] -> ShowS
showList :: [YieldItem] -> ShowS
Show)

_YieldItem :: Name
_YieldItem = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.YieldItem")

_YieldItem_field :: Name
_YieldItem_field = (String -> Name
Core.Name String
"field")

_YieldItem_variable :: Name
_YieldItem_variable = (String -> Name
Core.Name String
"variable")

data With = 
  With {
    With -> ProjectionBody
withProjection :: ProjectionBody,
    With -> Maybe Where
withWhere :: (Maybe Where)}
  deriving (With -> With -> Bool
(With -> With -> Bool) -> (With -> With -> Bool) -> Eq With
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: With -> With -> Bool
== :: With -> With -> Bool
$c/= :: With -> With -> Bool
/= :: With -> With -> Bool
Eq, Eq With
Eq With =>
(With -> With -> Ordering)
-> (With -> With -> Bool)
-> (With -> With -> Bool)
-> (With -> With -> Bool)
-> (With -> With -> Bool)
-> (With -> With -> With)
-> (With -> With -> With)
-> Ord With
With -> With -> Bool
With -> With -> Ordering
With -> With -> With
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: With -> With -> Ordering
compare :: With -> With -> Ordering
$c< :: With -> With -> Bool
< :: With -> With -> Bool
$c<= :: With -> With -> Bool
<= :: With -> With -> Bool
$c> :: With -> With -> Bool
> :: With -> With -> Bool
$c>= :: With -> With -> Bool
>= :: With -> With -> Bool
$cmax :: With -> With -> With
max :: With -> With -> With
$cmin :: With -> With -> With
min :: With -> With -> With
Ord, ReadPrec [With]
ReadPrec With
Int -> ReadS With
ReadS [With]
(Int -> ReadS With)
-> ReadS [With] -> ReadPrec With -> ReadPrec [With] -> Read With
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS With
readsPrec :: Int -> ReadS With
$creadList :: ReadS [With]
readList :: ReadS [With]
$creadPrec :: ReadPrec With
readPrec :: ReadPrec With
$creadListPrec :: ReadPrec [With]
readListPrec :: ReadPrec [With]
Read, Int -> With -> ShowS
[With] -> ShowS
With -> String
(Int -> With -> ShowS)
-> (With -> String) -> ([With] -> ShowS) -> Show With
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> With -> ShowS
showsPrec :: Int -> With -> ShowS
$cshow :: With -> String
show :: With -> String
$cshowList :: [With] -> ShowS
showList :: [With] -> ShowS
Show)

_With :: Name
_With = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.With")

_With_projection :: Name
_With_projection = (String -> Name
Core.Name String
"projection")

_With_where :: Name
_With_where = (String -> Name
Core.Name String
"where")

newtype Return = 
  Return {
    Return -> ProjectionBody
unReturn :: ProjectionBody}
  deriving (Return -> Return -> Bool
(Return -> Return -> Bool)
-> (Return -> Return -> Bool) -> Eq Return
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Return -> Return -> Bool
== :: Return -> Return -> Bool
$c/= :: Return -> Return -> Bool
/= :: Return -> Return -> Bool
Eq, Eq Return
Eq Return =>
(Return -> Return -> Ordering)
-> (Return -> Return -> Bool)
-> (Return -> Return -> Bool)
-> (Return -> Return -> Bool)
-> (Return -> Return -> Bool)
-> (Return -> Return -> Return)
-> (Return -> Return -> Return)
-> Ord Return
Return -> Return -> Bool
Return -> Return -> Ordering
Return -> Return -> Return
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Return -> Return -> Ordering
compare :: Return -> Return -> Ordering
$c< :: Return -> Return -> Bool
< :: Return -> Return -> Bool
$c<= :: Return -> Return -> Bool
<= :: Return -> Return -> Bool
$c> :: Return -> Return -> Bool
> :: Return -> Return -> Bool
$c>= :: Return -> Return -> Bool
>= :: Return -> Return -> Bool
$cmax :: Return -> Return -> Return
max :: Return -> Return -> Return
$cmin :: Return -> Return -> Return
min :: Return -> Return -> Return
Ord, ReadPrec [Return]
ReadPrec Return
Int -> ReadS Return
ReadS [Return]
(Int -> ReadS Return)
-> ReadS [Return]
-> ReadPrec Return
-> ReadPrec [Return]
-> Read Return
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Return
readsPrec :: Int -> ReadS Return
$creadList :: ReadS [Return]
readList :: ReadS [Return]
$creadPrec :: ReadPrec Return
readPrec :: ReadPrec Return
$creadListPrec :: ReadPrec [Return]
readListPrec :: ReadPrec [Return]
Read, Int -> Return -> ShowS
[Return] -> ShowS
Return -> String
(Int -> Return -> ShowS)
-> (Return -> String) -> ([Return] -> ShowS) -> Show Return
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Return -> ShowS
showsPrec :: Int -> Return -> ShowS
$cshow :: Return -> String
show :: Return -> String
$cshowList :: [Return] -> ShowS
showList :: [Return] -> ShowS
Show)

_Return :: Name
_Return = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Return")

data ProjectionBody = 
  ProjectionBody {
    ProjectionBody -> Bool
projectionBodyDistinct :: Bool,
    ProjectionBody -> ProjectionItems
projectionBodyProjectionItems :: ProjectionItems,
    ProjectionBody -> Maybe Order
projectionBodyOrder :: (Maybe Order),
    ProjectionBody -> Maybe Skip
projectionBodySkip :: (Maybe Skip),
    ProjectionBody -> Maybe Limit
projectionBodyLimit :: (Maybe Limit)}
  deriving (ProjectionBody -> ProjectionBody -> Bool
(ProjectionBody -> ProjectionBody -> Bool)
-> (ProjectionBody -> ProjectionBody -> Bool) -> Eq ProjectionBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectionBody -> ProjectionBody -> Bool
== :: ProjectionBody -> ProjectionBody -> Bool
$c/= :: ProjectionBody -> ProjectionBody -> Bool
/= :: ProjectionBody -> ProjectionBody -> Bool
Eq, Eq ProjectionBody
Eq ProjectionBody =>
(ProjectionBody -> ProjectionBody -> Ordering)
-> (ProjectionBody -> ProjectionBody -> Bool)
-> (ProjectionBody -> ProjectionBody -> Bool)
-> (ProjectionBody -> ProjectionBody -> Bool)
-> (ProjectionBody -> ProjectionBody -> Bool)
-> (ProjectionBody -> ProjectionBody -> ProjectionBody)
-> (ProjectionBody -> ProjectionBody -> ProjectionBody)
-> Ord ProjectionBody
ProjectionBody -> ProjectionBody -> Bool
ProjectionBody -> ProjectionBody -> Ordering
ProjectionBody -> ProjectionBody -> ProjectionBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ProjectionBody -> ProjectionBody -> Ordering
compare :: ProjectionBody -> ProjectionBody -> Ordering
$c< :: ProjectionBody -> ProjectionBody -> Bool
< :: ProjectionBody -> ProjectionBody -> Bool
$c<= :: ProjectionBody -> ProjectionBody -> Bool
<= :: ProjectionBody -> ProjectionBody -> Bool
$c> :: ProjectionBody -> ProjectionBody -> Bool
> :: ProjectionBody -> ProjectionBody -> Bool
$c>= :: ProjectionBody -> ProjectionBody -> Bool
>= :: ProjectionBody -> ProjectionBody -> Bool
$cmax :: ProjectionBody -> ProjectionBody -> ProjectionBody
max :: ProjectionBody -> ProjectionBody -> ProjectionBody
$cmin :: ProjectionBody -> ProjectionBody -> ProjectionBody
min :: ProjectionBody -> ProjectionBody -> ProjectionBody
Ord, ReadPrec [ProjectionBody]
ReadPrec ProjectionBody
Int -> ReadS ProjectionBody
ReadS [ProjectionBody]
(Int -> ReadS ProjectionBody)
-> ReadS [ProjectionBody]
-> ReadPrec ProjectionBody
-> ReadPrec [ProjectionBody]
-> Read ProjectionBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ProjectionBody
readsPrec :: Int -> ReadS ProjectionBody
$creadList :: ReadS [ProjectionBody]
readList :: ReadS [ProjectionBody]
$creadPrec :: ReadPrec ProjectionBody
readPrec :: ReadPrec ProjectionBody
$creadListPrec :: ReadPrec [ProjectionBody]
readListPrec :: ReadPrec [ProjectionBody]
Read, Int -> ProjectionBody -> ShowS
[ProjectionBody] -> ShowS
ProjectionBody -> String
(Int -> ProjectionBody -> ShowS)
-> (ProjectionBody -> String)
-> ([ProjectionBody] -> ShowS)
-> Show ProjectionBody
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectionBody -> ShowS
showsPrec :: Int -> ProjectionBody -> ShowS
$cshow :: ProjectionBody -> String
show :: ProjectionBody -> String
$cshowList :: [ProjectionBody] -> ShowS
showList :: [ProjectionBody] -> ShowS
Show)

_ProjectionBody :: Name
_ProjectionBody = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ProjectionBody")

_ProjectionBody_distinct :: Name
_ProjectionBody_distinct = (String -> Name
Core.Name String
"distinct")

_ProjectionBody_projectionItems :: Name
_ProjectionBody_projectionItems = (String -> Name
Core.Name String
"projectionItems")

_ProjectionBody_order :: Name
_ProjectionBody_order = (String -> Name
Core.Name String
"order")

_ProjectionBody_skip :: Name
_ProjectionBody_skip = (String -> Name
Core.Name String
"skip")

_ProjectionBody_limit :: Name
_ProjectionBody_limit = (String -> Name
Core.Name String
"limit")

data ProjectionItems = 
  ProjectionItems {
    ProjectionItems -> Bool
projectionItemsStar :: Bool,
    ProjectionItems -> [ProjectionItem]
projectionItemsExplicit :: [ProjectionItem]}
  deriving (ProjectionItems -> ProjectionItems -> Bool
(ProjectionItems -> ProjectionItems -> Bool)
-> (ProjectionItems -> ProjectionItems -> Bool)
-> Eq ProjectionItems
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectionItems -> ProjectionItems -> Bool
== :: ProjectionItems -> ProjectionItems -> Bool
$c/= :: ProjectionItems -> ProjectionItems -> Bool
/= :: ProjectionItems -> ProjectionItems -> Bool
Eq, Eq ProjectionItems
Eq ProjectionItems =>
(ProjectionItems -> ProjectionItems -> Ordering)
-> (ProjectionItems -> ProjectionItems -> Bool)
-> (ProjectionItems -> ProjectionItems -> Bool)
-> (ProjectionItems -> ProjectionItems -> Bool)
-> (ProjectionItems -> ProjectionItems -> Bool)
-> (ProjectionItems -> ProjectionItems -> ProjectionItems)
-> (ProjectionItems -> ProjectionItems -> ProjectionItems)
-> Ord ProjectionItems
ProjectionItems -> ProjectionItems -> Bool
ProjectionItems -> ProjectionItems -> Ordering
ProjectionItems -> ProjectionItems -> ProjectionItems
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ProjectionItems -> ProjectionItems -> Ordering
compare :: ProjectionItems -> ProjectionItems -> Ordering
$c< :: ProjectionItems -> ProjectionItems -> Bool
< :: ProjectionItems -> ProjectionItems -> Bool
$c<= :: ProjectionItems -> ProjectionItems -> Bool
<= :: ProjectionItems -> ProjectionItems -> Bool
$c> :: ProjectionItems -> ProjectionItems -> Bool
> :: ProjectionItems -> ProjectionItems -> Bool
$c>= :: ProjectionItems -> ProjectionItems -> Bool
>= :: ProjectionItems -> ProjectionItems -> Bool
$cmax :: ProjectionItems -> ProjectionItems -> ProjectionItems
max :: ProjectionItems -> ProjectionItems -> ProjectionItems
$cmin :: ProjectionItems -> ProjectionItems -> ProjectionItems
min :: ProjectionItems -> ProjectionItems -> ProjectionItems
Ord, ReadPrec [ProjectionItems]
ReadPrec ProjectionItems
Int -> ReadS ProjectionItems
ReadS [ProjectionItems]
(Int -> ReadS ProjectionItems)
-> ReadS [ProjectionItems]
-> ReadPrec ProjectionItems
-> ReadPrec [ProjectionItems]
-> Read ProjectionItems
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ProjectionItems
readsPrec :: Int -> ReadS ProjectionItems
$creadList :: ReadS [ProjectionItems]
readList :: ReadS [ProjectionItems]
$creadPrec :: ReadPrec ProjectionItems
readPrec :: ReadPrec ProjectionItems
$creadListPrec :: ReadPrec [ProjectionItems]
readListPrec :: ReadPrec [ProjectionItems]
Read, Int -> ProjectionItems -> ShowS
[ProjectionItems] -> ShowS
ProjectionItems -> String
(Int -> ProjectionItems -> ShowS)
-> (ProjectionItems -> String)
-> ([ProjectionItems] -> ShowS)
-> Show ProjectionItems
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectionItems -> ShowS
showsPrec :: Int -> ProjectionItems -> ShowS
$cshow :: ProjectionItems -> String
show :: ProjectionItems -> String
$cshowList :: [ProjectionItems] -> ShowS
showList :: [ProjectionItems] -> ShowS
Show)

_ProjectionItems :: Name
_ProjectionItems = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ProjectionItems")

_ProjectionItems_star :: Name
_ProjectionItems_star = (String -> Name
Core.Name String
"star")

_ProjectionItems_explicit :: Name
_ProjectionItems_explicit = (String -> Name
Core.Name String
"explicit")

data ProjectionItem = 
  ProjectionItem {
    ProjectionItem -> Expression
projectionItemExpression :: Expression,
    ProjectionItem -> Maybe Variable
projectionItemVariable :: (Maybe Variable)}
  deriving (ProjectionItem -> ProjectionItem -> Bool
(ProjectionItem -> ProjectionItem -> Bool)
-> (ProjectionItem -> ProjectionItem -> Bool) -> Eq ProjectionItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectionItem -> ProjectionItem -> Bool
== :: ProjectionItem -> ProjectionItem -> Bool
$c/= :: ProjectionItem -> ProjectionItem -> Bool
/= :: ProjectionItem -> ProjectionItem -> Bool
Eq, Eq ProjectionItem
Eq ProjectionItem =>
(ProjectionItem -> ProjectionItem -> Ordering)
-> (ProjectionItem -> ProjectionItem -> Bool)
-> (ProjectionItem -> ProjectionItem -> Bool)
-> (ProjectionItem -> ProjectionItem -> Bool)
-> (ProjectionItem -> ProjectionItem -> Bool)
-> (ProjectionItem -> ProjectionItem -> ProjectionItem)
-> (ProjectionItem -> ProjectionItem -> ProjectionItem)
-> Ord ProjectionItem
ProjectionItem -> ProjectionItem -> Bool
ProjectionItem -> ProjectionItem -> Ordering
ProjectionItem -> ProjectionItem -> ProjectionItem
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ProjectionItem -> ProjectionItem -> Ordering
compare :: ProjectionItem -> ProjectionItem -> Ordering
$c< :: ProjectionItem -> ProjectionItem -> Bool
< :: ProjectionItem -> ProjectionItem -> Bool
$c<= :: ProjectionItem -> ProjectionItem -> Bool
<= :: ProjectionItem -> ProjectionItem -> Bool
$c> :: ProjectionItem -> ProjectionItem -> Bool
> :: ProjectionItem -> ProjectionItem -> Bool
$c>= :: ProjectionItem -> ProjectionItem -> Bool
>= :: ProjectionItem -> ProjectionItem -> Bool
$cmax :: ProjectionItem -> ProjectionItem -> ProjectionItem
max :: ProjectionItem -> ProjectionItem -> ProjectionItem
$cmin :: ProjectionItem -> ProjectionItem -> ProjectionItem
min :: ProjectionItem -> ProjectionItem -> ProjectionItem
Ord, ReadPrec [ProjectionItem]
ReadPrec ProjectionItem
Int -> ReadS ProjectionItem
ReadS [ProjectionItem]
(Int -> ReadS ProjectionItem)
-> ReadS [ProjectionItem]
-> ReadPrec ProjectionItem
-> ReadPrec [ProjectionItem]
-> Read ProjectionItem
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ProjectionItem
readsPrec :: Int -> ReadS ProjectionItem
$creadList :: ReadS [ProjectionItem]
readList :: ReadS [ProjectionItem]
$creadPrec :: ReadPrec ProjectionItem
readPrec :: ReadPrec ProjectionItem
$creadListPrec :: ReadPrec [ProjectionItem]
readListPrec :: ReadPrec [ProjectionItem]
Read, Int -> ProjectionItem -> ShowS
[ProjectionItem] -> ShowS
ProjectionItem -> String
(Int -> ProjectionItem -> ShowS)
-> (ProjectionItem -> String)
-> ([ProjectionItem] -> ShowS)
-> Show ProjectionItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectionItem -> ShowS
showsPrec :: Int -> ProjectionItem -> ShowS
$cshow :: ProjectionItem -> String
show :: ProjectionItem -> String
$cshowList :: [ProjectionItem] -> ShowS
showList :: [ProjectionItem] -> ShowS
Show)

_ProjectionItem :: Name
_ProjectionItem = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ProjectionItem")

_ProjectionItem_expression :: Name
_ProjectionItem_expression = (String -> Name
Core.Name String
"expression")

_ProjectionItem_variable :: Name
_ProjectionItem_variable = (String -> Name
Core.Name String
"variable")

newtype Order = 
  Order {
    Order -> [SortItem]
unOrder :: [SortItem]}
  deriving (Order -> Order -> Bool
(Order -> Order -> Bool) -> (Order -> Order -> Bool) -> Eq Order
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Order -> Order -> Bool
== :: Order -> Order -> Bool
$c/= :: Order -> Order -> Bool
/= :: Order -> Order -> Bool
Eq, Eq Order
Eq Order =>
(Order -> Order -> Ordering)
-> (Order -> Order -> Bool)
-> (Order -> Order -> Bool)
-> (Order -> Order -> Bool)
-> (Order -> Order -> Bool)
-> (Order -> Order -> Order)
-> (Order -> Order -> Order)
-> Ord Order
Order -> Order -> Bool
Order -> Order -> Ordering
Order -> Order -> Order
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Order -> Order -> Ordering
compare :: Order -> Order -> Ordering
$c< :: Order -> Order -> Bool
< :: Order -> Order -> Bool
$c<= :: Order -> Order -> Bool
<= :: Order -> Order -> Bool
$c> :: Order -> Order -> Bool
> :: Order -> Order -> Bool
$c>= :: Order -> Order -> Bool
>= :: Order -> Order -> Bool
$cmax :: Order -> Order -> Order
max :: Order -> Order -> Order
$cmin :: Order -> Order -> Order
min :: Order -> Order -> Order
Ord, ReadPrec [Order]
ReadPrec Order
Int -> ReadS Order
ReadS [Order]
(Int -> ReadS Order)
-> ReadS [Order]
-> ReadPrec Order
-> ReadPrec [Order]
-> Read Order
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Order
readsPrec :: Int -> ReadS Order
$creadList :: ReadS [Order]
readList :: ReadS [Order]
$creadPrec :: ReadPrec Order
readPrec :: ReadPrec Order
$creadListPrec :: ReadPrec [Order]
readListPrec :: ReadPrec [Order]
Read, Int -> Order -> ShowS
[Order] -> ShowS
Order -> String
(Int -> Order -> ShowS)
-> (Order -> String) -> ([Order] -> ShowS) -> Show Order
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Order -> ShowS
showsPrec :: Int -> Order -> ShowS
$cshow :: Order -> String
show :: Order -> String
$cshowList :: [Order] -> ShowS
showList :: [Order] -> ShowS
Show)

_Order :: Name
_Order = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Order")

newtype Skip = 
  Skip {
    Skip -> Expression
unSkip :: Expression}
  deriving (Skip -> Skip -> Bool
(Skip -> Skip -> Bool) -> (Skip -> Skip -> Bool) -> Eq Skip
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Skip -> Skip -> Bool
== :: Skip -> Skip -> Bool
$c/= :: Skip -> Skip -> Bool
/= :: Skip -> Skip -> Bool
Eq, Eq Skip
Eq Skip =>
(Skip -> Skip -> Ordering)
-> (Skip -> Skip -> Bool)
-> (Skip -> Skip -> Bool)
-> (Skip -> Skip -> Bool)
-> (Skip -> Skip -> Bool)
-> (Skip -> Skip -> Skip)
-> (Skip -> Skip -> Skip)
-> Ord Skip
Skip -> Skip -> Bool
Skip -> Skip -> Ordering
Skip -> Skip -> Skip
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Skip -> Skip -> Ordering
compare :: Skip -> Skip -> Ordering
$c< :: Skip -> Skip -> Bool
< :: Skip -> Skip -> Bool
$c<= :: Skip -> Skip -> Bool
<= :: Skip -> Skip -> Bool
$c> :: Skip -> Skip -> Bool
> :: Skip -> Skip -> Bool
$c>= :: Skip -> Skip -> Bool
>= :: Skip -> Skip -> Bool
$cmax :: Skip -> Skip -> Skip
max :: Skip -> Skip -> Skip
$cmin :: Skip -> Skip -> Skip
min :: Skip -> Skip -> Skip
Ord, ReadPrec [Skip]
ReadPrec Skip
Int -> ReadS Skip
ReadS [Skip]
(Int -> ReadS Skip)
-> ReadS [Skip] -> ReadPrec Skip -> ReadPrec [Skip] -> Read Skip
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Skip
readsPrec :: Int -> ReadS Skip
$creadList :: ReadS [Skip]
readList :: ReadS [Skip]
$creadPrec :: ReadPrec Skip
readPrec :: ReadPrec Skip
$creadListPrec :: ReadPrec [Skip]
readListPrec :: ReadPrec [Skip]
Read, Int -> Skip -> ShowS
[Skip] -> ShowS
Skip -> String
(Int -> Skip -> ShowS)
-> (Skip -> String) -> ([Skip] -> ShowS) -> Show Skip
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Skip -> ShowS
showsPrec :: Int -> Skip -> ShowS
$cshow :: Skip -> String
show :: Skip -> String
$cshowList :: [Skip] -> ShowS
showList :: [Skip] -> ShowS
Show)

_Skip :: Name
_Skip = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Skip")

newtype Limit = 
  Limit {
    Limit -> Expression
unLimit :: Expression}
  deriving (Limit -> Limit -> Bool
(Limit -> Limit -> Bool) -> (Limit -> Limit -> Bool) -> Eq Limit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Limit -> Limit -> Bool
== :: Limit -> Limit -> Bool
$c/= :: Limit -> Limit -> Bool
/= :: Limit -> Limit -> Bool
Eq, Eq Limit
Eq Limit =>
(Limit -> Limit -> Ordering)
-> (Limit -> Limit -> Bool)
-> (Limit -> Limit -> Bool)
-> (Limit -> Limit -> Bool)
-> (Limit -> Limit -> Bool)
-> (Limit -> Limit -> Limit)
-> (Limit -> Limit -> Limit)
-> Ord Limit
Limit -> Limit -> Bool
Limit -> Limit -> Ordering
Limit -> Limit -> Limit
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Limit -> Limit -> Ordering
compare :: Limit -> Limit -> Ordering
$c< :: Limit -> Limit -> Bool
< :: Limit -> Limit -> Bool
$c<= :: Limit -> Limit -> Bool
<= :: Limit -> Limit -> Bool
$c> :: Limit -> Limit -> Bool
> :: Limit -> Limit -> Bool
$c>= :: Limit -> Limit -> Bool
>= :: Limit -> Limit -> Bool
$cmax :: Limit -> Limit -> Limit
max :: Limit -> Limit -> Limit
$cmin :: Limit -> Limit -> Limit
min :: Limit -> Limit -> Limit
Ord, ReadPrec [Limit]
ReadPrec Limit
Int -> ReadS Limit
ReadS [Limit]
(Int -> ReadS Limit)
-> ReadS [Limit]
-> ReadPrec Limit
-> ReadPrec [Limit]
-> Read Limit
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Limit
readsPrec :: Int -> ReadS Limit
$creadList :: ReadS [Limit]
readList :: ReadS [Limit]
$creadPrec :: ReadPrec Limit
readPrec :: ReadPrec Limit
$creadListPrec :: ReadPrec [Limit]
readListPrec :: ReadPrec [Limit]
Read, Int -> Limit -> ShowS
[Limit] -> ShowS
Limit -> String
(Int -> Limit -> ShowS)
-> (Limit -> String) -> ([Limit] -> ShowS) -> Show Limit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Limit -> ShowS
showsPrec :: Int -> Limit -> ShowS
$cshow :: Limit -> String
show :: Limit -> String
$cshowList :: [Limit] -> ShowS
showList :: [Limit] -> ShowS
Show)

_Limit :: Name
_Limit = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Limit")

data SortOrder = 
  SortOrderAscending  |
  SortOrderDescending 
  deriving (SortOrder -> SortOrder -> Bool
(SortOrder -> SortOrder -> Bool)
-> (SortOrder -> SortOrder -> Bool) -> Eq SortOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SortOrder -> SortOrder -> Bool
== :: SortOrder -> SortOrder -> Bool
$c/= :: SortOrder -> SortOrder -> Bool
/= :: SortOrder -> SortOrder -> Bool
Eq, Eq SortOrder
Eq SortOrder =>
(SortOrder -> SortOrder -> Ordering)
-> (SortOrder -> SortOrder -> Bool)
-> (SortOrder -> SortOrder -> Bool)
-> (SortOrder -> SortOrder -> Bool)
-> (SortOrder -> SortOrder -> Bool)
-> (SortOrder -> SortOrder -> SortOrder)
-> (SortOrder -> SortOrder -> SortOrder)
-> Ord SortOrder
SortOrder -> SortOrder -> Bool
SortOrder -> SortOrder -> Ordering
SortOrder -> SortOrder -> SortOrder
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SortOrder -> SortOrder -> Ordering
compare :: SortOrder -> SortOrder -> Ordering
$c< :: SortOrder -> SortOrder -> Bool
< :: SortOrder -> SortOrder -> Bool
$c<= :: SortOrder -> SortOrder -> Bool
<= :: SortOrder -> SortOrder -> Bool
$c> :: SortOrder -> SortOrder -> Bool
> :: SortOrder -> SortOrder -> Bool
$c>= :: SortOrder -> SortOrder -> Bool
>= :: SortOrder -> SortOrder -> Bool
$cmax :: SortOrder -> SortOrder -> SortOrder
max :: SortOrder -> SortOrder -> SortOrder
$cmin :: SortOrder -> SortOrder -> SortOrder
min :: SortOrder -> SortOrder -> SortOrder
Ord, ReadPrec [SortOrder]
ReadPrec SortOrder
Int -> ReadS SortOrder
ReadS [SortOrder]
(Int -> ReadS SortOrder)
-> ReadS [SortOrder]
-> ReadPrec SortOrder
-> ReadPrec [SortOrder]
-> Read SortOrder
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SortOrder
readsPrec :: Int -> ReadS SortOrder
$creadList :: ReadS [SortOrder]
readList :: ReadS [SortOrder]
$creadPrec :: ReadPrec SortOrder
readPrec :: ReadPrec SortOrder
$creadListPrec :: ReadPrec [SortOrder]
readListPrec :: ReadPrec [SortOrder]
Read, Int -> SortOrder -> ShowS
[SortOrder] -> ShowS
SortOrder -> String
(Int -> SortOrder -> ShowS)
-> (SortOrder -> String)
-> ([SortOrder] -> ShowS)
-> Show SortOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SortOrder -> ShowS
showsPrec :: Int -> SortOrder -> ShowS
$cshow :: SortOrder -> String
show :: SortOrder -> String
$cshowList :: [SortOrder] -> ShowS
showList :: [SortOrder] -> ShowS
Show)

_SortOrder :: Name
_SortOrder = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.SortOrder")

_SortOrder_ascending :: Name
_SortOrder_ascending = (String -> Name
Core.Name String
"ascending")

_SortOrder_descending :: Name
_SortOrder_descending = (String -> Name
Core.Name String
"descending")

data SortItem = 
  SortItem {
    SortItem -> Expression
sortItemExpression :: Expression,
    SortItem -> Maybe SortOrder
sortItemOrder :: (Maybe SortOrder)}
  deriving (SortItem -> SortItem -> Bool
(SortItem -> SortItem -> Bool)
-> (SortItem -> SortItem -> Bool) -> Eq SortItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SortItem -> SortItem -> Bool
== :: SortItem -> SortItem -> Bool
$c/= :: SortItem -> SortItem -> Bool
/= :: SortItem -> SortItem -> Bool
Eq, Eq SortItem
Eq SortItem =>
(SortItem -> SortItem -> Ordering)
-> (SortItem -> SortItem -> Bool)
-> (SortItem -> SortItem -> Bool)
-> (SortItem -> SortItem -> Bool)
-> (SortItem -> SortItem -> Bool)
-> (SortItem -> SortItem -> SortItem)
-> (SortItem -> SortItem -> SortItem)
-> Ord SortItem
SortItem -> SortItem -> Bool
SortItem -> SortItem -> Ordering
SortItem -> SortItem -> SortItem
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SortItem -> SortItem -> Ordering
compare :: SortItem -> SortItem -> Ordering
$c< :: SortItem -> SortItem -> Bool
< :: SortItem -> SortItem -> Bool
$c<= :: SortItem -> SortItem -> Bool
<= :: SortItem -> SortItem -> Bool
$c> :: SortItem -> SortItem -> Bool
> :: SortItem -> SortItem -> Bool
$c>= :: SortItem -> SortItem -> Bool
>= :: SortItem -> SortItem -> Bool
$cmax :: SortItem -> SortItem -> SortItem
max :: SortItem -> SortItem -> SortItem
$cmin :: SortItem -> SortItem -> SortItem
min :: SortItem -> SortItem -> SortItem
Ord, ReadPrec [SortItem]
ReadPrec SortItem
Int -> ReadS SortItem
ReadS [SortItem]
(Int -> ReadS SortItem)
-> ReadS [SortItem]
-> ReadPrec SortItem
-> ReadPrec [SortItem]
-> Read SortItem
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SortItem
readsPrec :: Int -> ReadS SortItem
$creadList :: ReadS [SortItem]
readList :: ReadS [SortItem]
$creadPrec :: ReadPrec SortItem
readPrec :: ReadPrec SortItem
$creadListPrec :: ReadPrec [SortItem]
readListPrec :: ReadPrec [SortItem]
Read, Int -> SortItem -> ShowS
[SortItem] -> ShowS
SortItem -> String
(Int -> SortItem -> ShowS)
-> (SortItem -> String) -> ([SortItem] -> ShowS) -> Show SortItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SortItem -> ShowS
showsPrec :: Int -> SortItem -> ShowS
$cshow :: SortItem -> String
show :: SortItem -> String
$cshowList :: [SortItem] -> ShowS
showList :: [SortItem] -> ShowS
Show)

_SortItem :: Name
_SortItem = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.SortItem")

_SortItem_expression :: Name
_SortItem_expression = (String -> Name
Core.Name String
"expression")

_SortItem_order :: Name
_SortItem_order = (String -> Name
Core.Name String
"order")

newtype Where = 
  Where {
    Where -> Expression
unWhere :: Expression}
  deriving (Where -> Where -> Bool
(Where -> Where -> Bool) -> (Where -> Where -> Bool) -> Eq Where
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Where -> Where -> Bool
== :: Where -> Where -> Bool
$c/= :: Where -> Where -> Bool
/= :: Where -> Where -> Bool
Eq, Eq Where
Eq Where =>
(Where -> Where -> Ordering)
-> (Where -> Where -> Bool)
-> (Where -> Where -> Bool)
-> (Where -> Where -> Bool)
-> (Where -> Where -> Bool)
-> (Where -> Where -> Where)
-> (Where -> Where -> Where)
-> Ord Where
Where -> Where -> Bool
Where -> Where -> Ordering
Where -> Where -> Where
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Where -> Where -> Ordering
compare :: Where -> Where -> Ordering
$c< :: Where -> Where -> Bool
< :: Where -> Where -> Bool
$c<= :: Where -> Where -> Bool
<= :: Where -> Where -> Bool
$c> :: Where -> Where -> Bool
> :: Where -> Where -> Bool
$c>= :: Where -> Where -> Bool
>= :: Where -> Where -> Bool
$cmax :: Where -> Where -> Where
max :: Where -> Where -> Where
$cmin :: Where -> Where -> Where
min :: Where -> Where -> Where
Ord, ReadPrec [Where]
ReadPrec Where
Int -> ReadS Where
ReadS [Where]
(Int -> ReadS Where)
-> ReadS [Where]
-> ReadPrec Where
-> ReadPrec [Where]
-> Read Where
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Where
readsPrec :: Int -> ReadS Where
$creadList :: ReadS [Where]
readList :: ReadS [Where]
$creadPrec :: ReadPrec Where
readPrec :: ReadPrec Where
$creadListPrec :: ReadPrec [Where]
readListPrec :: ReadPrec [Where]
Read, Int -> Where -> ShowS
[Where] -> ShowS
Where -> String
(Int -> Where -> ShowS)
-> (Where -> String) -> ([Where] -> ShowS) -> Show Where
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Where -> ShowS
showsPrec :: Int -> Where -> ShowS
$cshow :: Where -> String
show :: Where -> String
$cshowList :: [Where] -> ShowS
showList :: [Where] -> ShowS
Show)

_Where :: Name
_Where = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Where")

newtype Pattern = 
  Pattern {
    Pattern -> [PatternPart]
unPattern :: [PatternPart]}
  deriving (Pattern -> Pattern -> Bool
(Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Bool) -> Eq Pattern
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pattern -> Pattern -> Bool
== :: Pattern -> Pattern -> Bool
$c/= :: Pattern -> Pattern -> Bool
/= :: Pattern -> Pattern -> Bool
Eq, Eq Pattern
Eq Pattern =>
(Pattern -> Pattern -> Ordering)
-> (Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Pattern)
-> (Pattern -> Pattern -> Pattern)
-> Ord Pattern
Pattern -> Pattern -> Bool
Pattern -> Pattern -> Ordering
Pattern -> Pattern -> Pattern
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pattern -> Pattern -> Ordering
compare :: Pattern -> Pattern -> Ordering
$c< :: Pattern -> Pattern -> Bool
< :: Pattern -> Pattern -> Bool
$c<= :: Pattern -> Pattern -> Bool
<= :: Pattern -> Pattern -> Bool
$c> :: Pattern -> Pattern -> Bool
> :: Pattern -> Pattern -> Bool
$c>= :: Pattern -> Pattern -> Bool
>= :: Pattern -> Pattern -> Bool
$cmax :: Pattern -> Pattern -> Pattern
max :: Pattern -> Pattern -> Pattern
$cmin :: Pattern -> Pattern -> Pattern
min :: Pattern -> Pattern -> Pattern
Ord, ReadPrec [Pattern]
ReadPrec Pattern
Int -> ReadS Pattern
ReadS [Pattern]
(Int -> ReadS Pattern)
-> ReadS [Pattern]
-> ReadPrec Pattern
-> ReadPrec [Pattern]
-> Read Pattern
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pattern
readsPrec :: Int -> ReadS Pattern
$creadList :: ReadS [Pattern]
readList :: ReadS [Pattern]
$creadPrec :: ReadPrec Pattern
readPrec :: ReadPrec Pattern
$creadListPrec :: ReadPrec [Pattern]
readListPrec :: ReadPrec [Pattern]
Read, Int -> Pattern -> ShowS
[Pattern] -> ShowS
Pattern -> String
(Int -> Pattern -> ShowS)
-> (Pattern -> String) -> ([Pattern] -> ShowS) -> Show Pattern
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Pattern -> ShowS
showsPrec :: Int -> Pattern -> ShowS
$cshow :: Pattern -> String
show :: Pattern -> String
$cshowList :: [Pattern] -> ShowS
showList :: [Pattern] -> ShowS
Show)

_Pattern :: Name
_Pattern = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Pattern")

data PatternPart = 
  PatternPart {
    PatternPart -> Maybe Variable
patternPartVariable :: (Maybe Variable),
    PatternPart -> AnonymousPatternPart
patternPartPattern :: AnonymousPatternPart}
  deriving (PatternPart -> PatternPart -> Bool
(PatternPart -> PatternPart -> Bool)
-> (PatternPart -> PatternPart -> Bool) -> Eq PatternPart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PatternPart -> PatternPart -> Bool
== :: PatternPart -> PatternPart -> Bool
$c/= :: PatternPart -> PatternPart -> Bool
/= :: PatternPart -> PatternPart -> Bool
Eq, Eq PatternPart
Eq PatternPart =>
(PatternPart -> PatternPart -> Ordering)
-> (PatternPart -> PatternPart -> Bool)
-> (PatternPart -> PatternPart -> Bool)
-> (PatternPart -> PatternPart -> Bool)
-> (PatternPart -> PatternPart -> Bool)
-> (PatternPart -> PatternPart -> PatternPart)
-> (PatternPart -> PatternPart -> PatternPart)
-> Ord PatternPart
PatternPart -> PatternPart -> Bool
PatternPart -> PatternPart -> Ordering
PatternPart -> PatternPart -> PatternPart
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PatternPart -> PatternPart -> Ordering
compare :: PatternPart -> PatternPart -> Ordering
$c< :: PatternPart -> PatternPart -> Bool
< :: PatternPart -> PatternPart -> Bool
$c<= :: PatternPart -> PatternPart -> Bool
<= :: PatternPart -> PatternPart -> Bool
$c> :: PatternPart -> PatternPart -> Bool
> :: PatternPart -> PatternPart -> Bool
$c>= :: PatternPart -> PatternPart -> Bool
>= :: PatternPart -> PatternPart -> Bool
$cmax :: PatternPart -> PatternPart -> PatternPart
max :: PatternPart -> PatternPart -> PatternPart
$cmin :: PatternPart -> PatternPart -> PatternPart
min :: PatternPart -> PatternPart -> PatternPart
Ord, ReadPrec [PatternPart]
ReadPrec PatternPart
Int -> ReadS PatternPart
ReadS [PatternPart]
(Int -> ReadS PatternPart)
-> ReadS [PatternPart]
-> ReadPrec PatternPart
-> ReadPrec [PatternPart]
-> Read PatternPart
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PatternPart
readsPrec :: Int -> ReadS PatternPart
$creadList :: ReadS [PatternPart]
readList :: ReadS [PatternPart]
$creadPrec :: ReadPrec PatternPart
readPrec :: ReadPrec PatternPart
$creadListPrec :: ReadPrec [PatternPart]
readListPrec :: ReadPrec [PatternPart]
Read, Int -> PatternPart -> ShowS
[PatternPart] -> ShowS
PatternPart -> String
(Int -> PatternPart -> ShowS)
-> (PatternPart -> String)
-> ([PatternPart] -> ShowS)
-> Show PatternPart
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PatternPart -> ShowS
showsPrec :: Int -> PatternPart -> ShowS
$cshow :: PatternPart -> String
show :: PatternPart -> String
$cshowList :: [PatternPart] -> ShowS
showList :: [PatternPart] -> ShowS
Show)

_PatternPart :: Name
_PatternPart = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PatternPart")

_PatternPart_variable :: Name
_PatternPart_variable = (String -> Name
Core.Name String
"variable")

_PatternPart_pattern :: Name
_PatternPart_pattern = (String -> Name
Core.Name String
"pattern")

newtype AnonymousPatternPart = 
  AnonymousPatternPart {
    AnonymousPatternPart -> PatternElement
unAnonymousPatternPart :: PatternElement}
  deriving (AnonymousPatternPart -> AnonymousPatternPart -> Bool
(AnonymousPatternPart -> AnonymousPatternPart -> Bool)
-> (AnonymousPatternPart -> AnonymousPatternPart -> Bool)
-> Eq AnonymousPatternPart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
== :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
$c/= :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
/= :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
Eq, Eq AnonymousPatternPart
Eq AnonymousPatternPart =>
(AnonymousPatternPart -> AnonymousPatternPart -> Ordering)
-> (AnonymousPatternPart -> AnonymousPatternPart -> Bool)
-> (AnonymousPatternPart -> AnonymousPatternPart -> Bool)
-> (AnonymousPatternPart -> AnonymousPatternPart -> Bool)
-> (AnonymousPatternPart -> AnonymousPatternPart -> Bool)
-> (AnonymousPatternPart
    -> AnonymousPatternPart -> AnonymousPatternPart)
-> (AnonymousPatternPart
    -> AnonymousPatternPart -> AnonymousPatternPart)
-> Ord AnonymousPatternPart
AnonymousPatternPart -> AnonymousPatternPart -> Bool
AnonymousPatternPart -> AnonymousPatternPart -> Ordering
AnonymousPatternPart
-> AnonymousPatternPart -> AnonymousPatternPart
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AnonymousPatternPart -> AnonymousPatternPart -> Ordering
compare :: AnonymousPatternPart -> AnonymousPatternPart -> Ordering
$c< :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
< :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
$c<= :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
<= :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
$c> :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
> :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
$c>= :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
>= :: AnonymousPatternPart -> AnonymousPatternPart -> Bool
$cmax :: AnonymousPatternPart
-> AnonymousPatternPart -> AnonymousPatternPart
max :: AnonymousPatternPart
-> AnonymousPatternPart -> AnonymousPatternPart
$cmin :: AnonymousPatternPart
-> AnonymousPatternPart -> AnonymousPatternPart
min :: AnonymousPatternPart
-> AnonymousPatternPart -> AnonymousPatternPart
Ord, ReadPrec [AnonymousPatternPart]
ReadPrec AnonymousPatternPart
Int -> ReadS AnonymousPatternPart
ReadS [AnonymousPatternPart]
(Int -> ReadS AnonymousPatternPart)
-> ReadS [AnonymousPatternPart]
-> ReadPrec AnonymousPatternPart
-> ReadPrec [AnonymousPatternPart]
-> Read AnonymousPatternPart
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AnonymousPatternPart
readsPrec :: Int -> ReadS AnonymousPatternPart
$creadList :: ReadS [AnonymousPatternPart]
readList :: ReadS [AnonymousPatternPart]
$creadPrec :: ReadPrec AnonymousPatternPart
readPrec :: ReadPrec AnonymousPatternPart
$creadListPrec :: ReadPrec [AnonymousPatternPart]
readListPrec :: ReadPrec [AnonymousPatternPart]
Read, Int -> AnonymousPatternPart -> ShowS
[AnonymousPatternPart] -> ShowS
AnonymousPatternPart -> String
(Int -> AnonymousPatternPart -> ShowS)
-> (AnonymousPatternPart -> String)
-> ([AnonymousPatternPart] -> ShowS)
-> Show AnonymousPatternPart
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AnonymousPatternPart -> ShowS
showsPrec :: Int -> AnonymousPatternPart -> ShowS
$cshow :: AnonymousPatternPart -> String
show :: AnonymousPatternPart -> String
$cshowList :: [AnonymousPatternPart] -> ShowS
showList :: [AnonymousPatternPart] -> ShowS
Show)

_AnonymousPatternPart :: Name
_AnonymousPatternPart = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.AnonymousPatternPart")

data NodePatternChain = 
  NodePatternChain {
    NodePatternChain -> NodePattern
nodePatternChainNodePattern :: NodePattern,
    NodePatternChain -> [PatternElementChain]
nodePatternChainChain :: [PatternElementChain]}
  deriving (NodePatternChain -> NodePatternChain -> Bool
(NodePatternChain -> NodePatternChain -> Bool)
-> (NodePatternChain -> NodePatternChain -> Bool)
-> Eq NodePatternChain
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NodePatternChain -> NodePatternChain -> Bool
== :: NodePatternChain -> NodePatternChain -> Bool
$c/= :: NodePatternChain -> NodePatternChain -> Bool
/= :: NodePatternChain -> NodePatternChain -> Bool
Eq, Eq NodePatternChain
Eq NodePatternChain =>
(NodePatternChain -> NodePatternChain -> Ordering)
-> (NodePatternChain -> NodePatternChain -> Bool)
-> (NodePatternChain -> NodePatternChain -> Bool)
-> (NodePatternChain -> NodePatternChain -> Bool)
-> (NodePatternChain -> NodePatternChain -> Bool)
-> (NodePatternChain -> NodePatternChain -> NodePatternChain)
-> (NodePatternChain -> NodePatternChain -> NodePatternChain)
-> Ord NodePatternChain
NodePatternChain -> NodePatternChain -> Bool
NodePatternChain -> NodePatternChain -> Ordering
NodePatternChain -> NodePatternChain -> NodePatternChain
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NodePatternChain -> NodePatternChain -> Ordering
compare :: NodePatternChain -> NodePatternChain -> Ordering
$c< :: NodePatternChain -> NodePatternChain -> Bool
< :: NodePatternChain -> NodePatternChain -> Bool
$c<= :: NodePatternChain -> NodePatternChain -> Bool
<= :: NodePatternChain -> NodePatternChain -> Bool
$c> :: NodePatternChain -> NodePatternChain -> Bool
> :: NodePatternChain -> NodePatternChain -> Bool
$c>= :: NodePatternChain -> NodePatternChain -> Bool
>= :: NodePatternChain -> NodePatternChain -> Bool
$cmax :: NodePatternChain -> NodePatternChain -> NodePatternChain
max :: NodePatternChain -> NodePatternChain -> NodePatternChain
$cmin :: NodePatternChain -> NodePatternChain -> NodePatternChain
min :: NodePatternChain -> NodePatternChain -> NodePatternChain
Ord, ReadPrec [NodePatternChain]
ReadPrec NodePatternChain
Int -> ReadS NodePatternChain
ReadS [NodePatternChain]
(Int -> ReadS NodePatternChain)
-> ReadS [NodePatternChain]
-> ReadPrec NodePatternChain
-> ReadPrec [NodePatternChain]
-> Read NodePatternChain
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NodePatternChain
readsPrec :: Int -> ReadS NodePatternChain
$creadList :: ReadS [NodePatternChain]
readList :: ReadS [NodePatternChain]
$creadPrec :: ReadPrec NodePatternChain
readPrec :: ReadPrec NodePatternChain
$creadListPrec :: ReadPrec [NodePatternChain]
readListPrec :: ReadPrec [NodePatternChain]
Read, Int -> NodePatternChain -> ShowS
[NodePatternChain] -> ShowS
NodePatternChain -> String
(Int -> NodePatternChain -> ShowS)
-> (NodePatternChain -> String)
-> ([NodePatternChain] -> ShowS)
-> Show NodePatternChain
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NodePatternChain -> ShowS
showsPrec :: Int -> NodePatternChain -> ShowS
$cshow :: NodePatternChain -> String
show :: NodePatternChain -> String
$cshowList :: [NodePatternChain] -> ShowS
showList :: [NodePatternChain] -> ShowS
Show)

_NodePatternChain :: Name
_NodePatternChain = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.NodePatternChain")

_NodePatternChain_nodePattern :: Name
_NodePatternChain_nodePattern = (String -> Name
Core.Name String
"nodePattern")

_NodePatternChain_chain :: Name
_NodePatternChain_chain = (String -> Name
Core.Name String
"chain")

data PatternElement = 
  PatternElementChained NodePatternChain |
  PatternElementParenthesized PatternElement
  deriving (PatternElement -> PatternElement -> Bool
(PatternElement -> PatternElement -> Bool)
-> (PatternElement -> PatternElement -> Bool) -> Eq PatternElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PatternElement -> PatternElement -> Bool
== :: PatternElement -> PatternElement -> Bool
$c/= :: PatternElement -> PatternElement -> Bool
/= :: PatternElement -> PatternElement -> Bool
Eq, Eq PatternElement
Eq PatternElement =>
(PatternElement -> PatternElement -> Ordering)
-> (PatternElement -> PatternElement -> Bool)
-> (PatternElement -> PatternElement -> Bool)
-> (PatternElement -> PatternElement -> Bool)
-> (PatternElement -> PatternElement -> Bool)
-> (PatternElement -> PatternElement -> PatternElement)
-> (PatternElement -> PatternElement -> PatternElement)
-> Ord PatternElement
PatternElement -> PatternElement -> Bool
PatternElement -> PatternElement -> Ordering
PatternElement -> PatternElement -> PatternElement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PatternElement -> PatternElement -> Ordering
compare :: PatternElement -> PatternElement -> Ordering
$c< :: PatternElement -> PatternElement -> Bool
< :: PatternElement -> PatternElement -> Bool
$c<= :: PatternElement -> PatternElement -> Bool
<= :: PatternElement -> PatternElement -> Bool
$c> :: PatternElement -> PatternElement -> Bool
> :: PatternElement -> PatternElement -> Bool
$c>= :: PatternElement -> PatternElement -> Bool
>= :: PatternElement -> PatternElement -> Bool
$cmax :: PatternElement -> PatternElement -> PatternElement
max :: PatternElement -> PatternElement -> PatternElement
$cmin :: PatternElement -> PatternElement -> PatternElement
min :: PatternElement -> PatternElement -> PatternElement
Ord, ReadPrec [PatternElement]
ReadPrec PatternElement
Int -> ReadS PatternElement
ReadS [PatternElement]
(Int -> ReadS PatternElement)
-> ReadS [PatternElement]
-> ReadPrec PatternElement
-> ReadPrec [PatternElement]
-> Read PatternElement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PatternElement
readsPrec :: Int -> ReadS PatternElement
$creadList :: ReadS [PatternElement]
readList :: ReadS [PatternElement]
$creadPrec :: ReadPrec PatternElement
readPrec :: ReadPrec PatternElement
$creadListPrec :: ReadPrec [PatternElement]
readListPrec :: ReadPrec [PatternElement]
Read, Int -> PatternElement -> ShowS
[PatternElement] -> ShowS
PatternElement -> String
(Int -> PatternElement -> ShowS)
-> (PatternElement -> String)
-> ([PatternElement] -> ShowS)
-> Show PatternElement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PatternElement -> ShowS
showsPrec :: Int -> PatternElement -> ShowS
$cshow :: PatternElement -> String
show :: PatternElement -> String
$cshowList :: [PatternElement] -> ShowS
showList :: [PatternElement] -> ShowS
Show)

_PatternElement :: Name
_PatternElement = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PatternElement")

_PatternElement_chained :: Name
_PatternElement_chained = (String -> Name
Core.Name String
"chained")

_PatternElement_parenthesized :: Name
_PatternElement_parenthesized = (String -> Name
Core.Name String
"parenthesized")

data RelationshipsPattern = 
  RelationshipsPattern {
    RelationshipsPattern -> NodePattern
relationshipsPatternNodePattern :: NodePattern,
    RelationshipsPattern -> [PatternElementChain]
relationshipsPatternChain :: [PatternElementChain]}
  deriving (RelationshipsPattern -> RelationshipsPattern -> Bool
(RelationshipsPattern -> RelationshipsPattern -> Bool)
-> (RelationshipsPattern -> RelationshipsPattern -> Bool)
-> Eq RelationshipsPattern
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelationshipsPattern -> RelationshipsPattern -> Bool
== :: RelationshipsPattern -> RelationshipsPattern -> Bool
$c/= :: RelationshipsPattern -> RelationshipsPattern -> Bool
/= :: RelationshipsPattern -> RelationshipsPattern -> Bool
Eq, Eq RelationshipsPattern
Eq RelationshipsPattern =>
(RelationshipsPattern -> RelationshipsPattern -> Ordering)
-> (RelationshipsPattern -> RelationshipsPattern -> Bool)
-> (RelationshipsPattern -> RelationshipsPattern -> Bool)
-> (RelationshipsPattern -> RelationshipsPattern -> Bool)
-> (RelationshipsPattern -> RelationshipsPattern -> Bool)
-> (RelationshipsPattern
    -> RelationshipsPattern -> RelationshipsPattern)
-> (RelationshipsPattern
    -> RelationshipsPattern -> RelationshipsPattern)
-> Ord RelationshipsPattern
RelationshipsPattern -> RelationshipsPattern -> Bool
RelationshipsPattern -> RelationshipsPattern -> Ordering
RelationshipsPattern
-> RelationshipsPattern -> RelationshipsPattern
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RelationshipsPattern -> RelationshipsPattern -> Ordering
compare :: RelationshipsPattern -> RelationshipsPattern -> Ordering
$c< :: RelationshipsPattern -> RelationshipsPattern -> Bool
< :: RelationshipsPattern -> RelationshipsPattern -> Bool
$c<= :: RelationshipsPattern -> RelationshipsPattern -> Bool
<= :: RelationshipsPattern -> RelationshipsPattern -> Bool
$c> :: RelationshipsPattern -> RelationshipsPattern -> Bool
> :: RelationshipsPattern -> RelationshipsPattern -> Bool
$c>= :: RelationshipsPattern -> RelationshipsPattern -> Bool
>= :: RelationshipsPattern -> RelationshipsPattern -> Bool
$cmax :: RelationshipsPattern
-> RelationshipsPattern -> RelationshipsPattern
max :: RelationshipsPattern
-> RelationshipsPattern -> RelationshipsPattern
$cmin :: RelationshipsPattern
-> RelationshipsPattern -> RelationshipsPattern
min :: RelationshipsPattern
-> RelationshipsPattern -> RelationshipsPattern
Ord, ReadPrec [RelationshipsPattern]
ReadPrec RelationshipsPattern
Int -> ReadS RelationshipsPattern
ReadS [RelationshipsPattern]
(Int -> ReadS RelationshipsPattern)
-> ReadS [RelationshipsPattern]
-> ReadPrec RelationshipsPattern
-> ReadPrec [RelationshipsPattern]
-> Read RelationshipsPattern
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RelationshipsPattern
readsPrec :: Int -> ReadS RelationshipsPattern
$creadList :: ReadS [RelationshipsPattern]
readList :: ReadS [RelationshipsPattern]
$creadPrec :: ReadPrec RelationshipsPattern
readPrec :: ReadPrec RelationshipsPattern
$creadListPrec :: ReadPrec [RelationshipsPattern]
readListPrec :: ReadPrec [RelationshipsPattern]
Read, Int -> RelationshipsPattern -> ShowS
[RelationshipsPattern] -> ShowS
RelationshipsPattern -> String
(Int -> RelationshipsPattern -> ShowS)
-> (RelationshipsPattern -> String)
-> ([RelationshipsPattern] -> ShowS)
-> Show RelationshipsPattern
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelationshipsPattern -> ShowS
showsPrec :: Int -> RelationshipsPattern -> ShowS
$cshow :: RelationshipsPattern -> String
show :: RelationshipsPattern -> String
$cshowList :: [RelationshipsPattern] -> ShowS
showList :: [RelationshipsPattern] -> ShowS
Show)

_RelationshipsPattern :: Name
_RelationshipsPattern = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.RelationshipsPattern")

_RelationshipsPattern_nodePattern :: Name
_RelationshipsPattern_nodePattern = (String -> Name
Core.Name String
"nodePattern")

_RelationshipsPattern_chain :: Name
_RelationshipsPattern_chain = (String -> Name
Core.Name String
"chain")

data NodePattern = 
  NodePattern {
    NodePattern -> Maybe Variable
nodePatternVariable :: (Maybe Variable),
    NodePattern -> Maybe NodeLabels
nodePatternLabels :: (Maybe NodeLabels),
    NodePattern -> Maybe Properties
nodePatternProperties :: (Maybe Properties)}
  deriving (NodePattern -> NodePattern -> Bool
(NodePattern -> NodePattern -> Bool)
-> (NodePattern -> NodePattern -> Bool) -> Eq NodePattern
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NodePattern -> NodePattern -> Bool
== :: NodePattern -> NodePattern -> Bool
$c/= :: NodePattern -> NodePattern -> Bool
/= :: NodePattern -> NodePattern -> Bool
Eq, Eq NodePattern
Eq NodePattern =>
(NodePattern -> NodePattern -> Ordering)
-> (NodePattern -> NodePattern -> Bool)
-> (NodePattern -> NodePattern -> Bool)
-> (NodePattern -> NodePattern -> Bool)
-> (NodePattern -> NodePattern -> Bool)
-> (NodePattern -> NodePattern -> NodePattern)
-> (NodePattern -> NodePattern -> NodePattern)
-> Ord NodePattern
NodePattern -> NodePattern -> Bool
NodePattern -> NodePattern -> Ordering
NodePattern -> NodePattern -> NodePattern
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NodePattern -> NodePattern -> Ordering
compare :: NodePattern -> NodePattern -> Ordering
$c< :: NodePattern -> NodePattern -> Bool
< :: NodePattern -> NodePattern -> Bool
$c<= :: NodePattern -> NodePattern -> Bool
<= :: NodePattern -> NodePattern -> Bool
$c> :: NodePattern -> NodePattern -> Bool
> :: NodePattern -> NodePattern -> Bool
$c>= :: NodePattern -> NodePattern -> Bool
>= :: NodePattern -> NodePattern -> Bool
$cmax :: NodePattern -> NodePattern -> NodePattern
max :: NodePattern -> NodePattern -> NodePattern
$cmin :: NodePattern -> NodePattern -> NodePattern
min :: NodePattern -> NodePattern -> NodePattern
Ord, ReadPrec [NodePattern]
ReadPrec NodePattern
Int -> ReadS NodePattern
ReadS [NodePattern]
(Int -> ReadS NodePattern)
-> ReadS [NodePattern]
-> ReadPrec NodePattern
-> ReadPrec [NodePattern]
-> Read NodePattern
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NodePattern
readsPrec :: Int -> ReadS NodePattern
$creadList :: ReadS [NodePattern]
readList :: ReadS [NodePattern]
$creadPrec :: ReadPrec NodePattern
readPrec :: ReadPrec NodePattern
$creadListPrec :: ReadPrec [NodePattern]
readListPrec :: ReadPrec [NodePattern]
Read, Int -> NodePattern -> ShowS
[NodePattern] -> ShowS
NodePattern -> String
(Int -> NodePattern -> ShowS)
-> (NodePattern -> String)
-> ([NodePattern] -> ShowS)
-> Show NodePattern
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NodePattern -> ShowS
showsPrec :: Int -> NodePattern -> ShowS
$cshow :: NodePattern -> String
show :: NodePattern -> String
$cshowList :: [NodePattern] -> ShowS
showList :: [NodePattern] -> ShowS
Show)

_NodePattern :: Name
_NodePattern = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.NodePattern")

_NodePattern_variable :: Name
_NodePattern_variable = (String -> Name
Core.Name String
"variable")

_NodePattern_labels :: Name
_NodePattern_labels = (String -> Name
Core.Name String
"labels")

_NodePattern_properties :: Name
_NodePattern_properties = (String -> Name
Core.Name String
"properties")

data PatternElementChain = 
  PatternElementChain {
    PatternElementChain -> RelationshipPattern
patternElementChainRelationship :: RelationshipPattern,
    PatternElementChain -> NodePattern
patternElementChainNode :: NodePattern}
  deriving (PatternElementChain -> PatternElementChain -> Bool
(PatternElementChain -> PatternElementChain -> Bool)
-> (PatternElementChain -> PatternElementChain -> Bool)
-> Eq PatternElementChain
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PatternElementChain -> PatternElementChain -> Bool
== :: PatternElementChain -> PatternElementChain -> Bool
$c/= :: PatternElementChain -> PatternElementChain -> Bool
/= :: PatternElementChain -> PatternElementChain -> Bool
Eq, Eq PatternElementChain
Eq PatternElementChain =>
(PatternElementChain -> PatternElementChain -> Ordering)
-> (PatternElementChain -> PatternElementChain -> Bool)
-> (PatternElementChain -> PatternElementChain -> Bool)
-> (PatternElementChain -> PatternElementChain -> Bool)
-> (PatternElementChain -> PatternElementChain -> Bool)
-> (PatternElementChain
    -> PatternElementChain -> PatternElementChain)
-> (PatternElementChain
    -> PatternElementChain -> PatternElementChain)
-> Ord PatternElementChain
PatternElementChain -> PatternElementChain -> Bool
PatternElementChain -> PatternElementChain -> Ordering
PatternElementChain -> PatternElementChain -> PatternElementChain
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PatternElementChain -> PatternElementChain -> Ordering
compare :: PatternElementChain -> PatternElementChain -> Ordering
$c< :: PatternElementChain -> PatternElementChain -> Bool
< :: PatternElementChain -> PatternElementChain -> Bool
$c<= :: PatternElementChain -> PatternElementChain -> Bool
<= :: PatternElementChain -> PatternElementChain -> Bool
$c> :: PatternElementChain -> PatternElementChain -> Bool
> :: PatternElementChain -> PatternElementChain -> Bool
$c>= :: PatternElementChain -> PatternElementChain -> Bool
>= :: PatternElementChain -> PatternElementChain -> Bool
$cmax :: PatternElementChain -> PatternElementChain -> PatternElementChain
max :: PatternElementChain -> PatternElementChain -> PatternElementChain
$cmin :: PatternElementChain -> PatternElementChain -> PatternElementChain
min :: PatternElementChain -> PatternElementChain -> PatternElementChain
Ord, ReadPrec [PatternElementChain]
ReadPrec PatternElementChain
Int -> ReadS PatternElementChain
ReadS [PatternElementChain]
(Int -> ReadS PatternElementChain)
-> ReadS [PatternElementChain]
-> ReadPrec PatternElementChain
-> ReadPrec [PatternElementChain]
-> Read PatternElementChain
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PatternElementChain
readsPrec :: Int -> ReadS PatternElementChain
$creadList :: ReadS [PatternElementChain]
readList :: ReadS [PatternElementChain]
$creadPrec :: ReadPrec PatternElementChain
readPrec :: ReadPrec PatternElementChain
$creadListPrec :: ReadPrec [PatternElementChain]
readListPrec :: ReadPrec [PatternElementChain]
Read, Int -> PatternElementChain -> ShowS
[PatternElementChain] -> ShowS
PatternElementChain -> String
(Int -> PatternElementChain -> ShowS)
-> (PatternElementChain -> String)
-> ([PatternElementChain] -> ShowS)
-> Show PatternElementChain
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PatternElementChain -> ShowS
showsPrec :: Int -> PatternElementChain -> ShowS
$cshow :: PatternElementChain -> String
show :: PatternElementChain -> String
$cshowList :: [PatternElementChain] -> ShowS
showList :: [PatternElementChain] -> ShowS
Show)

_PatternElementChain :: Name
_PatternElementChain = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PatternElementChain")

_PatternElementChain_relationship :: Name
_PatternElementChain_relationship = (String -> Name
Core.Name String
"relationship")

_PatternElementChain_node :: Name
_PatternElementChain_node = (String -> Name
Core.Name String
"node")

data RelationshipPattern = 
  RelationshipPattern {
    RelationshipPattern -> Bool
relationshipPatternLeftArrow :: Bool,
    RelationshipPattern -> Maybe RelationshipDetail
relationshipPatternDetail :: (Maybe RelationshipDetail),
    RelationshipPattern -> Bool
relationshipPatternRightArrow :: Bool}
  deriving (RelationshipPattern -> RelationshipPattern -> Bool
(RelationshipPattern -> RelationshipPattern -> Bool)
-> (RelationshipPattern -> RelationshipPattern -> Bool)
-> Eq RelationshipPattern
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelationshipPattern -> RelationshipPattern -> Bool
== :: RelationshipPattern -> RelationshipPattern -> Bool
$c/= :: RelationshipPattern -> RelationshipPattern -> Bool
/= :: RelationshipPattern -> RelationshipPattern -> Bool
Eq, Eq RelationshipPattern
Eq RelationshipPattern =>
(RelationshipPattern -> RelationshipPattern -> Ordering)
-> (RelationshipPattern -> RelationshipPattern -> Bool)
-> (RelationshipPattern -> RelationshipPattern -> Bool)
-> (RelationshipPattern -> RelationshipPattern -> Bool)
-> (RelationshipPattern -> RelationshipPattern -> Bool)
-> (RelationshipPattern
    -> RelationshipPattern -> RelationshipPattern)
-> (RelationshipPattern
    -> RelationshipPattern -> RelationshipPattern)
-> Ord RelationshipPattern
RelationshipPattern -> RelationshipPattern -> Bool
RelationshipPattern -> RelationshipPattern -> Ordering
RelationshipPattern -> RelationshipPattern -> RelationshipPattern
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RelationshipPattern -> RelationshipPattern -> Ordering
compare :: RelationshipPattern -> RelationshipPattern -> Ordering
$c< :: RelationshipPattern -> RelationshipPattern -> Bool
< :: RelationshipPattern -> RelationshipPattern -> Bool
$c<= :: RelationshipPattern -> RelationshipPattern -> Bool
<= :: RelationshipPattern -> RelationshipPattern -> Bool
$c> :: RelationshipPattern -> RelationshipPattern -> Bool
> :: RelationshipPattern -> RelationshipPattern -> Bool
$c>= :: RelationshipPattern -> RelationshipPattern -> Bool
>= :: RelationshipPattern -> RelationshipPattern -> Bool
$cmax :: RelationshipPattern -> RelationshipPattern -> RelationshipPattern
max :: RelationshipPattern -> RelationshipPattern -> RelationshipPattern
$cmin :: RelationshipPattern -> RelationshipPattern -> RelationshipPattern
min :: RelationshipPattern -> RelationshipPattern -> RelationshipPattern
Ord, ReadPrec [RelationshipPattern]
ReadPrec RelationshipPattern
Int -> ReadS RelationshipPattern
ReadS [RelationshipPattern]
(Int -> ReadS RelationshipPattern)
-> ReadS [RelationshipPattern]
-> ReadPrec RelationshipPattern
-> ReadPrec [RelationshipPattern]
-> Read RelationshipPattern
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RelationshipPattern
readsPrec :: Int -> ReadS RelationshipPattern
$creadList :: ReadS [RelationshipPattern]
readList :: ReadS [RelationshipPattern]
$creadPrec :: ReadPrec RelationshipPattern
readPrec :: ReadPrec RelationshipPattern
$creadListPrec :: ReadPrec [RelationshipPattern]
readListPrec :: ReadPrec [RelationshipPattern]
Read, Int -> RelationshipPattern -> ShowS
[RelationshipPattern] -> ShowS
RelationshipPattern -> String
(Int -> RelationshipPattern -> ShowS)
-> (RelationshipPattern -> String)
-> ([RelationshipPattern] -> ShowS)
-> Show RelationshipPattern
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelationshipPattern -> ShowS
showsPrec :: Int -> RelationshipPattern -> ShowS
$cshow :: RelationshipPattern -> String
show :: RelationshipPattern -> String
$cshowList :: [RelationshipPattern] -> ShowS
showList :: [RelationshipPattern] -> ShowS
Show)

_RelationshipPattern :: Name
_RelationshipPattern = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.RelationshipPattern")

_RelationshipPattern_leftArrow :: Name
_RelationshipPattern_leftArrow = (String -> Name
Core.Name String
"leftArrow")

_RelationshipPattern_detail :: Name
_RelationshipPattern_detail = (String -> Name
Core.Name String
"detail")

_RelationshipPattern_rightArrow :: Name
_RelationshipPattern_rightArrow = (String -> Name
Core.Name String
"rightArrow")

data RelationshipDetail = 
  RelationshipDetail {
    RelationshipDetail -> Maybe Variable
relationshipDetailVariable :: (Maybe Variable),
    RelationshipDetail -> Maybe RelationshipTypes
relationshipDetailTypes :: (Maybe RelationshipTypes),
    RelationshipDetail -> Maybe RangeLiteral
relationshipDetailRange :: (Maybe RangeLiteral),
    RelationshipDetail -> Maybe Properties
relationshipDetailProperties :: (Maybe Properties)}
  deriving (RelationshipDetail -> RelationshipDetail -> Bool
(RelationshipDetail -> RelationshipDetail -> Bool)
-> (RelationshipDetail -> RelationshipDetail -> Bool)
-> Eq RelationshipDetail
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelationshipDetail -> RelationshipDetail -> Bool
== :: RelationshipDetail -> RelationshipDetail -> Bool
$c/= :: RelationshipDetail -> RelationshipDetail -> Bool
/= :: RelationshipDetail -> RelationshipDetail -> Bool
Eq, Eq RelationshipDetail
Eq RelationshipDetail =>
(RelationshipDetail -> RelationshipDetail -> Ordering)
-> (RelationshipDetail -> RelationshipDetail -> Bool)
-> (RelationshipDetail -> RelationshipDetail -> Bool)
-> (RelationshipDetail -> RelationshipDetail -> Bool)
-> (RelationshipDetail -> RelationshipDetail -> Bool)
-> (RelationshipDetail -> RelationshipDetail -> RelationshipDetail)
-> (RelationshipDetail -> RelationshipDetail -> RelationshipDetail)
-> Ord RelationshipDetail
RelationshipDetail -> RelationshipDetail -> Bool
RelationshipDetail -> RelationshipDetail -> Ordering
RelationshipDetail -> RelationshipDetail -> RelationshipDetail
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RelationshipDetail -> RelationshipDetail -> Ordering
compare :: RelationshipDetail -> RelationshipDetail -> Ordering
$c< :: RelationshipDetail -> RelationshipDetail -> Bool
< :: RelationshipDetail -> RelationshipDetail -> Bool
$c<= :: RelationshipDetail -> RelationshipDetail -> Bool
<= :: RelationshipDetail -> RelationshipDetail -> Bool
$c> :: RelationshipDetail -> RelationshipDetail -> Bool
> :: RelationshipDetail -> RelationshipDetail -> Bool
$c>= :: RelationshipDetail -> RelationshipDetail -> Bool
>= :: RelationshipDetail -> RelationshipDetail -> Bool
$cmax :: RelationshipDetail -> RelationshipDetail -> RelationshipDetail
max :: RelationshipDetail -> RelationshipDetail -> RelationshipDetail
$cmin :: RelationshipDetail -> RelationshipDetail -> RelationshipDetail
min :: RelationshipDetail -> RelationshipDetail -> RelationshipDetail
Ord, ReadPrec [RelationshipDetail]
ReadPrec RelationshipDetail
Int -> ReadS RelationshipDetail
ReadS [RelationshipDetail]
(Int -> ReadS RelationshipDetail)
-> ReadS [RelationshipDetail]
-> ReadPrec RelationshipDetail
-> ReadPrec [RelationshipDetail]
-> Read RelationshipDetail
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RelationshipDetail
readsPrec :: Int -> ReadS RelationshipDetail
$creadList :: ReadS [RelationshipDetail]
readList :: ReadS [RelationshipDetail]
$creadPrec :: ReadPrec RelationshipDetail
readPrec :: ReadPrec RelationshipDetail
$creadListPrec :: ReadPrec [RelationshipDetail]
readListPrec :: ReadPrec [RelationshipDetail]
Read, Int -> RelationshipDetail -> ShowS
[RelationshipDetail] -> ShowS
RelationshipDetail -> String
(Int -> RelationshipDetail -> ShowS)
-> (RelationshipDetail -> String)
-> ([RelationshipDetail] -> ShowS)
-> Show RelationshipDetail
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelationshipDetail -> ShowS
showsPrec :: Int -> RelationshipDetail -> ShowS
$cshow :: RelationshipDetail -> String
show :: RelationshipDetail -> String
$cshowList :: [RelationshipDetail] -> ShowS
showList :: [RelationshipDetail] -> ShowS
Show)

_RelationshipDetail :: Name
_RelationshipDetail = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.RelationshipDetail")

_RelationshipDetail_variable :: Name
_RelationshipDetail_variable = (String -> Name
Core.Name String
"variable")

_RelationshipDetail_types :: Name
_RelationshipDetail_types = (String -> Name
Core.Name String
"types")

_RelationshipDetail_range :: Name
_RelationshipDetail_range = (String -> Name
Core.Name String
"range")

_RelationshipDetail_properties :: Name
_RelationshipDetail_properties = (String -> Name
Core.Name String
"properties")

data Properties = 
  PropertiesMap MapLiteral |
  PropertiesParameter Parameter
  deriving (Properties -> Properties -> Bool
(Properties -> Properties -> Bool)
-> (Properties -> Properties -> Bool) -> Eq Properties
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Properties -> Properties -> Bool
== :: Properties -> Properties -> Bool
$c/= :: Properties -> Properties -> Bool
/= :: Properties -> Properties -> Bool
Eq, Eq Properties
Eq Properties =>
(Properties -> Properties -> Ordering)
-> (Properties -> Properties -> Bool)
-> (Properties -> Properties -> Bool)
-> (Properties -> Properties -> Bool)
-> (Properties -> Properties -> Bool)
-> (Properties -> Properties -> Properties)
-> (Properties -> Properties -> Properties)
-> Ord Properties
Properties -> Properties -> Bool
Properties -> Properties -> Ordering
Properties -> Properties -> Properties
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Properties -> Properties -> Ordering
compare :: Properties -> Properties -> Ordering
$c< :: Properties -> Properties -> Bool
< :: Properties -> Properties -> Bool
$c<= :: Properties -> Properties -> Bool
<= :: Properties -> Properties -> Bool
$c> :: Properties -> Properties -> Bool
> :: Properties -> Properties -> Bool
$c>= :: Properties -> Properties -> Bool
>= :: Properties -> Properties -> Bool
$cmax :: Properties -> Properties -> Properties
max :: Properties -> Properties -> Properties
$cmin :: Properties -> Properties -> Properties
min :: Properties -> Properties -> Properties
Ord, ReadPrec [Properties]
ReadPrec Properties
Int -> ReadS Properties
ReadS [Properties]
(Int -> ReadS Properties)
-> ReadS [Properties]
-> ReadPrec Properties
-> ReadPrec [Properties]
-> Read Properties
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Properties
readsPrec :: Int -> ReadS Properties
$creadList :: ReadS [Properties]
readList :: ReadS [Properties]
$creadPrec :: ReadPrec Properties
readPrec :: ReadPrec Properties
$creadListPrec :: ReadPrec [Properties]
readListPrec :: ReadPrec [Properties]
Read, Int -> Properties -> ShowS
[Properties] -> ShowS
Properties -> String
(Int -> Properties -> ShowS)
-> (Properties -> String)
-> ([Properties] -> ShowS)
-> Show Properties
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Properties -> ShowS
showsPrec :: Int -> Properties -> ShowS
$cshow :: Properties -> String
show :: Properties -> String
$cshowList :: [Properties] -> ShowS
showList :: [Properties] -> ShowS
Show)

_Properties :: Name
_Properties = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Properties")

_Properties_map :: Name
_Properties_map = (String -> Name
Core.Name String
"map")

_Properties_parameter :: Name
_Properties_parameter = (String -> Name
Core.Name String
"parameter")

newtype RelationshipTypes = 
  RelationshipTypes {
    RelationshipTypes -> [RelTypeName]
unRelationshipTypes :: [RelTypeName]}
  deriving (RelationshipTypes -> RelationshipTypes -> Bool
(RelationshipTypes -> RelationshipTypes -> Bool)
-> (RelationshipTypes -> RelationshipTypes -> Bool)
-> Eq RelationshipTypes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelationshipTypes -> RelationshipTypes -> Bool
== :: RelationshipTypes -> RelationshipTypes -> Bool
$c/= :: RelationshipTypes -> RelationshipTypes -> Bool
/= :: RelationshipTypes -> RelationshipTypes -> Bool
Eq, Eq RelationshipTypes
Eq RelationshipTypes =>
(RelationshipTypes -> RelationshipTypes -> Ordering)
-> (RelationshipTypes -> RelationshipTypes -> Bool)
-> (RelationshipTypes -> RelationshipTypes -> Bool)
-> (RelationshipTypes -> RelationshipTypes -> Bool)
-> (RelationshipTypes -> RelationshipTypes -> Bool)
-> (RelationshipTypes -> RelationshipTypes -> RelationshipTypes)
-> (RelationshipTypes -> RelationshipTypes -> RelationshipTypes)
-> Ord RelationshipTypes
RelationshipTypes -> RelationshipTypes -> Bool
RelationshipTypes -> RelationshipTypes -> Ordering
RelationshipTypes -> RelationshipTypes -> RelationshipTypes
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RelationshipTypes -> RelationshipTypes -> Ordering
compare :: RelationshipTypes -> RelationshipTypes -> Ordering
$c< :: RelationshipTypes -> RelationshipTypes -> Bool
< :: RelationshipTypes -> RelationshipTypes -> Bool
$c<= :: RelationshipTypes -> RelationshipTypes -> Bool
<= :: RelationshipTypes -> RelationshipTypes -> Bool
$c> :: RelationshipTypes -> RelationshipTypes -> Bool
> :: RelationshipTypes -> RelationshipTypes -> Bool
$c>= :: RelationshipTypes -> RelationshipTypes -> Bool
>= :: RelationshipTypes -> RelationshipTypes -> Bool
$cmax :: RelationshipTypes -> RelationshipTypes -> RelationshipTypes
max :: RelationshipTypes -> RelationshipTypes -> RelationshipTypes
$cmin :: RelationshipTypes -> RelationshipTypes -> RelationshipTypes
min :: RelationshipTypes -> RelationshipTypes -> RelationshipTypes
Ord, ReadPrec [RelationshipTypes]
ReadPrec RelationshipTypes
Int -> ReadS RelationshipTypes
ReadS [RelationshipTypes]
(Int -> ReadS RelationshipTypes)
-> ReadS [RelationshipTypes]
-> ReadPrec RelationshipTypes
-> ReadPrec [RelationshipTypes]
-> Read RelationshipTypes
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RelationshipTypes
readsPrec :: Int -> ReadS RelationshipTypes
$creadList :: ReadS [RelationshipTypes]
readList :: ReadS [RelationshipTypes]
$creadPrec :: ReadPrec RelationshipTypes
readPrec :: ReadPrec RelationshipTypes
$creadListPrec :: ReadPrec [RelationshipTypes]
readListPrec :: ReadPrec [RelationshipTypes]
Read, Int -> RelationshipTypes -> ShowS
[RelationshipTypes] -> ShowS
RelationshipTypes -> String
(Int -> RelationshipTypes -> ShowS)
-> (RelationshipTypes -> String)
-> ([RelationshipTypes] -> ShowS)
-> Show RelationshipTypes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelationshipTypes -> ShowS
showsPrec :: Int -> RelationshipTypes -> ShowS
$cshow :: RelationshipTypes -> String
show :: RelationshipTypes -> String
$cshowList :: [RelationshipTypes] -> ShowS
showList :: [RelationshipTypes] -> ShowS
Show)

_RelationshipTypes :: Name
_RelationshipTypes = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.RelationshipTypes")

newtype NodeLabels = 
  NodeLabels {
    NodeLabels -> [NodeLabel]
unNodeLabels :: [NodeLabel]}
  deriving (NodeLabels -> NodeLabels -> Bool
(NodeLabels -> NodeLabels -> Bool)
-> (NodeLabels -> NodeLabels -> Bool) -> Eq NodeLabels
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NodeLabels -> NodeLabels -> Bool
== :: NodeLabels -> NodeLabels -> Bool
$c/= :: NodeLabels -> NodeLabels -> Bool
/= :: NodeLabels -> NodeLabels -> Bool
Eq, Eq NodeLabels
Eq NodeLabels =>
(NodeLabels -> NodeLabels -> Ordering)
-> (NodeLabels -> NodeLabels -> Bool)
-> (NodeLabels -> NodeLabels -> Bool)
-> (NodeLabels -> NodeLabels -> Bool)
-> (NodeLabels -> NodeLabels -> Bool)
-> (NodeLabels -> NodeLabels -> NodeLabels)
-> (NodeLabels -> NodeLabels -> NodeLabels)
-> Ord NodeLabels
NodeLabels -> NodeLabels -> Bool
NodeLabels -> NodeLabels -> Ordering
NodeLabels -> NodeLabels -> NodeLabels
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NodeLabels -> NodeLabels -> Ordering
compare :: NodeLabels -> NodeLabels -> Ordering
$c< :: NodeLabels -> NodeLabels -> Bool
< :: NodeLabels -> NodeLabels -> Bool
$c<= :: NodeLabels -> NodeLabels -> Bool
<= :: NodeLabels -> NodeLabels -> Bool
$c> :: NodeLabels -> NodeLabels -> Bool
> :: NodeLabels -> NodeLabels -> Bool
$c>= :: NodeLabels -> NodeLabels -> Bool
>= :: NodeLabels -> NodeLabels -> Bool
$cmax :: NodeLabels -> NodeLabels -> NodeLabels
max :: NodeLabels -> NodeLabels -> NodeLabels
$cmin :: NodeLabels -> NodeLabels -> NodeLabels
min :: NodeLabels -> NodeLabels -> NodeLabels
Ord, ReadPrec [NodeLabels]
ReadPrec NodeLabels
Int -> ReadS NodeLabels
ReadS [NodeLabels]
(Int -> ReadS NodeLabels)
-> ReadS [NodeLabels]
-> ReadPrec NodeLabels
-> ReadPrec [NodeLabels]
-> Read NodeLabels
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NodeLabels
readsPrec :: Int -> ReadS NodeLabels
$creadList :: ReadS [NodeLabels]
readList :: ReadS [NodeLabels]
$creadPrec :: ReadPrec NodeLabels
readPrec :: ReadPrec NodeLabels
$creadListPrec :: ReadPrec [NodeLabels]
readListPrec :: ReadPrec [NodeLabels]
Read, Int -> NodeLabels -> ShowS
[NodeLabels] -> ShowS
NodeLabels -> String
(Int -> NodeLabels -> ShowS)
-> (NodeLabels -> String)
-> ([NodeLabels] -> ShowS)
-> Show NodeLabels
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NodeLabels -> ShowS
showsPrec :: Int -> NodeLabels -> ShowS
$cshow :: NodeLabels -> String
show :: NodeLabels -> String
$cshowList :: [NodeLabels] -> ShowS
showList :: [NodeLabels] -> ShowS
Show)

_NodeLabels :: Name
_NodeLabels = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.NodeLabels")

newtype NodeLabel = 
  NodeLabel {
    NodeLabel -> String
unNodeLabel :: String}
  deriving (NodeLabel -> NodeLabel -> Bool
(NodeLabel -> NodeLabel -> Bool)
-> (NodeLabel -> NodeLabel -> Bool) -> Eq NodeLabel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NodeLabel -> NodeLabel -> Bool
== :: NodeLabel -> NodeLabel -> Bool
$c/= :: NodeLabel -> NodeLabel -> Bool
/= :: NodeLabel -> NodeLabel -> Bool
Eq, Eq NodeLabel
Eq NodeLabel =>
(NodeLabel -> NodeLabel -> Ordering)
-> (NodeLabel -> NodeLabel -> Bool)
-> (NodeLabel -> NodeLabel -> Bool)
-> (NodeLabel -> NodeLabel -> Bool)
-> (NodeLabel -> NodeLabel -> Bool)
-> (NodeLabel -> NodeLabel -> NodeLabel)
-> (NodeLabel -> NodeLabel -> NodeLabel)
-> Ord NodeLabel
NodeLabel -> NodeLabel -> Bool
NodeLabel -> NodeLabel -> Ordering
NodeLabel -> NodeLabel -> NodeLabel
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NodeLabel -> NodeLabel -> Ordering
compare :: NodeLabel -> NodeLabel -> Ordering
$c< :: NodeLabel -> NodeLabel -> Bool
< :: NodeLabel -> NodeLabel -> Bool
$c<= :: NodeLabel -> NodeLabel -> Bool
<= :: NodeLabel -> NodeLabel -> Bool
$c> :: NodeLabel -> NodeLabel -> Bool
> :: NodeLabel -> NodeLabel -> Bool
$c>= :: NodeLabel -> NodeLabel -> Bool
>= :: NodeLabel -> NodeLabel -> Bool
$cmax :: NodeLabel -> NodeLabel -> NodeLabel
max :: NodeLabel -> NodeLabel -> NodeLabel
$cmin :: NodeLabel -> NodeLabel -> NodeLabel
min :: NodeLabel -> NodeLabel -> NodeLabel
Ord, ReadPrec [NodeLabel]
ReadPrec NodeLabel
Int -> ReadS NodeLabel
ReadS [NodeLabel]
(Int -> ReadS NodeLabel)
-> ReadS [NodeLabel]
-> ReadPrec NodeLabel
-> ReadPrec [NodeLabel]
-> Read NodeLabel
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NodeLabel
readsPrec :: Int -> ReadS NodeLabel
$creadList :: ReadS [NodeLabel]
readList :: ReadS [NodeLabel]
$creadPrec :: ReadPrec NodeLabel
readPrec :: ReadPrec NodeLabel
$creadListPrec :: ReadPrec [NodeLabel]
readListPrec :: ReadPrec [NodeLabel]
Read, Int -> NodeLabel -> ShowS
[NodeLabel] -> ShowS
NodeLabel -> String
(Int -> NodeLabel -> ShowS)
-> (NodeLabel -> String)
-> ([NodeLabel] -> ShowS)
-> Show NodeLabel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NodeLabel -> ShowS
showsPrec :: Int -> NodeLabel -> ShowS
$cshow :: NodeLabel -> String
show :: NodeLabel -> String
$cshowList :: [NodeLabel] -> ShowS
showList :: [NodeLabel] -> ShowS
Show)

_NodeLabel :: Name
_NodeLabel = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.NodeLabel")

data RangeLiteral = 
  RangeLiteral {
    RangeLiteral -> Maybe Integer
rangeLiteralStart :: (Maybe Integer),
    RangeLiteral -> Maybe Integer
rangeLiteralEnd :: (Maybe Integer)}
  deriving (RangeLiteral -> RangeLiteral -> Bool
(RangeLiteral -> RangeLiteral -> Bool)
-> (RangeLiteral -> RangeLiteral -> Bool) -> Eq RangeLiteral
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RangeLiteral -> RangeLiteral -> Bool
== :: RangeLiteral -> RangeLiteral -> Bool
$c/= :: RangeLiteral -> RangeLiteral -> Bool
/= :: RangeLiteral -> RangeLiteral -> Bool
Eq, Eq RangeLiteral
Eq RangeLiteral =>
(RangeLiteral -> RangeLiteral -> Ordering)
-> (RangeLiteral -> RangeLiteral -> Bool)
-> (RangeLiteral -> RangeLiteral -> Bool)
-> (RangeLiteral -> RangeLiteral -> Bool)
-> (RangeLiteral -> RangeLiteral -> Bool)
-> (RangeLiteral -> RangeLiteral -> RangeLiteral)
-> (RangeLiteral -> RangeLiteral -> RangeLiteral)
-> Ord RangeLiteral
RangeLiteral -> RangeLiteral -> Bool
RangeLiteral -> RangeLiteral -> Ordering
RangeLiteral -> RangeLiteral -> RangeLiteral
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RangeLiteral -> RangeLiteral -> Ordering
compare :: RangeLiteral -> RangeLiteral -> Ordering
$c< :: RangeLiteral -> RangeLiteral -> Bool
< :: RangeLiteral -> RangeLiteral -> Bool
$c<= :: RangeLiteral -> RangeLiteral -> Bool
<= :: RangeLiteral -> RangeLiteral -> Bool
$c> :: RangeLiteral -> RangeLiteral -> Bool
> :: RangeLiteral -> RangeLiteral -> Bool
$c>= :: RangeLiteral -> RangeLiteral -> Bool
>= :: RangeLiteral -> RangeLiteral -> Bool
$cmax :: RangeLiteral -> RangeLiteral -> RangeLiteral
max :: RangeLiteral -> RangeLiteral -> RangeLiteral
$cmin :: RangeLiteral -> RangeLiteral -> RangeLiteral
min :: RangeLiteral -> RangeLiteral -> RangeLiteral
Ord, ReadPrec [RangeLiteral]
ReadPrec RangeLiteral
Int -> ReadS RangeLiteral
ReadS [RangeLiteral]
(Int -> ReadS RangeLiteral)
-> ReadS [RangeLiteral]
-> ReadPrec RangeLiteral
-> ReadPrec [RangeLiteral]
-> Read RangeLiteral
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RangeLiteral
readsPrec :: Int -> ReadS RangeLiteral
$creadList :: ReadS [RangeLiteral]
readList :: ReadS [RangeLiteral]
$creadPrec :: ReadPrec RangeLiteral
readPrec :: ReadPrec RangeLiteral
$creadListPrec :: ReadPrec [RangeLiteral]
readListPrec :: ReadPrec [RangeLiteral]
Read, Int -> RangeLiteral -> ShowS
[RangeLiteral] -> ShowS
RangeLiteral -> String
(Int -> RangeLiteral -> ShowS)
-> (RangeLiteral -> String)
-> ([RangeLiteral] -> ShowS)
-> Show RangeLiteral
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RangeLiteral -> ShowS
showsPrec :: Int -> RangeLiteral -> ShowS
$cshow :: RangeLiteral -> String
show :: RangeLiteral -> String
$cshowList :: [RangeLiteral] -> ShowS
showList :: [RangeLiteral] -> ShowS
Show)

_RangeLiteral :: Name
_RangeLiteral = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.RangeLiteral")

_RangeLiteral_start :: Name
_RangeLiteral_start = (String -> Name
Core.Name String
"start")

_RangeLiteral_end :: Name
_RangeLiteral_end = (String -> Name
Core.Name String
"end")

newtype RelTypeName = 
  RelTypeName {
    RelTypeName -> String
unRelTypeName :: String}
  deriving (RelTypeName -> RelTypeName -> Bool
(RelTypeName -> RelTypeName -> Bool)
-> (RelTypeName -> RelTypeName -> Bool) -> Eq RelTypeName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelTypeName -> RelTypeName -> Bool
== :: RelTypeName -> RelTypeName -> Bool
$c/= :: RelTypeName -> RelTypeName -> Bool
/= :: RelTypeName -> RelTypeName -> Bool
Eq, Eq RelTypeName
Eq RelTypeName =>
(RelTypeName -> RelTypeName -> Ordering)
-> (RelTypeName -> RelTypeName -> Bool)
-> (RelTypeName -> RelTypeName -> Bool)
-> (RelTypeName -> RelTypeName -> Bool)
-> (RelTypeName -> RelTypeName -> Bool)
-> (RelTypeName -> RelTypeName -> RelTypeName)
-> (RelTypeName -> RelTypeName -> RelTypeName)
-> Ord RelTypeName
RelTypeName -> RelTypeName -> Bool
RelTypeName -> RelTypeName -> Ordering
RelTypeName -> RelTypeName -> RelTypeName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RelTypeName -> RelTypeName -> Ordering
compare :: RelTypeName -> RelTypeName -> Ordering
$c< :: RelTypeName -> RelTypeName -> Bool
< :: RelTypeName -> RelTypeName -> Bool
$c<= :: RelTypeName -> RelTypeName -> Bool
<= :: RelTypeName -> RelTypeName -> Bool
$c> :: RelTypeName -> RelTypeName -> Bool
> :: RelTypeName -> RelTypeName -> Bool
$c>= :: RelTypeName -> RelTypeName -> Bool
>= :: RelTypeName -> RelTypeName -> Bool
$cmax :: RelTypeName -> RelTypeName -> RelTypeName
max :: RelTypeName -> RelTypeName -> RelTypeName
$cmin :: RelTypeName -> RelTypeName -> RelTypeName
min :: RelTypeName -> RelTypeName -> RelTypeName
Ord, ReadPrec [RelTypeName]
ReadPrec RelTypeName
Int -> ReadS RelTypeName
ReadS [RelTypeName]
(Int -> ReadS RelTypeName)
-> ReadS [RelTypeName]
-> ReadPrec RelTypeName
-> ReadPrec [RelTypeName]
-> Read RelTypeName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RelTypeName
readsPrec :: Int -> ReadS RelTypeName
$creadList :: ReadS [RelTypeName]
readList :: ReadS [RelTypeName]
$creadPrec :: ReadPrec RelTypeName
readPrec :: ReadPrec RelTypeName
$creadListPrec :: ReadPrec [RelTypeName]
readListPrec :: ReadPrec [RelTypeName]
Read, Int -> RelTypeName -> ShowS
[RelTypeName] -> ShowS
RelTypeName -> String
(Int -> RelTypeName -> ShowS)
-> (RelTypeName -> String)
-> ([RelTypeName] -> ShowS)
-> Show RelTypeName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelTypeName -> ShowS
showsPrec :: Int -> RelTypeName -> ShowS
$cshow :: RelTypeName -> String
show :: RelTypeName -> String
$cshowList :: [RelTypeName] -> ShowS
showList :: [RelTypeName] -> ShowS
Show)

_RelTypeName :: Name
_RelTypeName = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.RelTypeName")

data PropertyExpression = 
  PropertyExpression {
    PropertyExpression -> Atom
propertyExpressionAtom :: Atom,
    PropertyExpression -> [PropertyLookup]
propertyExpressionLookups :: [PropertyLookup]}
  deriving (PropertyExpression -> PropertyExpression -> Bool
(PropertyExpression -> PropertyExpression -> Bool)
-> (PropertyExpression -> PropertyExpression -> Bool)
-> Eq PropertyExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PropertyExpression -> PropertyExpression -> Bool
== :: PropertyExpression -> PropertyExpression -> Bool
$c/= :: PropertyExpression -> PropertyExpression -> Bool
/= :: PropertyExpression -> PropertyExpression -> Bool
Eq, Eq PropertyExpression
Eq PropertyExpression =>
(PropertyExpression -> PropertyExpression -> Ordering)
-> (PropertyExpression -> PropertyExpression -> Bool)
-> (PropertyExpression -> PropertyExpression -> Bool)
-> (PropertyExpression -> PropertyExpression -> Bool)
-> (PropertyExpression -> PropertyExpression -> Bool)
-> (PropertyExpression -> PropertyExpression -> PropertyExpression)
-> (PropertyExpression -> PropertyExpression -> PropertyExpression)
-> Ord PropertyExpression
PropertyExpression -> PropertyExpression -> Bool
PropertyExpression -> PropertyExpression -> Ordering
PropertyExpression -> PropertyExpression -> PropertyExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PropertyExpression -> PropertyExpression -> Ordering
compare :: PropertyExpression -> PropertyExpression -> Ordering
$c< :: PropertyExpression -> PropertyExpression -> Bool
< :: PropertyExpression -> PropertyExpression -> Bool
$c<= :: PropertyExpression -> PropertyExpression -> Bool
<= :: PropertyExpression -> PropertyExpression -> Bool
$c> :: PropertyExpression -> PropertyExpression -> Bool
> :: PropertyExpression -> PropertyExpression -> Bool
$c>= :: PropertyExpression -> PropertyExpression -> Bool
>= :: PropertyExpression -> PropertyExpression -> Bool
$cmax :: PropertyExpression -> PropertyExpression -> PropertyExpression
max :: PropertyExpression -> PropertyExpression -> PropertyExpression
$cmin :: PropertyExpression -> PropertyExpression -> PropertyExpression
min :: PropertyExpression -> PropertyExpression -> PropertyExpression
Ord, ReadPrec [PropertyExpression]
ReadPrec PropertyExpression
Int -> ReadS PropertyExpression
ReadS [PropertyExpression]
(Int -> ReadS PropertyExpression)
-> ReadS [PropertyExpression]
-> ReadPrec PropertyExpression
-> ReadPrec [PropertyExpression]
-> Read PropertyExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PropertyExpression
readsPrec :: Int -> ReadS PropertyExpression
$creadList :: ReadS [PropertyExpression]
readList :: ReadS [PropertyExpression]
$creadPrec :: ReadPrec PropertyExpression
readPrec :: ReadPrec PropertyExpression
$creadListPrec :: ReadPrec [PropertyExpression]
readListPrec :: ReadPrec [PropertyExpression]
Read, Int -> PropertyExpression -> ShowS
[PropertyExpression] -> ShowS
PropertyExpression -> String
(Int -> PropertyExpression -> ShowS)
-> (PropertyExpression -> String)
-> ([PropertyExpression] -> ShowS)
-> Show PropertyExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PropertyExpression -> ShowS
showsPrec :: Int -> PropertyExpression -> ShowS
$cshow :: PropertyExpression -> String
show :: PropertyExpression -> String
$cshowList :: [PropertyExpression] -> ShowS
showList :: [PropertyExpression] -> ShowS
Show)

_PropertyExpression :: Name
_PropertyExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PropertyExpression")

_PropertyExpression_atom :: Name
_PropertyExpression_atom = (String -> Name
Core.Name String
"atom")

_PropertyExpression_lookups :: Name
_PropertyExpression_lookups = (String -> Name
Core.Name String
"lookups")

newtype Expression = 
  Expression {
    Expression -> OrExpression
unExpression :: OrExpression}
  deriving (Expression -> Expression -> Bool
(Expression -> Expression -> Bool)
-> (Expression -> Expression -> Bool) -> Eq Expression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Expression -> Expression -> Bool
== :: Expression -> Expression -> Bool
$c/= :: Expression -> Expression -> Bool
/= :: Expression -> Expression -> Bool
Eq, Eq Expression
Eq Expression =>
(Expression -> Expression -> Ordering)
-> (Expression -> Expression -> Bool)
-> (Expression -> Expression -> Bool)
-> (Expression -> Expression -> Bool)
-> (Expression -> Expression -> Bool)
-> (Expression -> Expression -> Expression)
-> (Expression -> Expression -> Expression)
-> Ord Expression
Expression -> Expression -> Bool
Expression -> Expression -> Ordering
Expression -> Expression -> Expression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Expression -> Expression -> Ordering
compare :: Expression -> Expression -> Ordering
$c< :: Expression -> Expression -> Bool
< :: Expression -> Expression -> Bool
$c<= :: Expression -> Expression -> Bool
<= :: Expression -> Expression -> Bool
$c> :: Expression -> Expression -> Bool
> :: Expression -> Expression -> Bool
$c>= :: Expression -> Expression -> Bool
>= :: Expression -> Expression -> Bool
$cmax :: Expression -> Expression -> Expression
max :: Expression -> Expression -> Expression
$cmin :: Expression -> Expression -> Expression
min :: Expression -> Expression -> Expression
Ord, ReadPrec [Expression]
ReadPrec Expression
Int -> ReadS Expression
ReadS [Expression]
(Int -> ReadS Expression)
-> ReadS [Expression]
-> ReadPrec Expression
-> ReadPrec [Expression]
-> Read Expression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Expression
readsPrec :: Int -> ReadS Expression
$creadList :: ReadS [Expression]
readList :: ReadS [Expression]
$creadPrec :: ReadPrec Expression
readPrec :: ReadPrec Expression
$creadListPrec :: ReadPrec [Expression]
readListPrec :: ReadPrec [Expression]
Read, Int -> Expression -> ShowS
[Expression] -> ShowS
Expression -> String
(Int -> Expression -> ShowS)
-> (Expression -> String)
-> ([Expression] -> ShowS)
-> Show Expression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Expression -> ShowS
showsPrec :: Int -> Expression -> ShowS
$cshow :: Expression -> String
show :: Expression -> String
$cshowList :: [Expression] -> ShowS
showList :: [Expression] -> ShowS
Show)

_Expression :: Name
_Expression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Expression")

newtype OrExpression = 
  OrExpression {
    OrExpression -> [XorExpression]
unOrExpression :: [XorExpression]}
  deriving (OrExpression -> OrExpression -> Bool
(OrExpression -> OrExpression -> Bool)
-> (OrExpression -> OrExpression -> Bool) -> Eq OrExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OrExpression -> OrExpression -> Bool
== :: OrExpression -> OrExpression -> Bool
$c/= :: OrExpression -> OrExpression -> Bool
/= :: OrExpression -> OrExpression -> Bool
Eq, Eq OrExpression
Eq OrExpression =>
(OrExpression -> OrExpression -> Ordering)
-> (OrExpression -> OrExpression -> Bool)
-> (OrExpression -> OrExpression -> Bool)
-> (OrExpression -> OrExpression -> Bool)
-> (OrExpression -> OrExpression -> Bool)
-> (OrExpression -> OrExpression -> OrExpression)
-> (OrExpression -> OrExpression -> OrExpression)
-> Ord OrExpression
OrExpression -> OrExpression -> Bool
OrExpression -> OrExpression -> Ordering
OrExpression -> OrExpression -> OrExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: OrExpression -> OrExpression -> Ordering
compare :: OrExpression -> OrExpression -> Ordering
$c< :: OrExpression -> OrExpression -> Bool
< :: OrExpression -> OrExpression -> Bool
$c<= :: OrExpression -> OrExpression -> Bool
<= :: OrExpression -> OrExpression -> Bool
$c> :: OrExpression -> OrExpression -> Bool
> :: OrExpression -> OrExpression -> Bool
$c>= :: OrExpression -> OrExpression -> Bool
>= :: OrExpression -> OrExpression -> Bool
$cmax :: OrExpression -> OrExpression -> OrExpression
max :: OrExpression -> OrExpression -> OrExpression
$cmin :: OrExpression -> OrExpression -> OrExpression
min :: OrExpression -> OrExpression -> OrExpression
Ord, ReadPrec [OrExpression]
ReadPrec OrExpression
Int -> ReadS OrExpression
ReadS [OrExpression]
(Int -> ReadS OrExpression)
-> ReadS [OrExpression]
-> ReadPrec OrExpression
-> ReadPrec [OrExpression]
-> Read OrExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OrExpression
readsPrec :: Int -> ReadS OrExpression
$creadList :: ReadS [OrExpression]
readList :: ReadS [OrExpression]
$creadPrec :: ReadPrec OrExpression
readPrec :: ReadPrec OrExpression
$creadListPrec :: ReadPrec [OrExpression]
readListPrec :: ReadPrec [OrExpression]
Read, Int -> OrExpression -> ShowS
[OrExpression] -> ShowS
OrExpression -> String
(Int -> OrExpression -> ShowS)
-> (OrExpression -> String)
-> ([OrExpression] -> ShowS)
-> Show OrExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OrExpression -> ShowS
showsPrec :: Int -> OrExpression -> ShowS
$cshow :: OrExpression -> String
show :: OrExpression -> String
$cshowList :: [OrExpression] -> ShowS
showList :: [OrExpression] -> ShowS
Show)

_OrExpression :: Name
_OrExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.OrExpression")

newtype XorExpression = 
  XorExpression {
    XorExpression -> [AndExpression]
unXorExpression :: [AndExpression]}
  deriving (XorExpression -> XorExpression -> Bool
(XorExpression -> XorExpression -> Bool)
-> (XorExpression -> XorExpression -> Bool) -> Eq XorExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: XorExpression -> XorExpression -> Bool
== :: XorExpression -> XorExpression -> Bool
$c/= :: XorExpression -> XorExpression -> Bool
/= :: XorExpression -> XorExpression -> Bool
Eq, Eq XorExpression
Eq XorExpression =>
(XorExpression -> XorExpression -> Ordering)
-> (XorExpression -> XorExpression -> Bool)
-> (XorExpression -> XorExpression -> Bool)
-> (XorExpression -> XorExpression -> Bool)
-> (XorExpression -> XorExpression -> Bool)
-> (XorExpression -> XorExpression -> XorExpression)
-> (XorExpression -> XorExpression -> XorExpression)
-> Ord XorExpression
XorExpression -> XorExpression -> Bool
XorExpression -> XorExpression -> Ordering
XorExpression -> XorExpression -> XorExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: XorExpression -> XorExpression -> Ordering
compare :: XorExpression -> XorExpression -> Ordering
$c< :: XorExpression -> XorExpression -> Bool
< :: XorExpression -> XorExpression -> Bool
$c<= :: XorExpression -> XorExpression -> Bool
<= :: XorExpression -> XorExpression -> Bool
$c> :: XorExpression -> XorExpression -> Bool
> :: XorExpression -> XorExpression -> Bool
$c>= :: XorExpression -> XorExpression -> Bool
>= :: XorExpression -> XorExpression -> Bool
$cmax :: XorExpression -> XorExpression -> XorExpression
max :: XorExpression -> XorExpression -> XorExpression
$cmin :: XorExpression -> XorExpression -> XorExpression
min :: XorExpression -> XorExpression -> XorExpression
Ord, ReadPrec [XorExpression]
ReadPrec XorExpression
Int -> ReadS XorExpression
ReadS [XorExpression]
(Int -> ReadS XorExpression)
-> ReadS [XorExpression]
-> ReadPrec XorExpression
-> ReadPrec [XorExpression]
-> Read XorExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS XorExpression
readsPrec :: Int -> ReadS XorExpression
$creadList :: ReadS [XorExpression]
readList :: ReadS [XorExpression]
$creadPrec :: ReadPrec XorExpression
readPrec :: ReadPrec XorExpression
$creadListPrec :: ReadPrec [XorExpression]
readListPrec :: ReadPrec [XorExpression]
Read, Int -> XorExpression -> ShowS
[XorExpression] -> ShowS
XorExpression -> String
(Int -> XorExpression -> ShowS)
-> (XorExpression -> String)
-> ([XorExpression] -> ShowS)
-> Show XorExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> XorExpression -> ShowS
showsPrec :: Int -> XorExpression -> ShowS
$cshow :: XorExpression -> String
show :: XorExpression -> String
$cshowList :: [XorExpression] -> ShowS
showList :: [XorExpression] -> ShowS
Show)

_XorExpression :: Name
_XorExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.XorExpression")

newtype AndExpression = 
  AndExpression {
    AndExpression -> [NotExpression]
unAndExpression :: [NotExpression]}
  deriving (AndExpression -> AndExpression -> Bool
(AndExpression -> AndExpression -> Bool)
-> (AndExpression -> AndExpression -> Bool) -> Eq AndExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AndExpression -> AndExpression -> Bool
== :: AndExpression -> AndExpression -> Bool
$c/= :: AndExpression -> AndExpression -> Bool
/= :: AndExpression -> AndExpression -> Bool
Eq, Eq AndExpression
Eq AndExpression =>
(AndExpression -> AndExpression -> Ordering)
-> (AndExpression -> AndExpression -> Bool)
-> (AndExpression -> AndExpression -> Bool)
-> (AndExpression -> AndExpression -> Bool)
-> (AndExpression -> AndExpression -> Bool)
-> (AndExpression -> AndExpression -> AndExpression)
-> (AndExpression -> AndExpression -> AndExpression)
-> Ord AndExpression
AndExpression -> AndExpression -> Bool
AndExpression -> AndExpression -> Ordering
AndExpression -> AndExpression -> AndExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AndExpression -> AndExpression -> Ordering
compare :: AndExpression -> AndExpression -> Ordering
$c< :: AndExpression -> AndExpression -> Bool
< :: AndExpression -> AndExpression -> Bool
$c<= :: AndExpression -> AndExpression -> Bool
<= :: AndExpression -> AndExpression -> Bool
$c> :: AndExpression -> AndExpression -> Bool
> :: AndExpression -> AndExpression -> Bool
$c>= :: AndExpression -> AndExpression -> Bool
>= :: AndExpression -> AndExpression -> Bool
$cmax :: AndExpression -> AndExpression -> AndExpression
max :: AndExpression -> AndExpression -> AndExpression
$cmin :: AndExpression -> AndExpression -> AndExpression
min :: AndExpression -> AndExpression -> AndExpression
Ord, ReadPrec [AndExpression]
ReadPrec AndExpression
Int -> ReadS AndExpression
ReadS [AndExpression]
(Int -> ReadS AndExpression)
-> ReadS [AndExpression]
-> ReadPrec AndExpression
-> ReadPrec [AndExpression]
-> Read AndExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AndExpression
readsPrec :: Int -> ReadS AndExpression
$creadList :: ReadS [AndExpression]
readList :: ReadS [AndExpression]
$creadPrec :: ReadPrec AndExpression
readPrec :: ReadPrec AndExpression
$creadListPrec :: ReadPrec [AndExpression]
readListPrec :: ReadPrec [AndExpression]
Read, Int -> AndExpression -> ShowS
[AndExpression] -> ShowS
AndExpression -> String
(Int -> AndExpression -> ShowS)
-> (AndExpression -> String)
-> ([AndExpression] -> ShowS)
-> Show AndExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AndExpression -> ShowS
showsPrec :: Int -> AndExpression -> ShowS
$cshow :: AndExpression -> String
show :: AndExpression -> String
$cshowList :: [AndExpression] -> ShowS
showList :: [AndExpression] -> ShowS
Show)

_AndExpression :: Name
_AndExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.AndExpression")

data NotExpression = 
  NotExpression {
    NotExpression -> Bool
notExpressionNot :: Bool,
    NotExpression -> ComparisonExpression
notExpressionExpression :: ComparisonExpression}
  deriving (NotExpression -> NotExpression -> Bool
(NotExpression -> NotExpression -> Bool)
-> (NotExpression -> NotExpression -> Bool) -> Eq NotExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NotExpression -> NotExpression -> Bool
== :: NotExpression -> NotExpression -> Bool
$c/= :: NotExpression -> NotExpression -> Bool
/= :: NotExpression -> NotExpression -> Bool
Eq, Eq NotExpression
Eq NotExpression =>
(NotExpression -> NotExpression -> Ordering)
-> (NotExpression -> NotExpression -> Bool)
-> (NotExpression -> NotExpression -> Bool)
-> (NotExpression -> NotExpression -> Bool)
-> (NotExpression -> NotExpression -> Bool)
-> (NotExpression -> NotExpression -> NotExpression)
-> (NotExpression -> NotExpression -> NotExpression)
-> Ord NotExpression
NotExpression -> NotExpression -> Bool
NotExpression -> NotExpression -> Ordering
NotExpression -> NotExpression -> NotExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NotExpression -> NotExpression -> Ordering
compare :: NotExpression -> NotExpression -> Ordering
$c< :: NotExpression -> NotExpression -> Bool
< :: NotExpression -> NotExpression -> Bool
$c<= :: NotExpression -> NotExpression -> Bool
<= :: NotExpression -> NotExpression -> Bool
$c> :: NotExpression -> NotExpression -> Bool
> :: NotExpression -> NotExpression -> Bool
$c>= :: NotExpression -> NotExpression -> Bool
>= :: NotExpression -> NotExpression -> Bool
$cmax :: NotExpression -> NotExpression -> NotExpression
max :: NotExpression -> NotExpression -> NotExpression
$cmin :: NotExpression -> NotExpression -> NotExpression
min :: NotExpression -> NotExpression -> NotExpression
Ord, ReadPrec [NotExpression]
ReadPrec NotExpression
Int -> ReadS NotExpression
ReadS [NotExpression]
(Int -> ReadS NotExpression)
-> ReadS [NotExpression]
-> ReadPrec NotExpression
-> ReadPrec [NotExpression]
-> Read NotExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NotExpression
readsPrec :: Int -> ReadS NotExpression
$creadList :: ReadS [NotExpression]
readList :: ReadS [NotExpression]
$creadPrec :: ReadPrec NotExpression
readPrec :: ReadPrec NotExpression
$creadListPrec :: ReadPrec [NotExpression]
readListPrec :: ReadPrec [NotExpression]
Read, Int -> NotExpression -> ShowS
[NotExpression] -> ShowS
NotExpression -> String
(Int -> NotExpression -> ShowS)
-> (NotExpression -> String)
-> ([NotExpression] -> ShowS)
-> Show NotExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NotExpression -> ShowS
showsPrec :: Int -> NotExpression -> ShowS
$cshow :: NotExpression -> String
show :: NotExpression -> String
$cshowList :: [NotExpression] -> ShowS
showList :: [NotExpression] -> ShowS
Show)

_NotExpression :: Name
_NotExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.NotExpression")

_NotExpression_not :: Name
_NotExpression_not = (String -> Name
Core.Name String
"not")

_NotExpression_expression :: Name
_NotExpression_expression = (String -> Name
Core.Name String
"expression")

data ComparisonExpression = 
  ComparisonExpression {
    ComparisonExpression -> StringListNullPredicateExpression
comparisonExpressionLeft :: StringListNullPredicateExpression,
    ComparisonExpression -> [PartialComparisonExpression]
comparisonExpressionRight :: [PartialComparisonExpression]}
  deriving (ComparisonExpression -> ComparisonExpression -> Bool
(ComparisonExpression -> ComparisonExpression -> Bool)
-> (ComparisonExpression -> ComparisonExpression -> Bool)
-> Eq ComparisonExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ComparisonExpression -> ComparisonExpression -> Bool
== :: ComparisonExpression -> ComparisonExpression -> Bool
$c/= :: ComparisonExpression -> ComparisonExpression -> Bool
/= :: ComparisonExpression -> ComparisonExpression -> Bool
Eq, Eq ComparisonExpression
Eq ComparisonExpression =>
(ComparisonExpression -> ComparisonExpression -> Ordering)
-> (ComparisonExpression -> ComparisonExpression -> Bool)
-> (ComparisonExpression -> ComparisonExpression -> Bool)
-> (ComparisonExpression -> ComparisonExpression -> Bool)
-> (ComparisonExpression -> ComparisonExpression -> Bool)
-> (ComparisonExpression
    -> ComparisonExpression -> ComparisonExpression)
-> (ComparisonExpression
    -> ComparisonExpression -> ComparisonExpression)
-> Ord ComparisonExpression
ComparisonExpression -> ComparisonExpression -> Bool
ComparisonExpression -> ComparisonExpression -> Ordering
ComparisonExpression
-> ComparisonExpression -> ComparisonExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ComparisonExpression -> ComparisonExpression -> Ordering
compare :: ComparisonExpression -> ComparisonExpression -> Ordering
$c< :: ComparisonExpression -> ComparisonExpression -> Bool
< :: ComparisonExpression -> ComparisonExpression -> Bool
$c<= :: ComparisonExpression -> ComparisonExpression -> Bool
<= :: ComparisonExpression -> ComparisonExpression -> Bool
$c> :: ComparisonExpression -> ComparisonExpression -> Bool
> :: ComparisonExpression -> ComparisonExpression -> Bool
$c>= :: ComparisonExpression -> ComparisonExpression -> Bool
>= :: ComparisonExpression -> ComparisonExpression -> Bool
$cmax :: ComparisonExpression
-> ComparisonExpression -> ComparisonExpression
max :: ComparisonExpression
-> ComparisonExpression -> ComparisonExpression
$cmin :: ComparisonExpression
-> ComparisonExpression -> ComparisonExpression
min :: ComparisonExpression
-> ComparisonExpression -> ComparisonExpression
Ord, ReadPrec [ComparisonExpression]
ReadPrec ComparisonExpression
Int -> ReadS ComparisonExpression
ReadS [ComparisonExpression]
(Int -> ReadS ComparisonExpression)
-> ReadS [ComparisonExpression]
-> ReadPrec ComparisonExpression
-> ReadPrec [ComparisonExpression]
-> Read ComparisonExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ComparisonExpression
readsPrec :: Int -> ReadS ComparisonExpression
$creadList :: ReadS [ComparisonExpression]
readList :: ReadS [ComparisonExpression]
$creadPrec :: ReadPrec ComparisonExpression
readPrec :: ReadPrec ComparisonExpression
$creadListPrec :: ReadPrec [ComparisonExpression]
readListPrec :: ReadPrec [ComparisonExpression]
Read, Int -> ComparisonExpression -> ShowS
[ComparisonExpression] -> ShowS
ComparisonExpression -> String
(Int -> ComparisonExpression -> ShowS)
-> (ComparisonExpression -> String)
-> ([ComparisonExpression] -> ShowS)
-> Show ComparisonExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ComparisonExpression -> ShowS
showsPrec :: Int -> ComparisonExpression -> ShowS
$cshow :: ComparisonExpression -> String
show :: ComparisonExpression -> String
$cshowList :: [ComparisonExpression] -> ShowS
showList :: [ComparisonExpression] -> ShowS
Show)

_ComparisonExpression :: Name
_ComparisonExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ComparisonExpression")

_ComparisonExpression_left :: Name
_ComparisonExpression_left = (String -> Name
Core.Name String
"left")

_ComparisonExpression_right :: Name
_ComparisonExpression_right = (String -> Name
Core.Name String
"right")

data ComparisonOperator = 
  ComparisonOperatorEq  |
  ComparisonOperatorNeq  |
  ComparisonOperatorLt  |
  ComparisonOperatorGt  |
  ComparisonOperatorLte  |
  ComparisonOperatorGte 
  deriving (ComparisonOperator -> ComparisonOperator -> Bool
(ComparisonOperator -> ComparisonOperator -> Bool)
-> (ComparisonOperator -> ComparisonOperator -> Bool)
-> Eq ComparisonOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ComparisonOperator -> ComparisonOperator -> Bool
== :: ComparisonOperator -> ComparisonOperator -> Bool
$c/= :: ComparisonOperator -> ComparisonOperator -> Bool
/= :: ComparisonOperator -> ComparisonOperator -> Bool
Eq, Eq ComparisonOperator
Eq ComparisonOperator =>
(ComparisonOperator -> ComparisonOperator -> Ordering)
-> (ComparisonOperator -> ComparisonOperator -> Bool)
-> (ComparisonOperator -> ComparisonOperator -> Bool)
-> (ComparisonOperator -> ComparisonOperator -> Bool)
-> (ComparisonOperator -> ComparisonOperator -> Bool)
-> (ComparisonOperator -> ComparisonOperator -> ComparisonOperator)
-> (ComparisonOperator -> ComparisonOperator -> ComparisonOperator)
-> Ord ComparisonOperator
ComparisonOperator -> ComparisonOperator -> Bool
ComparisonOperator -> ComparisonOperator -> Ordering
ComparisonOperator -> ComparisonOperator -> ComparisonOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ComparisonOperator -> ComparisonOperator -> Ordering
compare :: ComparisonOperator -> ComparisonOperator -> Ordering
$c< :: ComparisonOperator -> ComparisonOperator -> Bool
< :: ComparisonOperator -> ComparisonOperator -> Bool
$c<= :: ComparisonOperator -> ComparisonOperator -> Bool
<= :: ComparisonOperator -> ComparisonOperator -> Bool
$c> :: ComparisonOperator -> ComparisonOperator -> Bool
> :: ComparisonOperator -> ComparisonOperator -> Bool
$c>= :: ComparisonOperator -> ComparisonOperator -> Bool
>= :: ComparisonOperator -> ComparisonOperator -> Bool
$cmax :: ComparisonOperator -> ComparisonOperator -> ComparisonOperator
max :: ComparisonOperator -> ComparisonOperator -> ComparisonOperator
$cmin :: ComparisonOperator -> ComparisonOperator -> ComparisonOperator
min :: ComparisonOperator -> ComparisonOperator -> ComparisonOperator
Ord, ReadPrec [ComparisonOperator]
ReadPrec ComparisonOperator
Int -> ReadS ComparisonOperator
ReadS [ComparisonOperator]
(Int -> ReadS ComparisonOperator)
-> ReadS [ComparisonOperator]
-> ReadPrec ComparisonOperator
-> ReadPrec [ComparisonOperator]
-> Read ComparisonOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ComparisonOperator
readsPrec :: Int -> ReadS ComparisonOperator
$creadList :: ReadS [ComparisonOperator]
readList :: ReadS [ComparisonOperator]
$creadPrec :: ReadPrec ComparisonOperator
readPrec :: ReadPrec ComparisonOperator
$creadListPrec :: ReadPrec [ComparisonOperator]
readListPrec :: ReadPrec [ComparisonOperator]
Read, Int -> ComparisonOperator -> ShowS
[ComparisonOperator] -> ShowS
ComparisonOperator -> String
(Int -> ComparisonOperator -> ShowS)
-> (ComparisonOperator -> String)
-> ([ComparisonOperator] -> ShowS)
-> Show ComparisonOperator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ComparisonOperator -> ShowS
showsPrec :: Int -> ComparisonOperator -> ShowS
$cshow :: ComparisonOperator -> String
show :: ComparisonOperator -> String
$cshowList :: [ComparisonOperator] -> ShowS
showList :: [ComparisonOperator] -> ShowS
Show)

_ComparisonOperator :: Name
_ComparisonOperator = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ComparisonOperator")

_ComparisonOperator_eq :: Name
_ComparisonOperator_eq = (String -> Name
Core.Name String
"eq")

_ComparisonOperator_neq :: Name
_ComparisonOperator_neq = (String -> Name
Core.Name String
"neq")

_ComparisonOperator_lt :: Name
_ComparisonOperator_lt = (String -> Name
Core.Name String
"lt")

_ComparisonOperator_gt :: Name
_ComparisonOperator_gt = (String -> Name
Core.Name String
"gt")

_ComparisonOperator_lte :: Name
_ComparisonOperator_lte = (String -> Name
Core.Name String
"lte")

_ComparisonOperator_gte :: Name
_ComparisonOperator_gte = (String -> Name
Core.Name String
"gte")

data PartialComparisonExpression = 
  PartialComparisonExpression {
    PartialComparisonExpression -> ComparisonOperator
partialComparisonExpressionOperator :: ComparisonOperator,
    PartialComparisonExpression -> StringListNullPredicateExpression
partialComparisonExpressionRight :: StringListNullPredicateExpression}
  deriving (PartialComparisonExpression -> PartialComparisonExpression -> Bool
(PartialComparisonExpression
 -> PartialComparisonExpression -> Bool)
-> (PartialComparisonExpression
    -> PartialComparisonExpression -> Bool)
-> Eq PartialComparisonExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
== :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
$c/= :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
/= :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
Eq, Eq PartialComparisonExpression
Eq PartialComparisonExpression =>
(PartialComparisonExpression
 -> PartialComparisonExpression -> Ordering)
-> (PartialComparisonExpression
    -> PartialComparisonExpression -> Bool)
-> (PartialComparisonExpression
    -> PartialComparisonExpression -> Bool)
-> (PartialComparisonExpression
    -> PartialComparisonExpression -> Bool)
-> (PartialComparisonExpression
    -> PartialComparisonExpression -> Bool)
-> (PartialComparisonExpression
    -> PartialComparisonExpression -> PartialComparisonExpression)
-> (PartialComparisonExpression
    -> PartialComparisonExpression -> PartialComparisonExpression)
-> Ord PartialComparisonExpression
PartialComparisonExpression -> PartialComparisonExpression -> Bool
PartialComparisonExpression
-> PartialComparisonExpression -> Ordering
PartialComparisonExpression
-> PartialComparisonExpression -> PartialComparisonExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PartialComparisonExpression
-> PartialComparisonExpression -> Ordering
compare :: PartialComparisonExpression
-> PartialComparisonExpression -> Ordering
$c< :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
< :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
$c<= :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
<= :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
$c> :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
> :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
$c>= :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
>= :: PartialComparisonExpression -> PartialComparisonExpression -> Bool
$cmax :: PartialComparisonExpression
-> PartialComparisonExpression -> PartialComparisonExpression
max :: PartialComparisonExpression
-> PartialComparisonExpression -> PartialComparisonExpression
$cmin :: PartialComparisonExpression
-> PartialComparisonExpression -> PartialComparisonExpression
min :: PartialComparisonExpression
-> PartialComparisonExpression -> PartialComparisonExpression
Ord, ReadPrec [PartialComparisonExpression]
ReadPrec PartialComparisonExpression
Int -> ReadS PartialComparisonExpression
ReadS [PartialComparisonExpression]
(Int -> ReadS PartialComparisonExpression)
-> ReadS [PartialComparisonExpression]
-> ReadPrec PartialComparisonExpression
-> ReadPrec [PartialComparisonExpression]
-> Read PartialComparisonExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PartialComparisonExpression
readsPrec :: Int -> ReadS PartialComparisonExpression
$creadList :: ReadS [PartialComparisonExpression]
readList :: ReadS [PartialComparisonExpression]
$creadPrec :: ReadPrec PartialComparisonExpression
readPrec :: ReadPrec PartialComparisonExpression
$creadListPrec :: ReadPrec [PartialComparisonExpression]
readListPrec :: ReadPrec [PartialComparisonExpression]
Read, Int -> PartialComparisonExpression -> ShowS
[PartialComparisonExpression] -> ShowS
PartialComparisonExpression -> String
(Int -> PartialComparisonExpression -> ShowS)
-> (PartialComparisonExpression -> String)
-> ([PartialComparisonExpression] -> ShowS)
-> Show PartialComparisonExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PartialComparisonExpression -> ShowS
showsPrec :: Int -> PartialComparisonExpression -> ShowS
$cshow :: PartialComparisonExpression -> String
show :: PartialComparisonExpression -> String
$cshowList :: [PartialComparisonExpression] -> ShowS
showList :: [PartialComparisonExpression] -> ShowS
Show)

_PartialComparisonExpression :: Name
_PartialComparisonExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PartialComparisonExpression")

_PartialComparisonExpression_operator :: Name
_PartialComparisonExpression_operator = (String -> Name
Core.Name String
"operator")

_PartialComparisonExpression_right :: Name
_PartialComparisonExpression_right = (String -> Name
Core.Name String
"right")

data StringListNullPredicateExpression = 
  StringListNullPredicateExpression {
    StringListNullPredicateExpression -> AddOrSubtractExpression
stringListNullPredicateExpressionLeft :: AddOrSubtractExpression,
    StringListNullPredicateExpression
-> [StringListNullPredicateRightHandSide]
stringListNullPredicateExpressionRight :: [StringListNullPredicateRightHandSide]}
  deriving (StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
(StringListNullPredicateExpression
 -> StringListNullPredicateExpression -> Bool)
-> (StringListNullPredicateExpression
    -> StringListNullPredicateExpression -> Bool)
-> Eq StringListNullPredicateExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
== :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
$c/= :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
/= :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
Eq, Eq StringListNullPredicateExpression
Eq StringListNullPredicateExpression =>
(StringListNullPredicateExpression
 -> StringListNullPredicateExpression -> Ordering)
-> (StringListNullPredicateExpression
    -> StringListNullPredicateExpression -> Bool)
-> (StringListNullPredicateExpression
    -> StringListNullPredicateExpression -> Bool)
-> (StringListNullPredicateExpression
    -> StringListNullPredicateExpression -> Bool)
-> (StringListNullPredicateExpression
    -> StringListNullPredicateExpression -> Bool)
-> (StringListNullPredicateExpression
    -> StringListNullPredicateExpression
    -> StringListNullPredicateExpression)
-> (StringListNullPredicateExpression
    -> StringListNullPredicateExpression
    -> StringListNullPredicateExpression)
-> Ord StringListNullPredicateExpression
StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Ordering
StringListNullPredicateExpression
-> StringListNullPredicateExpression
-> StringListNullPredicateExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Ordering
compare :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Ordering
$c< :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
< :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
$c<= :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
<= :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
$c> :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
> :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
$c>= :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
>= :: StringListNullPredicateExpression
-> StringListNullPredicateExpression -> Bool
$cmax :: StringListNullPredicateExpression
-> StringListNullPredicateExpression
-> StringListNullPredicateExpression
max :: StringListNullPredicateExpression
-> StringListNullPredicateExpression
-> StringListNullPredicateExpression
$cmin :: StringListNullPredicateExpression
-> StringListNullPredicateExpression
-> StringListNullPredicateExpression
min :: StringListNullPredicateExpression
-> StringListNullPredicateExpression
-> StringListNullPredicateExpression
Ord, ReadPrec [StringListNullPredicateExpression]
ReadPrec StringListNullPredicateExpression
Int -> ReadS StringListNullPredicateExpression
ReadS [StringListNullPredicateExpression]
(Int -> ReadS StringListNullPredicateExpression)
-> ReadS [StringListNullPredicateExpression]
-> ReadPrec StringListNullPredicateExpression
-> ReadPrec [StringListNullPredicateExpression]
-> Read StringListNullPredicateExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StringListNullPredicateExpression
readsPrec :: Int -> ReadS StringListNullPredicateExpression
$creadList :: ReadS [StringListNullPredicateExpression]
readList :: ReadS [StringListNullPredicateExpression]
$creadPrec :: ReadPrec StringListNullPredicateExpression
readPrec :: ReadPrec StringListNullPredicateExpression
$creadListPrec :: ReadPrec [StringListNullPredicateExpression]
readListPrec :: ReadPrec [StringListNullPredicateExpression]
Read, Int -> StringListNullPredicateExpression -> ShowS
[StringListNullPredicateExpression] -> ShowS
StringListNullPredicateExpression -> String
(Int -> StringListNullPredicateExpression -> ShowS)
-> (StringListNullPredicateExpression -> String)
-> ([StringListNullPredicateExpression] -> ShowS)
-> Show StringListNullPredicateExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StringListNullPredicateExpression -> ShowS
showsPrec :: Int -> StringListNullPredicateExpression -> ShowS
$cshow :: StringListNullPredicateExpression -> String
show :: StringListNullPredicateExpression -> String
$cshowList :: [StringListNullPredicateExpression] -> ShowS
showList :: [StringListNullPredicateExpression] -> ShowS
Show)

_StringListNullPredicateExpression :: Name
_StringListNullPredicateExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.StringListNullPredicateExpression")

_StringListNullPredicateExpression_left :: Name
_StringListNullPredicateExpression_left = (String -> Name
Core.Name String
"left")

_StringListNullPredicateExpression_right :: Name
_StringListNullPredicateExpression_right = (String -> Name
Core.Name String
"right")

data StringListNullPredicateRightHandSide = 
  StringListNullPredicateRightHandSideString StringPredicateExpression |
  StringListNullPredicateRightHandSideList ListPredicateExpression |
  StringListNullPredicateRightHandSideNull NullPredicateExpression
  deriving (StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
(StringListNullPredicateRightHandSide
 -> StringListNullPredicateRightHandSide -> Bool)
-> (StringListNullPredicateRightHandSide
    -> StringListNullPredicateRightHandSide -> Bool)
-> Eq StringListNullPredicateRightHandSide
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
== :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
$c/= :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
/= :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
Eq, Eq StringListNullPredicateRightHandSide
Eq StringListNullPredicateRightHandSide =>
(StringListNullPredicateRightHandSide
 -> StringListNullPredicateRightHandSide -> Ordering)
-> (StringListNullPredicateRightHandSide
    -> StringListNullPredicateRightHandSide -> Bool)
-> (StringListNullPredicateRightHandSide
    -> StringListNullPredicateRightHandSide -> Bool)
-> (StringListNullPredicateRightHandSide
    -> StringListNullPredicateRightHandSide -> Bool)
-> (StringListNullPredicateRightHandSide
    -> StringListNullPredicateRightHandSide -> Bool)
-> (StringListNullPredicateRightHandSide
    -> StringListNullPredicateRightHandSide
    -> StringListNullPredicateRightHandSide)
-> (StringListNullPredicateRightHandSide
    -> StringListNullPredicateRightHandSide
    -> StringListNullPredicateRightHandSide)
-> Ord StringListNullPredicateRightHandSide
StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Ordering
StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Ordering
compare :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Ordering
$c< :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
< :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
$c<= :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
<= :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
$c> :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
> :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
$c>= :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
>= :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide -> Bool
$cmax :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide
max :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide
$cmin :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide
min :: StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide
-> StringListNullPredicateRightHandSide
Ord, ReadPrec [StringListNullPredicateRightHandSide]
ReadPrec StringListNullPredicateRightHandSide
Int -> ReadS StringListNullPredicateRightHandSide
ReadS [StringListNullPredicateRightHandSide]
(Int -> ReadS StringListNullPredicateRightHandSide)
-> ReadS [StringListNullPredicateRightHandSide]
-> ReadPrec StringListNullPredicateRightHandSide
-> ReadPrec [StringListNullPredicateRightHandSide]
-> Read StringListNullPredicateRightHandSide
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StringListNullPredicateRightHandSide
readsPrec :: Int -> ReadS StringListNullPredicateRightHandSide
$creadList :: ReadS [StringListNullPredicateRightHandSide]
readList :: ReadS [StringListNullPredicateRightHandSide]
$creadPrec :: ReadPrec StringListNullPredicateRightHandSide
readPrec :: ReadPrec StringListNullPredicateRightHandSide
$creadListPrec :: ReadPrec [StringListNullPredicateRightHandSide]
readListPrec :: ReadPrec [StringListNullPredicateRightHandSide]
Read, Int -> StringListNullPredicateRightHandSide -> ShowS
[StringListNullPredicateRightHandSide] -> ShowS
StringListNullPredicateRightHandSide -> String
(Int -> StringListNullPredicateRightHandSide -> ShowS)
-> (StringListNullPredicateRightHandSide -> String)
-> ([StringListNullPredicateRightHandSide] -> ShowS)
-> Show StringListNullPredicateRightHandSide
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StringListNullPredicateRightHandSide -> ShowS
showsPrec :: Int -> StringListNullPredicateRightHandSide -> ShowS
$cshow :: StringListNullPredicateRightHandSide -> String
show :: StringListNullPredicateRightHandSide -> String
$cshowList :: [StringListNullPredicateRightHandSide] -> ShowS
showList :: [StringListNullPredicateRightHandSide] -> ShowS
Show)

_StringListNullPredicateRightHandSide :: Name
_StringListNullPredicateRightHandSide = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.StringListNullPredicateRightHandSide")

_StringListNullPredicateRightHandSide_string :: Name
_StringListNullPredicateRightHandSide_string = (String -> Name
Core.Name String
"string")

_StringListNullPredicateRightHandSide_list :: Name
_StringListNullPredicateRightHandSide_list = (String -> Name
Core.Name String
"list")

_StringListNullPredicateRightHandSide_null :: Name
_StringListNullPredicateRightHandSide_null = (String -> Name
Core.Name String
"null")

data StringPredicateExpression = 
  StringPredicateExpression {
    StringPredicateExpression -> StringPredicateOperator
stringPredicateExpressionOperator :: StringPredicateOperator,
    StringPredicateExpression -> AddOrSubtractExpression
stringPredicateExpressionExpression :: AddOrSubtractExpression}
  deriving (StringPredicateExpression -> StringPredicateExpression -> Bool
(StringPredicateExpression -> StringPredicateExpression -> Bool)
-> (StringPredicateExpression -> StringPredicateExpression -> Bool)
-> Eq StringPredicateExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StringPredicateExpression -> StringPredicateExpression -> Bool
== :: StringPredicateExpression -> StringPredicateExpression -> Bool
$c/= :: StringPredicateExpression -> StringPredicateExpression -> Bool
/= :: StringPredicateExpression -> StringPredicateExpression -> Bool
Eq, Eq StringPredicateExpression
Eq StringPredicateExpression =>
(StringPredicateExpression
 -> StringPredicateExpression -> Ordering)
-> (StringPredicateExpression -> StringPredicateExpression -> Bool)
-> (StringPredicateExpression -> StringPredicateExpression -> Bool)
-> (StringPredicateExpression -> StringPredicateExpression -> Bool)
-> (StringPredicateExpression -> StringPredicateExpression -> Bool)
-> (StringPredicateExpression
    -> StringPredicateExpression -> StringPredicateExpression)
-> (StringPredicateExpression
    -> StringPredicateExpression -> StringPredicateExpression)
-> Ord StringPredicateExpression
StringPredicateExpression -> StringPredicateExpression -> Bool
StringPredicateExpression -> StringPredicateExpression -> Ordering
StringPredicateExpression
-> StringPredicateExpression -> StringPredicateExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StringPredicateExpression -> StringPredicateExpression -> Ordering
compare :: StringPredicateExpression -> StringPredicateExpression -> Ordering
$c< :: StringPredicateExpression -> StringPredicateExpression -> Bool
< :: StringPredicateExpression -> StringPredicateExpression -> Bool
$c<= :: StringPredicateExpression -> StringPredicateExpression -> Bool
<= :: StringPredicateExpression -> StringPredicateExpression -> Bool
$c> :: StringPredicateExpression -> StringPredicateExpression -> Bool
> :: StringPredicateExpression -> StringPredicateExpression -> Bool
$c>= :: StringPredicateExpression -> StringPredicateExpression -> Bool
>= :: StringPredicateExpression -> StringPredicateExpression -> Bool
$cmax :: StringPredicateExpression
-> StringPredicateExpression -> StringPredicateExpression
max :: StringPredicateExpression
-> StringPredicateExpression -> StringPredicateExpression
$cmin :: StringPredicateExpression
-> StringPredicateExpression -> StringPredicateExpression
min :: StringPredicateExpression
-> StringPredicateExpression -> StringPredicateExpression
Ord, ReadPrec [StringPredicateExpression]
ReadPrec StringPredicateExpression
Int -> ReadS StringPredicateExpression
ReadS [StringPredicateExpression]
(Int -> ReadS StringPredicateExpression)
-> ReadS [StringPredicateExpression]
-> ReadPrec StringPredicateExpression
-> ReadPrec [StringPredicateExpression]
-> Read StringPredicateExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StringPredicateExpression
readsPrec :: Int -> ReadS StringPredicateExpression
$creadList :: ReadS [StringPredicateExpression]
readList :: ReadS [StringPredicateExpression]
$creadPrec :: ReadPrec StringPredicateExpression
readPrec :: ReadPrec StringPredicateExpression
$creadListPrec :: ReadPrec [StringPredicateExpression]
readListPrec :: ReadPrec [StringPredicateExpression]
Read, Int -> StringPredicateExpression -> ShowS
[StringPredicateExpression] -> ShowS
StringPredicateExpression -> String
(Int -> StringPredicateExpression -> ShowS)
-> (StringPredicateExpression -> String)
-> ([StringPredicateExpression] -> ShowS)
-> Show StringPredicateExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StringPredicateExpression -> ShowS
showsPrec :: Int -> StringPredicateExpression -> ShowS
$cshow :: StringPredicateExpression -> String
show :: StringPredicateExpression -> String
$cshowList :: [StringPredicateExpression] -> ShowS
showList :: [StringPredicateExpression] -> ShowS
Show)

_StringPredicateExpression :: Name
_StringPredicateExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.StringPredicateExpression")

_StringPredicateExpression_operator :: Name
_StringPredicateExpression_operator = (String -> Name
Core.Name String
"operator")

_StringPredicateExpression_expression :: Name
_StringPredicateExpression_expression = (String -> Name
Core.Name String
"expression")

data StringPredicateOperator = 
  StringPredicateOperatorStartsWith  |
  StringPredicateOperatorEndsWith  |
  StringPredicateOperatorContains 
  deriving (StringPredicateOperator -> StringPredicateOperator -> Bool
(StringPredicateOperator -> StringPredicateOperator -> Bool)
-> (StringPredicateOperator -> StringPredicateOperator -> Bool)
-> Eq StringPredicateOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StringPredicateOperator -> StringPredicateOperator -> Bool
== :: StringPredicateOperator -> StringPredicateOperator -> Bool
$c/= :: StringPredicateOperator -> StringPredicateOperator -> Bool
/= :: StringPredicateOperator -> StringPredicateOperator -> Bool
Eq, Eq StringPredicateOperator
Eq StringPredicateOperator =>
(StringPredicateOperator -> StringPredicateOperator -> Ordering)
-> (StringPredicateOperator -> StringPredicateOperator -> Bool)
-> (StringPredicateOperator -> StringPredicateOperator -> Bool)
-> (StringPredicateOperator -> StringPredicateOperator -> Bool)
-> (StringPredicateOperator -> StringPredicateOperator -> Bool)
-> (StringPredicateOperator
    -> StringPredicateOperator -> StringPredicateOperator)
-> (StringPredicateOperator
    -> StringPredicateOperator -> StringPredicateOperator)
-> Ord StringPredicateOperator
StringPredicateOperator -> StringPredicateOperator -> Bool
StringPredicateOperator -> StringPredicateOperator -> Ordering
StringPredicateOperator
-> StringPredicateOperator -> StringPredicateOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StringPredicateOperator -> StringPredicateOperator -> Ordering
compare :: StringPredicateOperator -> StringPredicateOperator -> Ordering
$c< :: StringPredicateOperator -> StringPredicateOperator -> Bool
< :: StringPredicateOperator -> StringPredicateOperator -> Bool
$c<= :: StringPredicateOperator -> StringPredicateOperator -> Bool
<= :: StringPredicateOperator -> StringPredicateOperator -> Bool
$c> :: StringPredicateOperator -> StringPredicateOperator -> Bool
> :: StringPredicateOperator -> StringPredicateOperator -> Bool
$c>= :: StringPredicateOperator -> StringPredicateOperator -> Bool
>= :: StringPredicateOperator -> StringPredicateOperator -> Bool
$cmax :: StringPredicateOperator
-> StringPredicateOperator -> StringPredicateOperator
max :: StringPredicateOperator
-> StringPredicateOperator -> StringPredicateOperator
$cmin :: StringPredicateOperator
-> StringPredicateOperator -> StringPredicateOperator
min :: StringPredicateOperator
-> StringPredicateOperator -> StringPredicateOperator
Ord, ReadPrec [StringPredicateOperator]
ReadPrec StringPredicateOperator
Int -> ReadS StringPredicateOperator
ReadS [StringPredicateOperator]
(Int -> ReadS StringPredicateOperator)
-> ReadS [StringPredicateOperator]
-> ReadPrec StringPredicateOperator
-> ReadPrec [StringPredicateOperator]
-> Read StringPredicateOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StringPredicateOperator
readsPrec :: Int -> ReadS StringPredicateOperator
$creadList :: ReadS [StringPredicateOperator]
readList :: ReadS [StringPredicateOperator]
$creadPrec :: ReadPrec StringPredicateOperator
readPrec :: ReadPrec StringPredicateOperator
$creadListPrec :: ReadPrec [StringPredicateOperator]
readListPrec :: ReadPrec [StringPredicateOperator]
Read, Int -> StringPredicateOperator -> ShowS
[StringPredicateOperator] -> ShowS
StringPredicateOperator -> String
(Int -> StringPredicateOperator -> ShowS)
-> (StringPredicateOperator -> String)
-> ([StringPredicateOperator] -> ShowS)
-> Show StringPredicateOperator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StringPredicateOperator -> ShowS
showsPrec :: Int -> StringPredicateOperator -> ShowS
$cshow :: StringPredicateOperator -> String
show :: StringPredicateOperator -> String
$cshowList :: [StringPredicateOperator] -> ShowS
showList :: [StringPredicateOperator] -> ShowS
Show)

_StringPredicateOperator :: Name
_StringPredicateOperator = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.StringPredicateOperator")

_StringPredicateOperator_startsWith :: Name
_StringPredicateOperator_startsWith = (String -> Name
Core.Name String
"startsWith")

_StringPredicateOperator_endsWith :: Name
_StringPredicateOperator_endsWith = (String -> Name
Core.Name String
"endsWith")

_StringPredicateOperator_contains :: Name
_StringPredicateOperator_contains = (String -> Name
Core.Name String
"contains")

newtype ListPredicateExpression = 
  ListPredicateExpression {
    ListPredicateExpression -> AddOrSubtractExpression
unListPredicateExpression :: AddOrSubtractExpression}
  deriving (ListPredicateExpression -> ListPredicateExpression -> Bool
(ListPredicateExpression -> ListPredicateExpression -> Bool)
-> (ListPredicateExpression -> ListPredicateExpression -> Bool)
-> Eq ListPredicateExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListPredicateExpression -> ListPredicateExpression -> Bool
== :: ListPredicateExpression -> ListPredicateExpression -> Bool
$c/= :: ListPredicateExpression -> ListPredicateExpression -> Bool
/= :: ListPredicateExpression -> ListPredicateExpression -> Bool
Eq, Eq ListPredicateExpression
Eq ListPredicateExpression =>
(ListPredicateExpression -> ListPredicateExpression -> Ordering)
-> (ListPredicateExpression -> ListPredicateExpression -> Bool)
-> (ListPredicateExpression -> ListPredicateExpression -> Bool)
-> (ListPredicateExpression -> ListPredicateExpression -> Bool)
-> (ListPredicateExpression -> ListPredicateExpression -> Bool)
-> (ListPredicateExpression
    -> ListPredicateExpression -> ListPredicateExpression)
-> (ListPredicateExpression
    -> ListPredicateExpression -> ListPredicateExpression)
-> Ord ListPredicateExpression
ListPredicateExpression -> ListPredicateExpression -> Bool
ListPredicateExpression -> ListPredicateExpression -> Ordering
ListPredicateExpression
-> ListPredicateExpression -> ListPredicateExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ListPredicateExpression -> ListPredicateExpression -> Ordering
compare :: ListPredicateExpression -> ListPredicateExpression -> Ordering
$c< :: ListPredicateExpression -> ListPredicateExpression -> Bool
< :: ListPredicateExpression -> ListPredicateExpression -> Bool
$c<= :: ListPredicateExpression -> ListPredicateExpression -> Bool
<= :: ListPredicateExpression -> ListPredicateExpression -> Bool
$c> :: ListPredicateExpression -> ListPredicateExpression -> Bool
> :: ListPredicateExpression -> ListPredicateExpression -> Bool
$c>= :: ListPredicateExpression -> ListPredicateExpression -> Bool
>= :: ListPredicateExpression -> ListPredicateExpression -> Bool
$cmax :: ListPredicateExpression
-> ListPredicateExpression -> ListPredicateExpression
max :: ListPredicateExpression
-> ListPredicateExpression -> ListPredicateExpression
$cmin :: ListPredicateExpression
-> ListPredicateExpression -> ListPredicateExpression
min :: ListPredicateExpression
-> ListPredicateExpression -> ListPredicateExpression
Ord, ReadPrec [ListPredicateExpression]
ReadPrec ListPredicateExpression
Int -> ReadS ListPredicateExpression
ReadS [ListPredicateExpression]
(Int -> ReadS ListPredicateExpression)
-> ReadS [ListPredicateExpression]
-> ReadPrec ListPredicateExpression
-> ReadPrec [ListPredicateExpression]
-> Read ListPredicateExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ListPredicateExpression
readsPrec :: Int -> ReadS ListPredicateExpression
$creadList :: ReadS [ListPredicateExpression]
readList :: ReadS [ListPredicateExpression]
$creadPrec :: ReadPrec ListPredicateExpression
readPrec :: ReadPrec ListPredicateExpression
$creadListPrec :: ReadPrec [ListPredicateExpression]
readListPrec :: ReadPrec [ListPredicateExpression]
Read, Int -> ListPredicateExpression -> ShowS
[ListPredicateExpression] -> ShowS
ListPredicateExpression -> String
(Int -> ListPredicateExpression -> ShowS)
-> (ListPredicateExpression -> String)
-> ([ListPredicateExpression] -> ShowS)
-> Show ListPredicateExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListPredicateExpression -> ShowS
showsPrec :: Int -> ListPredicateExpression -> ShowS
$cshow :: ListPredicateExpression -> String
show :: ListPredicateExpression -> String
$cshowList :: [ListPredicateExpression] -> ShowS
showList :: [ListPredicateExpression] -> ShowS
Show)

_ListPredicateExpression :: Name
_ListPredicateExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ListPredicateExpression")

newtype NullPredicateExpression = 
  NullPredicateExpression {
    NullPredicateExpression -> Bool
unNullPredicateExpression :: Bool}
  deriving (NullPredicateExpression -> NullPredicateExpression -> Bool
(NullPredicateExpression -> NullPredicateExpression -> Bool)
-> (NullPredicateExpression -> NullPredicateExpression -> Bool)
-> Eq NullPredicateExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NullPredicateExpression -> NullPredicateExpression -> Bool
== :: NullPredicateExpression -> NullPredicateExpression -> Bool
$c/= :: NullPredicateExpression -> NullPredicateExpression -> Bool
/= :: NullPredicateExpression -> NullPredicateExpression -> Bool
Eq, Eq NullPredicateExpression
Eq NullPredicateExpression =>
(NullPredicateExpression -> NullPredicateExpression -> Ordering)
-> (NullPredicateExpression -> NullPredicateExpression -> Bool)
-> (NullPredicateExpression -> NullPredicateExpression -> Bool)
-> (NullPredicateExpression -> NullPredicateExpression -> Bool)
-> (NullPredicateExpression -> NullPredicateExpression -> Bool)
-> (NullPredicateExpression
    -> NullPredicateExpression -> NullPredicateExpression)
-> (NullPredicateExpression
    -> NullPredicateExpression -> NullPredicateExpression)
-> Ord NullPredicateExpression
NullPredicateExpression -> NullPredicateExpression -> Bool
NullPredicateExpression -> NullPredicateExpression -> Ordering
NullPredicateExpression
-> NullPredicateExpression -> NullPredicateExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NullPredicateExpression -> NullPredicateExpression -> Ordering
compare :: NullPredicateExpression -> NullPredicateExpression -> Ordering
$c< :: NullPredicateExpression -> NullPredicateExpression -> Bool
< :: NullPredicateExpression -> NullPredicateExpression -> Bool
$c<= :: NullPredicateExpression -> NullPredicateExpression -> Bool
<= :: NullPredicateExpression -> NullPredicateExpression -> Bool
$c> :: NullPredicateExpression -> NullPredicateExpression -> Bool
> :: NullPredicateExpression -> NullPredicateExpression -> Bool
$c>= :: NullPredicateExpression -> NullPredicateExpression -> Bool
>= :: NullPredicateExpression -> NullPredicateExpression -> Bool
$cmax :: NullPredicateExpression
-> NullPredicateExpression -> NullPredicateExpression
max :: NullPredicateExpression
-> NullPredicateExpression -> NullPredicateExpression
$cmin :: NullPredicateExpression
-> NullPredicateExpression -> NullPredicateExpression
min :: NullPredicateExpression
-> NullPredicateExpression -> NullPredicateExpression
Ord, ReadPrec [NullPredicateExpression]
ReadPrec NullPredicateExpression
Int -> ReadS NullPredicateExpression
ReadS [NullPredicateExpression]
(Int -> ReadS NullPredicateExpression)
-> ReadS [NullPredicateExpression]
-> ReadPrec NullPredicateExpression
-> ReadPrec [NullPredicateExpression]
-> Read NullPredicateExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NullPredicateExpression
readsPrec :: Int -> ReadS NullPredicateExpression
$creadList :: ReadS [NullPredicateExpression]
readList :: ReadS [NullPredicateExpression]
$creadPrec :: ReadPrec NullPredicateExpression
readPrec :: ReadPrec NullPredicateExpression
$creadListPrec :: ReadPrec [NullPredicateExpression]
readListPrec :: ReadPrec [NullPredicateExpression]
Read, Int -> NullPredicateExpression -> ShowS
[NullPredicateExpression] -> ShowS
NullPredicateExpression -> String
(Int -> NullPredicateExpression -> ShowS)
-> (NullPredicateExpression -> String)
-> ([NullPredicateExpression] -> ShowS)
-> Show NullPredicateExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NullPredicateExpression -> ShowS
showsPrec :: Int -> NullPredicateExpression -> ShowS
$cshow :: NullPredicateExpression -> String
show :: NullPredicateExpression -> String
$cshowList :: [NullPredicateExpression] -> ShowS
showList :: [NullPredicateExpression] -> ShowS
Show)

_NullPredicateExpression :: Name
_NullPredicateExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.NullPredicateExpression")

data AddOrSubtractExpression = 
  AddOrSubtractExpression {
    AddOrSubtractExpression -> MultiplyDivideModuloExpression
addOrSubtractExpressionLeft :: MultiplyDivideModuloExpression,
    AddOrSubtractExpression -> [AddOrSubtractRightHandSide]
addOrSubtractExpressionRight :: [AddOrSubtractRightHandSide]}
  deriving (AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
(AddOrSubtractExpression -> AddOrSubtractExpression -> Bool)
-> (AddOrSubtractExpression -> AddOrSubtractExpression -> Bool)
-> Eq AddOrSubtractExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
== :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
$c/= :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
/= :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
Eq, Eq AddOrSubtractExpression
Eq AddOrSubtractExpression =>
(AddOrSubtractExpression -> AddOrSubtractExpression -> Ordering)
-> (AddOrSubtractExpression -> AddOrSubtractExpression -> Bool)
-> (AddOrSubtractExpression -> AddOrSubtractExpression -> Bool)
-> (AddOrSubtractExpression -> AddOrSubtractExpression -> Bool)
-> (AddOrSubtractExpression -> AddOrSubtractExpression -> Bool)
-> (AddOrSubtractExpression
    -> AddOrSubtractExpression -> AddOrSubtractExpression)
-> (AddOrSubtractExpression
    -> AddOrSubtractExpression -> AddOrSubtractExpression)
-> Ord AddOrSubtractExpression
AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
AddOrSubtractExpression -> AddOrSubtractExpression -> Ordering
AddOrSubtractExpression
-> AddOrSubtractExpression -> AddOrSubtractExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AddOrSubtractExpression -> AddOrSubtractExpression -> Ordering
compare :: AddOrSubtractExpression -> AddOrSubtractExpression -> Ordering
$c< :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
< :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
$c<= :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
<= :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
$c> :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
> :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
$c>= :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
>= :: AddOrSubtractExpression -> AddOrSubtractExpression -> Bool
$cmax :: AddOrSubtractExpression
-> AddOrSubtractExpression -> AddOrSubtractExpression
max :: AddOrSubtractExpression
-> AddOrSubtractExpression -> AddOrSubtractExpression
$cmin :: AddOrSubtractExpression
-> AddOrSubtractExpression -> AddOrSubtractExpression
min :: AddOrSubtractExpression
-> AddOrSubtractExpression -> AddOrSubtractExpression
Ord, ReadPrec [AddOrSubtractExpression]
ReadPrec AddOrSubtractExpression
Int -> ReadS AddOrSubtractExpression
ReadS [AddOrSubtractExpression]
(Int -> ReadS AddOrSubtractExpression)
-> ReadS [AddOrSubtractExpression]
-> ReadPrec AddOrSubtractExpression
-> ReadPrec [AddOrSubtractExpression]
-> Read AddOrSubtractExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AddOrSubtractExpression
readsPrec :: Int -> ReadS AddOrSubtractExpression
$creadList :: ReadS [AddOrSubtractExpression]
readList :: ReadS [AddOrSubtractExpression]
$creadPrec :: ReadPrec AddOrSubtractExpression
readPrec :: ReadPrec AddOrSubtractExpression
$creadListPrec :: ReadPrec [AddOrSubtractExpression]
readListPrec :: ReadPrec [AddOrSubtractExpression]
Read, Int -> AddOrSubtractExpression -> ShowS
[AddOrSubtractExpression] -> ShowS
AddOrSubtractExpression -> String
(Int -> AddOrSubtractExpression -> ShowS)
-> (AddOrSubtractExpression -> String)
-> ([AddOrSubtractExpression] -> ShowS)
-> Show AddOrSubtractExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AddOrSubtractExpression -> ShowS
showsPrec :: Int -> AddOrSubtractExpression -> ShowS
$cshow :: AddOrSubtractExpression -> String
show :: AddOrSubtractExpression -> String
$cshowList :: [AddOrSubtractExpression] -> ShowS
showList :: [AddOrSubtractExpression] -> ShowS
Show)

_AddOrSubtractExpression :: Name
_AddOrSubtractExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.AddOrSubtractExpression")

_AddOrSubtractExpression_left :: Name
_AddOrSubtractExpression_left = (String -> Name
Core.Name String
"left")

_AddOrSubtractExpression_right :: Name
_AddOrSubtractExpression_right = (String -> Name
Core.Name String
"right")

data AddOrSubtractRightHandSide = 
  AddOrSubtractRightHandSide {
    AddOrSubtractRightHandSide -> AddOrSubtractOperator
addOrSubtractRightHandSideOperator :: AddOrSubtractOperator,
    AddOrSubtractRightHandSide -> MultiplyDivideModuloExpression
addOrSubtractRightHandSideExpression :: MultiplyDivideModuloExpression}
  deriving (AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
(AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool)
-> (AddOrSubtractRightHandSide
    -> AddOrSubtractRightHandSide -> Bool)
-> Eq AddOrSubtractRightHandSide
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
== :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
$c/= :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
/= :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
Eq, Eq AddOrSubtractRightHandSide
Eq AddOrSubtractRightHandSide =>
(AddOrSubtractRightHandSide
 -> AddOrSubtractRightHandSide -> Ordering)
-> (AddOrSubtractRightHandSide
    -> AddOrSubtractRightHandSide -> Bool)
-> (AddOrSubtractRightHandSide
    -> AddOrSubtractRightHandSide -> Bool)
-> (AddOrSubtractRightHandSide
    -> AddOrSubtractRightHandSide -> Bool)
-> (AddOrSubtractRightHandSide
    -> AddOrSubtractRightHandSide -> Bool)
-> (AddOrSubtractRightHandSide
    -> AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide)
-> (AddOrSubtractRightHandSide
    -> AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide)
-> Ord AddOrSubtractRightHandSide
AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
AddOrSubtractRightHandSide
-> AddOrSubtractRightHandSide -> Ordering
AddOrSubtractRightHandSide
-> AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AddOrSubtractRightHandSide
-> AddOrSubtractRightHandSide -> Ordering
compare :: AddOrSubtractRightHandSide
-> AddOrSubtractRightHandSide -> Ordering
$c< :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
< :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
$c<= :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
<= :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
$c> :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
> :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
$c>= :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
>= :: AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide -> Bool
$cmax :: AddOrSubtractRightHandSide
-> AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide
max :: AddOrSubtractRightHandSide
-> AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide
$cmin :: AddOrSubtractRightHandSide
-> AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide
min :: AddOrSubtractRightHandSide
-> AddOrSubtractRightHandSide -> AddOrSubtractRightHandSide
Ord, ReadPrec [AddOrSubtractRightHandSide]
ReadPrec AddOrSubtractRightHandSide
Int -> ReadS AddOrSubtractRightHandSide
ReadS [AddOrSubtractRightHandSide]
(Int -> ReadS AddOrSubtractRightHandSide)
-> ReadS [AddOrSubtractRightHandSide]
-> ReadPrec AddOrSubtractRightHandSide
-> ReadPrec [AddOrSubtractRightHandSide]
-> Read AddOrSubtractRightHandSide
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AddOrSubtractRightHandSide
readsPrec :: Int -> ReadS AddOrSubtractRightHandSide
$creadList :: ReadS [AddOrSubtractRightHandSide]
readList :: ReadS [AddOrSubtractRightHandSide]
$creadPrec :: ReadPrec AddOrSubtractRightHandSide
readPrec :: ReadPrec AddOrSubtractRightHandSide
$creadListPrec :: ReadPrec [AddOrSubtractRightHandSide]
readListPrec :: ReadPrec [AddOrSubtractRightHandSide]
Read, Int -> AddOrSubtractRightHandSide -> ShowS
[AddOrSubtractRightHandSide] -> ShowS
AddOrSubtractRightHandSide -> String
(Int -> AddOrSubtractRightHandSide -> ShowS)
-> (AddOrSubtractRightHandSide -> String)
-> ([AddOrSubtractRightHandSide] -> ShowS)
-> Show AddOrSubtractRightHandSide
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AddOrSubtractRightHandSide -> ShowS
showsPrec :: Int -> AddOrSubtractRightHandSide -> ShowS
$cshow :: AddOrSubtractRightHandSide -> String
show :: AddOrSubtractRightHandSide -> String
$cshowList :: [AddOrSubtractRightHandSide] -> ShowS
showList :: [AddOrSubtractRightHandSide] -> ShowS
Show)

_AddOrSubtractRightHandSide :: Name
_AddOrSubtractRightHandSide = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.AddOrSubtractRightHandSide")

_AddOrSubtractRightHandSide_operator :: Name
_AddOrSubtractRightHandSide_operator = (String -> Name
Core.Name String
"operator")

_AddOrSubtractRightHandSide_expression :: Name
_AddOrSubtractRightHandSide_expression = (String -> Name
Core.Name String
"expression")

data AddOrSubtractOperator = 
  AddOrSubtractOperatorAdd  |
  AddOrSubtractOperatorSubtract 
  deriving (AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
(AddOrSubtractOperator -> AddOrSubtractOperator -> Bool)
-> (AddOrSubtractOperator -> AddOrSubtractOperator -> Bool)
-> Eq AddOrSubtractOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
== :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
$c/= :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
/= :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
Eq, Eq AddOrSubtractOperator
Eq AddOrSubtractOperator =>
(AddOrSubtractOperator -> AddOrSubtractOperator -> Ordering)
-> (AddOrSubtractOperator -> AddOrSubtractOperator -> Bool)
-> (AddOrSubtractOperator -> AddOrSubtractOperator -> Bool)
-> (AddOrSubtractOperator -> AddOrSubtractOperator -> Bool)
-> (AddOrSubtractOperator -> AddOrSubtractOperator -> Bool)
-> (AddOrSubtractOperator
    -> AddOrSubtractOperator -> AddOrSubtractOperator)
-> (AddOrSubtractOperator
    -> AddOrSubtractOperator -> AddOrSubtractOperator)
-> Ord AddOrSubtractOperator
AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
AddOrSubtractOperator -> AddOrSubtractOperator -> Ordering
AddOrSubtractOperator
-> AddOrSubtractOperator -> AddOrSubtractOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AddOrSubtractOperator -> AddOrSubtractOperator -> Ordering
compare :: AddOrSubtractOperator -> AddOrSubtractOperator -> Ordering
$c< :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
< :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
$c<= :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
<= :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
$c> :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
> :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
$c>= :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
>= :: AddOrSubtractOperator -> AddOrSubtractOperator -> Bool
$cmax :: AddOrSubtractOperator
-> AddOrSubtractOperator -> AddOrSubtractOperator
max :: AddOrSubtractOperator
-> AddOrSubtractOperator -> AddOrSubtractOperator
$cmin :: AddOrSubtractOperator
-> AddOrSubtractOperator -> AddOrSubtractOperator
min :: AddOrSubtractOperator
-> AddOrSubtractOperator -> AddOrSubtractOperator
Ord, ReadPrec [AddOrSubtractOperator]
ReadPrec AddOrSubtractOperator
Int -> ReadS AddOrSubtractOperator
ReadS [AddOrSubtractOperator]
(Int -> ReadS AddOrSubtractOperator)
-> ReadS [AddOrSubtractOperator]
-> ReadPrec AddOrSubtractOperator
-> ReadPrec [AddOrSubtractOperator]
-> Read AddOrSubtractOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AddOrSubtractOperator
readsPrec :: Int -> ReadS AddOrSubtractOperator
$creadList :: ReadS [AddOrSubtractOperator]
readList :: ReadS [AddOrSubtractOperator]
$creadPrec :: ReadPrec AddOrSubtractOperator
readPrec :: ReadPrec AddOrSubtractOperator
$creadListPrec :: ReadPrec [AddOrSubtractOperator]
readListPrec :: ReadPrec [AddOrSubtractOperator]
Read, Int -> AddOrSubtractOperator -> ShowS
[AddOrSubtractOperator] -> ShowS
AddOrSubtractOperator -> String
(Int -> AddOrSubtractOperator -> ShowS)
-> (AddOrSubtractOperator -> String)
-> ([AddOrSubtractOperator] -> ShowS)
-> Show AddOrSubtractOperator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AddOrSubtractOperator -> ShowS
showsPrec :: Int -> AddOrSubtractOperator -> ShowS
$cshow :: AddOrSubtractOperator -> String
show :: AddOrSubtractOperator -> String
$cshowList :: [AddOrSubtractOperator] -> ShowS
showList :: [AddOrSubtractOperator] -> ShowS
Show)

_AddOrSubtractOperator :: Name
_AddOrSubtractOperator = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.AddOrSubtractOperator")

_AddOrSubtractOperator_add :: Name
_AddOrSubtractOperator_add = (String -> Name
Core.Name String
"add")

_AddOrSubtractOperator_subtract :: Name
_AddOrSubtractOperator_subtract = (String -> Name
Core.Name String
"subtract")

data MultiplyDivideModuloExpression = 
  MultiplyDivideModuloExpression {
    MultiplyDivideModuloExpression -> PowerOfExpression
multiplyDivideModuloExpressionLeft :: PowerOfExpression,
    MultiplyDivideModuloExpression
-> [MultiplyDivideModuloRightHandSide]
multiplyDivideModuloExpressionRight :: [MultiplyDivideModuloRightHandSide]}
  deriving (MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
(MultiplyDivideModuloExpression
 -> MultiplyDivideModuloExpression -> Bool)
-> (MultiplyDivideModuloExpression
    -> MultiplyDivideModuloExpression -> Bool)
-> Eq MultiplyDivideModuloExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
== :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
$c/= :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
/= :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
Eq, Eq MultiplyDivideModuloExpression
Eq MultiplyDivideModuloExpression =>
(MultiplyDivideModuloExpression
 -> MultiplyDivideModuloExpression -> Ordering)
-> (MultiplyDivideModuloExpression
    -> MultiplyDivideModuloExpression -> Bool)
-> (MultiplyDivideModuloExpression
    -> MultiplyDivideModuloExpression -> Bool)
-> (MultiplyDivideModuloExpression
    -> MultiplyDivideModuloExpression -> Bool)
-> (MultiplyDivideModuloExpression
    -> MultiplyDivideModuloExpression -> Bool)
-> (MultiplyDivideModuloExpression
    -> MultiplyDivideModuloExpression
    -> MultiplyDivideModuloExpression)
-> (MultiplyDivideModuloExpression
    -> MultiplyDivideModuloExpression
    -> MultiplyDivideModuloExpression)
-> Ord MultiplyDivideModuloExpression
MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Ordering
MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> MultiplyDivideModuloExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Ordering
compare :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Ordering
$c< :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
< :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
$c<= :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
<= :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
$c> :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
> :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
$c>= :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
>= :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> Bool
$cmax :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> MultiplyDivideModuloExpression
max :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> MultiplyDivideModuloExpression
$cmin :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> MultiplyDivideModuloExpression
min :: MultiplyDivideModuloExpression
-> MultiplyDivideModuloExpression -> MultiplyDivideModuloExpression
Ord, ReadPrec [MultiplyDivideModuloExpression]
ReadPrec MultiplyDivideModuloExpression
Int -> ReadS MultiplyDivideModuloExpression
ReadS [MultiplyDivideModuloExpression]
(Int -> ReadS MultiplyDivideModuloExpression)
-> ReadS [MultiplyDivideModuloExpression]
-> ReadPrec MultiplyDivideModuloExpression
-> ReadPrec [MultiplyDivideModuloExpression]
-> Read MultiplyDivideModuloExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MultiplyDivideModuloExpression
readsPrec :: Int -> ReadS MultiplyDivideModuloExpression
$creadList :: ReadS [MultiplyDivideModuloExpression]
readList :: ReadS [MultiplyDivideModuloExpression]
$creadPrec :: ReadPrec MultiplyDivideModuloExpression
readPrec :: ReadPrec MultiplyDivideModuloExpression
$creadListPrec :: ReadPrec [MultiplyDivideModuloExpression]
readListPrec :: ReadPrec [MultiplyDivideModuloExpression]
Read, Int -> MultiplyDivideModuloExpression -> ShowS
[MultiplyDivideModuloExpression] -> ShowS
MultiplyDivideModuloExpression -> String
(Int -> MultiplyDivideModuloExpression -> ShowS)
-> (MultiplyDivideModuloExpression -> String)
-> ([MultiplyDivideModuloExpression] -> ShowS)
-> Show MultiplyDivideModuloExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MultiplyDivideModuloExpression -> ShowS
showsPrec :: Int -> MultiplyDivideModuloExpression -> ShowS
$cshow :: MultiplyDivideModuloExpression -> String
show :: MultiplyDivideModuloExpression -> String
$cshowList :: [MultiplyDivideModuloExpression] -> ShowS
showList :: [MultiplyDivideModuloExpression] -> ShowS
Show)

_MultiplyDivideModuloExpression :: Name
_MultiplyDivideModuloExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.MultiplyDivideModuloExpression")

_MultiplyDivideModuloExpression_left :: Name
_MultiplyDivideModuloExpression_left = (String -> Name
Core.Name String
"left")

_MultiplyDivideModuloExpression_right :: Name
_MultiplyDivideModuloExpression_right = (String -> Name
Core.Name String
"right")

data MultiplyDivideModuloRightHandSide = 
  MultiplyDivideModuloRightHandSide {
    MultiplyDivideModuloRightHandSide -> MultiplyDivideModuloOperator
multiplyDivideModuloRightHandSideOperator :: MultiplyDivideModuloOperator,
    MultiplyDivideModuloRightHandSide -> PowerOfExpression
multiplyDivideModuloRightHandSideExpression :: PowerOfExpression}
  deriving (MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
(MultiplyDivideModuloRightHandSide
 -> MultiplyDivideModuloRightHandSide -> Bool)
-> (MultiplyDivideModuloRightHandSide
    -> MultiplyDivideModuloRightHandSide -> Bool)
-> Eq MultiplyDivideModuloRightHandSide
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
== :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
$c/= :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
/= :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
Eq, Eq MultiplyDivideModuloRightHandSide
Eq MultiplyDivideModuloRightHandSide =>
(MultiplyDivideModuloRightHandSide
 -> MultiplyDivideModuloRightHandSide -> Ordering)
-> (MultiplyDivideModuloRightHandSide
    -> MultiplyDivideModuloRightHandSide -> Bool)
-> (MultiplyDivideModuloRightHandSide
    -> MultiplyDivideModuloRightHandSide -> Bool)
-> (MultiplyDivideModuloRightHandSide
    -> MultiplyDivideModuloRightHandSide -> Bool)
-> (MultiplyDivideModuloRightHandSide
    -> MultiplyDivideModuloRightHandSide -> Bool)
-> (MultiplyDivideModuloRightHandSide
    -> MultiplyDivideModuloRightHandSide
    -> MultiplyDivideModuloRightHandSide)
-> (MultiplyDivideModuloRightHandSide
    -> MultiplyDivideModuloRightHandSide
    -> MultiplyDivideModuloRightHandSide)
-> Ord MultiplyDivideModuloRightHandSide
MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Ordering
MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Ordering
compare :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Ordering
$c< :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
< :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
$c<= :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
<= :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
$c> :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
> :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
$c>= :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
>= :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide -> Bool
$cmax :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide
max :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide
$cmin :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide
min :: MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide
-> MultiplyDivideModuloRightHandSide
Ord, ReadPrec [MultiplyDivideModuloRightHandSide]
ReadPrec MultiplyDivideModuloRightHandSide
Int -> ReadS MultiplyDivideModuloRightHandSide
ReadS [MultiplyDivideModuloRightHandSide]
(Int -> ReadS MultiplyDivideModuloRightHandSide)
-> ReadS [MultiplyDivideModuloRightHandSide]
-> ReadPrec MultiplyDivideModuloRightHandSide
-> ReadPrec [MultiplyDivideModuloRightHandSide]
-> Read MultiplyDivideModuloRightHandSide
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MultiplyDivideModuloRightHandSide
readsPrec :: Int -> ReadS MultiplyDivideModuloRightHandSide
$creadList :: ReadS [MultiplyDivideModuloRightHandSide]
readList :: ReadS [MultiplyDivideModuloRightHandSide]
$creadPrec :: ReadPrec MultiplyDivideModuloRightHandSide
readPrec :: ReadPrec MultiplyDivideModuloRightHandSide
$creadListPrec :: ReadPrec [MultiplyDivideModuloRightHandSide]
readListPrec :: ReadPrec [MultiplyDivideModuloRightHandSide]
Read, Int -> MultiplyDivideModuloRightHandSide -> ShowS
[MultiplyDivideModuloRightHandSide] -> ShowS
MultiplyDivideModuloRightHandSide -> String
(Int -> MultiplyDivideModuloRightHandSide -> ShowS)
-> (MultiplyDivideModuloRightHandSide -> String)
-> ([MultiplyDivideModuloRightHandSide] -> ShowS)
-> Show MultiplyDivideModuloRightHandSide
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MultiplyDivideModuloRightHandSide -> ShowS
showsPrec :: Int -> MultiplyDivideModuloRightHandSide -> ShowS
$cshow :: MultiplyDivideModuloRightHandSide -> String
show :: MultiplyDivideModuloRightHandSide -> String
$cshowList :: [MultiplyDivideModuloRightHandSide] -> ShowS
showList :: [MultiplyDivideModuloRightHandSide] -> ShowS
Show)

_MultiplyDivideModuloRightHandSide :: Name
_MultiplyDivideModuloRightHandSide = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.MultiplyDivideModuloRightHandSide")

_MultiplyDivideModuloRightHandSide_operator :: Name
_MultiplyDivideModuloRightHandSide_operator = (String -> Name
Core.Name String
"operator")

_MultiplyDivideModuloRightHandSide_expression :: Name
_MultiplyDivideModuloRightHandSide_expression = (String -> Name
Core.Name String
"expression")

data MultiplyDivideModuloOperator = 
  MultiplyDivideModuloOperatorMultiply  |
  MultiplyDivideModuloOperatorDivide  |
  MultiplyDivideModuloOperatorModulo 
  deriving (MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
(MultiplyDivideModuloOperator
 -> MultiplyDivideModuloOperator -> Bool)
-> (MultiplyDivideModuloOperator
    -> MultiplyDivideModuloOperator -> Bool)
-> Eq MultiplyDivideModuloOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
== :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
$c/= :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
/= :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
Eq, Eq MultiplyDivideModuloOperator
Eq MultiplyDivideModuloOperator =>
(MultiplyDivideModuloOperator
 -> MultiplyDivideModuloOperator -> Ordering)
-> (MultiplyDivideModuloOperator
    -> MultiplyDivideModuloOperator -> Bool)
-> (MultiplyDivideModuloOperator
    -> MultiplyDivideModuloOperator -> Bool)
-> (MultiplyDivideModuloOperator
    -> MultiplyDivideModuloOperator -> Bool)
-> (MultiplyDivideModuloOperator
    -> MultiplyDivideModuloOperator -> Bool)
-> (MultiplyDivideModuloOperator
    -> MultiplyDivideModuloOperator -> MultiplyDivideModuloOperator)
-> (MultiplyDivideModuloOperator
    -> MultiplyDivideModuloOperator -> MultiplyDivideModuloOperator)
-> Ord MultiplyDivideModuloOperator
MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Ordering
MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> MultiplyDivideModuloOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Ordering
compare :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Ordering
$c< :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
< :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
$c<= :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
<= :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
$c> :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
> :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
$c>= :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
>= :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> Bool
$cmax :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> MultiplyDivideModuloOperator
max :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> MultiplyDivideModuloOperator
$cmin :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> MultiplyDivideModuloOperator
min :: MultiplyDivideModuloOperator
-> MultiplyDivideModuloOperator -> MultiplyDivideModuloOperator
Ord, ReadPrec [MultiplyDivideModuloOperator]
ReadPrec MultiplyDivideModuloOperator
Int -> ReadS MultiplyDivideModuloOperator
ReadS [MultiplyDivideModuloOperator]
(Int -> ReadS MultiplyDivideModuloOperator)
-> ReadS [MultiplyDivideModuloOperator]
-> ReadPrec MultiplyDivideModuloOperator
-> ReadPrec [MultiplyDivideModuloOperator]
-> Read MultiplyDivideModuloOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MultiplyDivideModuloOperator
readsPrec :: Int -> ReadS MultiplyDivideModuloOperator
$creadList :: ReadS [MultiplyDivideModuloOperator]
readList :: ReadS [MultiplyDivideModuloOperator]
$creadPrec :: ReadPrec MultiplyDivideModuloOperator
readPrec :: ReadPrec MultiplyDivideModuloOperator
$creadListPrec :: ReadPrec [MultiplyDivideModuloOperator]
readListPrec :: ReadPrec [MultiplyDivideModuloOperator]
Read, Int -> MultiplyDivideModuloOperator -> ShowS
[MultiplyDivideModuloOperator] -> ShowS
MultiplyDivideModuloOperator -> String
(Int -> MultiplyDivideModuloOperator -> ShowS)
-> (MultiplyDivideModuloOperator -> String)
-> ([MultiplyDivideModuloOperator] -> ShowS)
-> Show MultiplyDivideModuloOperator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MultiplyDivideModuloOperator -> ShowS
showsPrec :: Int -> MultiplyDivideModuloOperator -> ShowS
$cshow :: MultiplyDivideModuloOperator -> String
show :: MultiplyDivideModuloOperator -> String
$cshowList :: [MultiplyDivideModuloOperator] -> ShowS
showList :: [MultiplyDivideModuloOperator] -> ShowS
Show)

_MultiplyDivideModuloOperator :: Name
_MultiplyDivideModuloOperator = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.MultiplyDivideModuloOperator")

_MultiplyDivideModuloOperator_multiply :: Name
_MultiplyDivideModuloOperator_multiply = (String -> Name
Core.Name String
"multiply")

_MultiplyDivideModuloOperator_divide :: Name
_MultiplyDivideModuloOperator_divide = (String -> Name
Core.Name String
"divide")

_MultiplyDivideModuloOperator_modulo :: Name
_MultiplyDivideModuloOperator_modulo = (String -> Name
Core.Name String
"modulo")

newtype PowerOfExpression = 
  PowerOfExpression {
    PowerOfExpression -> [UnaryAddOrSubtractExpression]
unPowerOfExpression :: [UnaryAddOrSubtractExpression]}
  deriving (PowerOfExpression -> PowerOfExpression -> Bool
(PowerOfExpression -> PowerOfExpression -> Bool)
-> (PowerOfExpression -> PowerOfExpression -> Bool)
-> Eq PowerOfExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PowerOfExpression -> PowerOfExpression -> Bool
== :: PowerOfExpression -> PowerOfExpression -> Bool
$c/= :: PowerOfExpression -> PowerOfExpression -> Bool
/= :: PowerOfExpression -> PowerOfExpression -> Bool
Eq, Eq PowerOfExpression
Eq PowerOfExpression =>
(PowerOfExpression -> PowerOfExpression -> Ordering)
-> (PowerOfExpression -> PowerOfExpression -> Bool)
-> (PowerOfExpression -> PowerOfExpression -> Bool)
-> (PowerOfExpression -> PowerOfExpression -> Bool)
-> (PowerOfExpression -> PowerOfExpression -> Bool)
-> (PowerOfExpression -> PowerOfExpression -> PowerOfExpression)
-> (PowerOfExpression -> PowerOfExpression -> PowerOfExpression)
-> Ord PowerOfExpression
PowerOfExpression -> PowerOfExpression -> Bool
PowerOfExpression -> PowerOfExpression -> Ordering
PowerOfExpression -> PowerOfExpression -> PowerOfExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PowerOfExpression -> PowerOfExpression -> Ordering
compare :: PowerOfExpression -> PowerOfExpression -> Ordering
$c< :: PowerOfExpression -> PowerOfExpression -> Bool
< :: PowerOfExpression -> PowerOfExpression -> Bool
$c<= :: PowerOfExpression -> PowerOfExpression -> Bool
<= :: PowerOfExpression -> PowerOfExpression -> Bool
$c> :: PowerOfExpression -> PowerOfExpression -> Bool
> :: PowerOfExpression -> PowerOfExpression -> Bool
$c>= :: PowerOfExpression -> PowerOfExpression -> Bool
>= :: PowerOfExpression -> PowerOfExpression -> Bool
$cmax :: PowerOfExpression -> PowerOfExpression -> PowerOfExpression
max :: PowerOfExpression -> PowerOfExpression -> PowerOfExpression
$cmin :: PowerOfExpression -> PowerOfExpression -> PowerOfExpression
min :: PowerOfExpression -> PowerOfExpression -> PowerOfExpression
Ord, ReadPrec [PowerOfExpression]
ReadPrec PowerOfExpression
Int -> ReadS PowerOfExpression
ReadS [PowerOfExpression]
(Int -> ReadS PowerOfExpression)
-> ReadS [PowerOfExpression]
-> ReadPrec PowerOfExpression
-> ReadPrec [PowerOfExpression]
-> Read PowerOfExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PowerOfExpression
readsPrec :: Int -> ReadS PowerOfExpression
$creadList :: ReadS [PowerOfExpression]
readList :: ReadS [PowerOfExpression]
$creadPrec :: ReadPrec PowerOfExpression
readPrec :: ReadPrec PowerOfExpression
$creadListPrec :: ReadPrec [PowerOfExpression]
readListPrec :: ReadPrec [PowerOfExpression]
Read, Int -> PowerOfExpression -> ShowS
[PowerOfExpression] -> ShowS
PowerOfExpression -> String
(Int -> PowerOfExpression -> ShowS)
-> (PowerOfExpression -> String)
-> ([PowerOfExpression] -> ShowS)
-> Show PowerOfExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PowerOfExpression -> ShowS
showsPrec :: Int -> PowerOfExpression -> ShowS
$cshow :: PowerOfExpression -> String
show :: PowerOfExpression -> String
$cshowList :: [PowerOfExpression] -> ShowS
showList :: [PowerOfExpression] -> ShowS
Show)

_PowerOfExpression :: Name
_PowerOfExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PowerOfExpression")

data UnaryAddOrSubtractExpression = 
  UnaryAddOrSubtractExpression {
    UnaryAddOrSubtractExpression -> Maybe AddOrSubtractOperator
unaryAddOrSubtractExpressionOperator :: (Maybe AddOrSubtractOperator),
    UnaryAddOrSubtractExpression -> NonArithmeticOperatorExpression
unaryAddOrSubtractExpressionExpression :: NonArithmeticOperatorExpression}
  deriving (UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
(UnaryAddOrSubtractExpression
 -> UnaryAddOrSubtractExpression -> Bool)
-> (UnaryAddOrSubtractExpression
    -> UnaryAddOrSubtractExpression -> Bool)
-> Eq UnaryAddOrSubtractExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
== :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
$c/= :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
/= :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
Eq, Eq UnaryAddOrSubtractExpression
Eq UnaryAddOrSubtractExpression =>
(UnaryAddOrSubtractExpression
 -> UnaryAddOrSubtractExpression -> Ordering)
-> (UnaryAddOrSubtractExpression
    -> UnaryAddOrSubtractExpression -> Bool)
-> (UnaryAddOrSubtractExpression
    -> UnaryAddOrSubtractExpression -> Bool)
-> (UnaryAddOrSubtractExpression
    -> UnaryAddOrSubtractExpression -> Bool)
-> (UnaryAddOrSubtractExpression
    -> UnaryAddOrSubtractExpression -> Bool)
-> (UnaryAddOrSubtractExpression
    -> UnaryAddOrSubtractExpression -> UnaryAddOrSubtractExpression)
-> (UnaryAddOrSubtractExpression
    -> UnaryAddOrSubtractExpression -> UnaryAddOrSubtractExpression)
-> Ord UnaryAddOrSubtractExpression
UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Ordering
UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> UnaryAddOrSubtractExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Ordering
compare :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Ordering
$c< :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
< :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
$c<= :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
<= :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
$c> :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
> :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
$c>= :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
>= :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> Bool
$cmax :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> UnaryAddOrSubtractExpression
max :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> UnaryAddOrSubtractExpression
$cmin :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> UnaryAddOrSubtractExpression
min :: UnaryAddOrSubtractExpression
-> UnaryAddOrSubtractExpression -> UnaryAddOrSubtractExpression
Ord, ReadPrec [UnaryAddOrSubtractExpression]
ReadPrec UnaryAddOrSubtractExpression
Int -> ReadS UnaryAddOrSubtractExpression
ReadS [UnaryAddOrSubtractExpression]
(Int -> ReadS UnaryAddOrSubtractExpression)
-> ReadS [UnaryAddOrSubtractExpression]
-> ReadPrec UnaryAddOrSubtractExpression
-> ReadPrec [UnaryAddOrSubtractExpression]
-> Read UnaryAddOrSubtractExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UnaryAddOrSubtractExpression
readsPrec :: Int -> ReadS UnaryAddOrSubtractExpression
$creadList :: ReadS [UnaryAddOrSubtractExpression]
readList :: ReadS [UnaryAddOrSubtractExpression]
$creadPrec :: ReadPrec UnaryAddOrSubtractExpression
readPrec :: ReadPrec UnaryAddOrSubtractExpression
$creadListPrec :: ReadPrec [UnaryAddOrSubtractExpression]
readListPrec :: ReadPrec [UnaryAddOrSubtractExpression]
Read, Int -> UnaryAddOrSubtractExpression -> ShowS
[UnaryAddOrSubtractExpression] -> ShowS
UnaryAddOrSubtractExpression -> String
(Int -> UnaryAddOrSubtractExpression -> ShowS)
-> (UnaryAddOrSubtractExpression -> String)
-> ([UnaryAddOrSubtractExpression] -> ShowS)
-> Show UnaryAddOrSubtractExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UnaryAddOrSubtractExpression -> ShowS
showsPrec :: Int -> UnaryAddOrSubtractExpression -> ShowS
$cshow :: UnaryAddOrSubtractExpression -> String
show :: UnaryAddOrSubtractExpression -> String
$cshowList :: [UnaryAddOrSubtractExpression] -> ShowS
showList :: [UnaryAddOrSubtractExpression] -> ShowS
Show)

_UnaryAddOrSubtractExpression :: Name
_UnaryAddOrSubtractExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.UnaryAddOrSubtractExpression")

_UnaryAddOrSubtractExpression_operator :: Name
_UnaryAddOrSubtractExpression_operator = (String -> Name
Core.Name String
"operator")

_UnaryAddOrSubtractExpression_expression :: Name
_UnaryAddOrSubtractExpression_expression = (String -> Name
Core.Name String
"expression")

data ListOperatorExpressionOrPropertyLookup = 
  ListOperatorExpressionOrPropertyLookupList ListOperatorExpression |
  ListOperatorExpressionOrPropertyLookupProperty PropertyLookup
  deriving (ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
(ListOperatorExpressionOrPropertyLookup
 -> ListOperatorExpressionOrPropertyLookup -> Bool)
-> (ListOperatorExpressionOrPropertyLookup
    -> ListOperatorExpressionOrPropertyLookup -> Bool)
-> Eq ListOperatorExpressionOrPropertyLookup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
== :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
$c/= :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
/= :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
Eq, Eq ListOperatorExpressionOrPropertyLookup
Eq ListOperatorExpressionOrPropertyLookup =>
(ListOperatorExpressionOrPropertyLookup
 -> ListOperatorExpressionOrPropertyLookup -> Ordering)
-> (ListOperatorExpressionOrPropertyLookup
    -> ListOperatorExpressionOrPropertyLookup -> Bool)
-> (ListOperatorExpressionOrPropertyLookup
    -> ListOperatorExpressionOrPropertyLookup -> Bool)
-> (ListOperatorExpressionOrPropertyLookup
    -> ListOperatorExpressionOrPropertyLookup -> Bool)
-> (ListOperatorExpressionOrPropertyLookup
    -> ListOperatorExpressionOrPropertyLookup -> Bool)
-> (ListOperatorExpressionOrPropertyLookup
    -> ListOperatorExpressionOrPropertyLookup
    -> ListOperatorExpressionOrPropertyLookup)
-> (ListOperatorExpressionOrPropertyLookup
    -> ListOperatorExpressionOrPropertyLookup
    -> ListOperatorExpressionOrPropertyLookup)
-> Ord ListOperatorExpressionOrPropertyLookup
ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Ordering
ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Ordering
compare :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Ordering
$c< :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
< :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
$c<= :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
<= :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
$c> :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
> :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
$c>= :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
>= :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup -> Bool
$cmax :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup
max :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup
$cmin :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup
min :: ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup
-> ListOperatorExpressionOrPropertyLookup
Ord, ReadPrec [ListOperatorExpressionOrPropertyLookup]
ReadPrec ListOperatorExpressionOrPropertyLookup
Int -> ReadS ListOperatorExpressionOrPropertyLookup
ReadS [ListOperatorExpressionOrPropertyLookup]
(Int -> ReadS ListOperatorExpressionOrPropertyLookup)
-> ReadS [ListOperatorExpressionOrPropertyLookup]
-> ReadPrec ListOperatorExpressionOrPropertyLookup
-> ReadPrec [ListOperatorExpressionOrPropertyLookup]
-> Read ListOperatorExpressionOrPropertyLookup
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ListOperatorExpressionOrPropertyLookup
readsPrec :: Int -> ReadS ListOperatorExpressionOrPropertyLookup
$creadList :: ReadS [ListOperatorExpressionOrPropertyLookup]
readList :: ReadS [ListOperatorExpressionOrPropertyLookup]
$creadPrec :: ReadPrec ListOperatorExpressionOrPropertyLookup
readPrec :: ReadPrec ListOperatorExpressionOrPropertyLookup
$creadListPrec :: ReadPrec [ListOperatorExpressionOrPropertyLookup]
readListPrec :: ReadPrec [ListOperatorExpressionOrPropertyLookup]
Read, Int -> ListOperatorExpressionOrPropertyLookup -> ShowS
[ListOperatorExpressionOrPropertyLookup] -> ShowS
ListOperatorExpressionOrPropertyLookup -> String
(Int -> ListOperatorExpressionOrPropertyLookup -> ShowS)
-> (ListOperatorExpressionOrPropertyLookup -> String)
-> ([ListOperatorExpressionOrPropertyLookup] -> ShowS)
-> Show ListOperatorExpressionOrPropertyLookup
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListOperatorExpressionOrPropertyLookup -> ShowS
showsPrec :: Int -> ListOperatorExpressionOrPropertyLookup -> ShowS
$cshow :: ListOperatorExpressionOrPropertyLookup -> String
show :: ListOperatorExpressionOrPropertyLookup -> String
$cshowList :: [ListOperatorExpressionOrPropertyLookup] -> ShowS
showList :: [ListOperatorExpressionOrPropertyLookup] -> ShowS
Show)

_ListOperatorExpressionOrPropertyLookup :: Name
_ListOperatorExpressionOrPropertyLookup = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ListOperatorExpressionOrPropertyLookup")

_ListOperatorExpressionOrPropertyLookup_list :: Name
_ListOperatorExpressionOrPropertyLookup_list = (String -> Name
Core.Name String
"list")

_ListOperatorExpressionOrPropertyLookup_property :: Name
_ListOperatorExpressionOrPropertyLookup_property = (String -> Name
Core.Name String
"property")

data NonArithmeticOperatorExpression = 
  NonArithmeticOperatorExpression {
    NonArithmeticOperatorExpression -> Atom
nonArithmeticOperatorExpressionAtom :: Atom,
    NonArithmeticOperatorExpression
-> [ListOperatorExpressionOrPropertyLookup]
nonArithmeticOperatorExpressionListsAndLookups :: [ListOperatorExpressionOrPropertyLookup],
    NonArithmeticOperatorExpression -> Maybe NodeLabels
nonArithmeticOperatorExpressionLabels :: (Maybe NodeLabels)}
  deriving (NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
(NonArithmeticOperatorExpression
 -> NonArithmeticOperatorExpression -> Bool)
-> (NonArithmeticOperatorExpression
    -> NonArithmeticOperatorExpression -> Bool)
-> Eq NonArithmeticOperatorExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
== :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
$c/= :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
/= :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
Eq, Eq NonArithmeticOperatorExpression
Eq NonArithmeticOperatorExpression =>
(NonArithmeticOperatorExpression
 -> NonArithmeticOperatorExpression -> Ordering)
-> (NonArithmeticOperatorExpression
    -> NonArithmeticOperatorExpression -> Bool)
-> (NonArithmeticOperatorExpression
    -> NonArithmeticOperatorExpression -> Bool)
-> (NonArithmeticOperatorExpression
    -> NonArithmeticOperatorExpression -> Bool)
-> (NonArithmeticOperatorExpression
    -> NonArithmeticOperatorExpression -> Bool)
-> (NonArithmeticOperatorExpression
    -> NonArithmeticOperatorExpression
    -> NonArithmeticOperatorExpression)
-> (NonArithmeticOperatorExpression
    -> NonArithmeticOperatorExpression
    -> NonArithmeticOperatorExpression)
-> Ord NonArithmeticOperatorExpression
NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Ordering
NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Ordering
compare :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Ordering
$c< :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
< :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
$c<= :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
<= :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
$c> :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
> :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
$c>= :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
>= :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression -> Bool
$cmax :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression
max :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression
$cmin :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression
min :: NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression
-> NonArithmeticOperatorExpression
Ord, ReadPrec [NonArithmeticOperatorExpression]
ReadPrec NonArithmeticOperatorExpression
Int -> ReadS NonArithmeticOperatorExpression
ReadS [NonArithmeticOperatorExpression]
(Int -> ReadS NonArithmeticOperatorExpression)
-> ReadS [NonArithmeticOperatorExpression]
-> ReadPrec NonArithmeticOperatorExpression
-> ReadPrec [NonArithmeticOperatorExpression]
-> Read NonArithmeticOperatorExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NonArithmeticOperatorExpression
readsPrec :: Int -> ReadS NonArithmeticOperatorExpression
$creadList :: ReadS [NonArithmeticOperatorExpression]
readList :: ReadS [NonArithmeticOperatorExpression]
$creadPrec :: ReadPrec NonArithmeticOperatorExpression
readPrec :: ReadPrec NonArithmeticOperatorExpression
$creadListPrec :: ReadPrec [NonArithmeticOperatorExpression]
readListPrec :: ReadPrec [NonArithmeticOperatorExpression]
Read, Int -> NonArithmeticOperatorExpression -> ShowS
[NonArithmeticOperatorExpression] -> ShowS
NonArithmeticOperatorExpression -> String
(Int -> NonArithmeticOperatorExpression -> ShowS)
-> (NonArithmeticOperatorExpression -> String)
-> ([NonArithmeticOperatorExpression] -> ShowS)
-> Show NonArithmeticOperatorExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NonArithmeticOperatorExpression -> ShowS
showsPrec :: Int -> NonArithmeticOperatorExpression -> ShowS
$cshow :: NonArithmeticOperatorExpression -> String
show :: NonArithmeticOperatorExpression -> String
$cshowList :: [NonArithmeticOperatorExpression] -> ShowS
showList :: [NonArithmeticOperatorExpression] -> ShowS
Show)

_NonArithmeticOperatorExpression :: Name
_NonArithmeticOperatorExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.NonArithmeticOperatorExpression")

_NonArithmeticOperatorExpression_atom :: Name
_NonArithmeticOperatorExpression_atom = (String -> Name
Core.Name String
"atom")

_NonArithmeticOperatorExpression_listsAndLookups :: Name
_NonArithmeticOperatorExpression_listsAndLookups = (String -> Name
Core.Name String
"listsAndLookups")

_NonArithmeticOperatorExpression_labels :: Name
_NonArithmeticOperatorExpression_labels = (String -> Name
Core.Name String
"labels")

data RangeExpression = 
  RangeExpression {
    RangeExpression -> Maybe Expression
rangeExpressionStart :: (Maybe Expression),
    RangeExpression -> Maybe Expression
rangeExpressionEnd :: (Maybe Expression)}
  deriving (RangeExpression -> RangeExpression -> Bool
(RangeExpression -> RangeExpression -> Bool)
-> (RangeExpression -> RangeExpression -> Bool)
-> Eq RangeExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RangeExpression -> RangeExpression -> Bool
== :: RangeExpression -> RangeExpression -> Bool
$c/= :: RangeExpression -> RangeExpression -> Bool
/= :: RangeExpression -> RangeExpression -> Bool
Eq, Eq RangeExpression
Eq RangeExpression =>
(RangeExpression -> RangeExpression -> Ordering)
-> (RangeExpression -> RangeExpression -> Bool)
-> (RangeExpression -> RangeExpression -> Bool)
-> (RangeExpression -> RangeExpression -> Bool)
-> (RangeExpression -> RangeExpression -> Bool)
-> (RangeExpression -> RangeExpression -> RangeExpression)
-> (RangeExpression -> RangeExpression -> RangeExpression)
-> Ord RangeExpression
RangeExpression -> RangeExpression -> Bool
RangeExpression -> RangeExpression -> Ordering
RangeExpression -> RangeExpression -> RangeExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RangeExpression -> RangeExpression -> Ordering
compare :: RangeExpression -> RangeExpression -> Ordering
$c< :: RangeExpression -> RangeExpression -> Bool
< :: RangeExpression -> RangeExpression -> Bool
$c<= :: RangeExpression -> RangeExpression -> Bool
<= :: RangeExpression -> RangeExpression -> Bool
$c> :: RangeExpression -> RangeExpression -> Bool
> :: RangeExpression -> RangeExpression -> Bool
$c>= :: RangeExpression -> RangeExpression -> Bool
>= :: RangeExpression -> RangeExpression -> Bool
$cmax :: RangeExpression -> RangeExpression -> RangeExpression
max :: RangeExpression -> RangeExpression -> RangeExpression
$cmin :: RangeExpression -> RangeExpression -> RangeExpression
min :: RangeExpression -> RangeExpression -> RangeExpression
Ord, ReadPrec [RangeExpression]
ReadPrec RangeExpression
Int -> ReadS RangeExpression
ReadS [RangeExpression]
(Int -> ReadS RangeExpression)
-> ReadS [RangeExpression]
-> ReadPrec RangeExpression
-> ReadPrec [RangeExpression]
-> Read RangeExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RangeExpression
readsPrec :: Int -> ReadS RangeExpression
$creadList :: ReadS [RangeExpression]
readList :: ReadS [RangeExpression]
$creadPrec :: ReadPrec RangeExpression
readPrec :: ReadPrec RangeExpression
$creadListPrec :: ReadPrec [RangeExpression]
readListPrec :: ReadPrec [RangeExpression]
Read, Int -> RangeExpression -> ShowS
[RangeExpression] -> ShowS
RangeExpression -> String
(Int -> RangeExpression -> ShowS)
-> (RangeExpression -> String)
-> ([RangeExpression] -> ShowS)
-> Show RangeExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RangeExpression -> ShowS
showsPrec :: Int -> RangeExpression -> ShowS
$cshow :: RangeExpression -> String
show :: RangeExpression -> String
$cshowList :: [RangeExpression] -> ShowS
showList :: [RangeExpression] -> ShowS
Show)

_RangeExpression :: Name
_RangeExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.RangeExpression")

_RangeExpression_start :: Name
_RangeExpression_start = (String -> Name
Core.Name String
"start")

_RangeExpression_end :: Name
_RangeExpression_end = (String -> Name
Core.Name String
"end")

data ListOperatorExpression = 
  ListOperatorExpressionSingle Expression |
  ListOperatorExpressionRange RangeExpression
  deriving (ListOperatorExpression -> ListOperatorExpression -> Bool
(ListOperatorExpression -> ListOperatorExpression -> Bool)
-> (ListOperatorExpression -> ListOperatorExpression -> Bool)
-> Eq ListOperatorExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListOperatorExpression -> ListOperatorExpression -> Bool
== :: ListOperatorExpression -> ListOperatorExpression -> Bool
$c/= :: ListOperatorExpression -> ListOperatorExpression -> Bool
/= :: ListOperatorExpression -> ListOperatorExpression -> Bool
Eq, Eq ListOperatorExpression
Eq ListOperatorExpression =>
(ListOperatorExpression -> ListOperatorExpression -> Ordering)
-> (ListOperatorExpression -> ListOperatorExpression -> Bool)
-> (ListOperatorExpression -> ListOperatorExpression -> Bool)
-> (ListOperatorExpression -> ListOperatorExpression -> Bool)
-> (ListOperatorExpression -> ListOperatorExpression -> Bool)
-> (ListOperatorExpression
    -> ListOperatorExpression -> ListOperatorExpression)
-> (ListOperatorExpression
    -> ListOperatorExpression -> ListOperatorExpression)
-> Ord ListOperatorExpression
ListOperatorExpression -> ListOperatorExpression -> Bool
ListOperatorExpression -> ListOperatorExpression -> Ordering
ListOperatorExpression
-> ListOperatorExpression -> ListOperatorExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ListOperatorExpression -> ListOperatorExpression -> Ordering
compare :: ListOperatorExpression -> ListOperatorExpression -> Ordering
$c< :: ListOperatorExpression -> ListOperatorExpression -> Bool
< :: ListOperatorExpression -> ListOperatorExpression -> Bool
$c<= :: ListOperatorExpression -> ListOperatorExpression -> Bool
<= :: ListOperatorExpression -> ListOperatorExpression -> Bool
$c> :: ListOperatorExpression -> ListOperatorExpression -> Bool
> :: ListOperatorExpression -> ListOperatorExpression -> Bool
$c>= :: ListOperatorExpression -> ListOperatorExpression -> Bool
>= :: ListOperatorExpression -> ListOperatorExpression -> Bool
$cmax :: ListOperatorExpression
-> ListOperatorExpression -> ListOperatorExpression
max :: ListOperatorExpression
-> ListOperatorExpression -> ListOperatorExpression
$cmin :: ListOperatorExpression
-> ListOperatorExpression -> ListOperatorExpression
min :: ListOperatorExpression
-> ListOperatorExpression -> ListOperatorExpression
Ord, ReadPrec [ListOperatorExpression]
ReadPrec ListOperatorExpression
Int -> ReadS ListOperatorExpression
ReadS [ListOperatorExpression]
(Int -> ReadS ListOperatorExpression)
-> ReadS [ListOperatorExpression]
-> ReadPrec ListOperatorExpression
-> ReadPrec [ListOperatorExpression]
-> Read ListOperatorExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ListOperatorExpression
readsPrec :: Int -> ReadS ListOperatorExpression
$creadList :: ReadS [ListOperatorExpression]
readList :: ReadS [ListOperatorExpression]
$creadPrec :: ReadPrec ListOperatorExpression
readPrec :: ReadPrec ListOperatorExpression
$creadListPrec :: ReadPrec [ListOperatorExpression]
readListPrec :: ReadPrec [ListOperatorExpression]
Read, Int -> ListOperatorExpression -> ShowS
[ListOperatorExpression] -> ShowS
ListOperatorExpression -> String
(Int -> ListOperatorExpression -> ShowS)
-> (ListOperatorExpression -> String)
-> ([ListOperatorExpression] -> ShowS)
-> Show ListOperatorExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListOperatorExpression -> ShowS
showsPrec :: Int -> ListOperatorExpression -> ShowS
$cshow :: ListOperatorExpression -> String
show :: ListOperatorExpression -> String
$cshowList :: [ListOperatorExpression] -> ShowS
showList :: [ListOperatorExpression] -> ShowS
Show)

_ListOperatorExpression :: Name
_ListOperatorExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ListOperatorExpression")

_ListOperatorExpression_single :: Name
_ListOperatorExpression_single = (String -> Name
Core.Name String
"single")

_ListOperatorExpression_range :: Name
_ListOperatorExpression_range = (String -> Name
Core.Name String
"range")

newtype PropertyLookup = 
  PropertyLookup {
    PropertyLookup -> PropertyKeyName
unPropertyLookup :: PropertyKeyName}
  deriving (PropertyLookup -> PropertyLookup -> Bool
(PropertyLookup -> PropertyLookup -> Bool)
-> (PropertyLookup -> PropertyLookup -> Bool) -> Eq PropertyLookup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PropertyLookup -> PropertyLookup -> Bool
== :: PropertyLookup -> PropertyLookup -> Bool
$c/= :: PropertyLookup -> PropertyLookup -> Bool
/= :: PropertyLookup -> PropertyLookup -> Bool
Eq, Eq PropertyLookup
Eq PropertyLookup =>
(PropertyLookup -> PropertyLookup -> Ordering)
-> (PropertyLookup -> PropertyLookup -> Bool)
-> (PropertyLookup -> PropertyLookup -> Bool)
-> (PropertyLookup -> PropertyLookup -> Bool)
-> (PropertyLookup -> PropertyLookup -> Bool)
-> (PropertyLookup -> PropertyLookup -> PropertyLookup)
-> (PropertyLookup -> PropertyLookup -> PropertyLookup)
-> Ord PropertyLookup
PropertyLookup -> PropertyLookup -> Bool
PropertyLookup -> PropertyLookup -> Ordering
PropertyLookup -> PropertyLookup -> PropertyLookup
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PropertyLookup -> PropertyLookup -> Ordering
compare :: PropertyLookup -> PropertyLookup -> Ordering
$c< :: PropertyLookup -> PropertyLookup -> Bool
< :: PropertyLookup -> PropertyLookup -> Bool
$c<= :: PropertyLookup -> PropertyLookup -> Bool
<= :: PropertyLookup -> PropertyLookup -> Bool
$c> :: PropertyLookup -> PropertyLookup -> Bool
> :: PropertyLookup -> PropertyLookup -> Bool
$c>= :: PropertyLookup -> PropertyLookup -> Bool
>= :: PropertyLookup -> PropertyLookup -> Bool
$cmax :: PropertyLookup -> PropertyLookup -> PropertyLookup
max :: PropertyLookup -> PropertyLookup -> PropertyLookup
$cmin :: PropertyLookup -> PropertyLookup -> PropertyLookup
min :: PropertyLookup -> PropertyLookup -> PropertyLookup
Ord, ReadPrec [PropertyLookup]
ReadPrec PropertyLookup
Int -> ReadS PropertyLookup
ReadS [PropertyLookup]
(Int -> ReadS PropertyLookup)
-> ReadS [PropertyLookup]
-> ReadPrec PropertyLookup
-> ReadPrec [PropertyLookup]
-> Read PropertyLookup
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PropertyLookup
readsPrec :: Int -> ReadS PropertyLookup
$creadList :: ReadS [PropertyLookup]
readList :: ReadS [PropertyLookup]
$creadPrec :: ReadPrec PropertyLookup
readPrec :: ReadPrec PropertyLookup
$creadListPrec :: ReadPrec [PropertyLookup]
readListPrec :: ReadPrec [PropertyLookup]
Read, Int -> PropertyLookup -> ShowS
[PropertyLookup] -> ShowS
PropertyLookup -> String
(Int -> PropertyLookup -> ShowS)
-> (PropertyLookup -> String)
-> ([PropertyLookup] -> ShowS)
-> Show PropertyLookup
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PropertyLookup -> ShowS
showsPrec :: Int -> PropertyLookup -> ShowS
$cshow :: PropertyLookup -> String
show :: PropertyLookup -> String
$cshowList :: [PropertyLookup] -> ShowS
showList :: [PropertyLookup] -> ShowS
Show)

_PropertyLookup :: Name
_PropertyLookup = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PropertyLookup")

data Atom = 
  AtomLiteral Literal |
  AtomParameter Parameter |
  AtomCase CaseExpression |
  AtomCountStar  |
  AtomListComprehension ListComprehension |
  AtomPatternComprehension PatternComprehension |
  AtomQuantifier Quantifier |
  AtomPatternPredicate PatternPredicate |
  AtomParenthesized ParenthesizedExpression |
  AtomFunctionInvocation FunctionInvocation |
  AtomExistentialSubquery ExistentialSubquery |
  AtomVariable Variable
  deriving (Atom -> Atom -> Bool
(Atom -> Atom -> Bool) -> (Atom -> Atom -> Bool) -> Eq Atom
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Atom -> Atom -> Bool
== :: Atom -> Atom -> Bool
$c/= :: Atom -> Atom -> Bool
/= :: Atom -> Atom -> Bool
Eq, Eq Atom
Eq Atom =>
(Atom -> Atom -> Ordering)
-> (Atom -> Atom -> Bool)
-> (Atom -> Atom -> Bool)
-> (Atom -> Atom -> Bool)
-> (Atom -> Atom -> Bool)
-> (Atom -> Atom -> Atom)
-> (Atom -> Atom -> Atom)
-> Ord Atom
Atom -> Atom -> Bool
Atom -> Atom -> Ordering
Atom -> Atom -> Atom
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Atom -> Atom -> Ordering
compare :: Atom -> Atom -> Ordering
$c< :: Atom -> Atom -> Bool
< :: Atom -> Atom -> Bool
$c<= :: Atom -> Atom -> Bool
<= :: Atom -> Atom -> Bool
$c> :: Atom -> Atom -> Bool
> :: Atom -> Atom -> Bool
$c>= :: Atom -> Atom -> Bool
>= :: Atom -> Atom -> Bool
$cmax :: Atom -> Atom -> Atom
max :: Atom -> Atom -> Atom
$cmin :: Atom -> Atom -> Atom
min :: Atom -> Atom -> Atom
Ord, ReadPrec [Atom]
ReadPrec Atom
Int -> ReadS Atom
ReadS [Atom]
(Int -> ReadS Atom)
-> ReadS [Atom] -> ReadPrec Atom -> ReadPrec [Atom] -> Read Atom
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Atom
readsPrec :: Int -> ReadS Atom
$creadList :: ReadS [Atom]
readList :: ReadS [Atom]
$creadPrec :: ReadPrec Atom
readPrec :: ReadPrec Atom
$creadListPrec :: ReadPrec [Atom]
readListPrec :: ReadPrec [Atom]
Read, Int -> Atom -> ShowS
[Atom] -> ShowS
Atom -> String
(Int -> Atom -> ShowS)
-> (Atom -> String) -> ([Atom] -> ShowS) -> Show Atom
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Atom -> ShowS
showsPrec :: Int -> Atom -> ShowS
$cshow :: Atom -> String
show :: Atom -> String
$cshowList :: [Atom] -> ShowS
showList :: [Atom] -> ShowS
Show)

_Atom :: Name
_Atom = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Atom")

_Atom_literal :: Name
_Atom_literal = (String -> Name
Core.Name String
"literal")

_Atom_parameter :: Name
_Atom_parameter = (String -> Name
Core.Name String
"parameter")

_Atom_case :: Name
_Atom_case = (String -> Name
Core.Name String
"case")

_Atom_countStar :: Name
_Atom_countStar = (String -> Name
Core.Name String
"countStar")

_Atom_listComprehension :: Name
_Atom_listComprehension = (String -> Name
Core.Name String
"listComprehension")

_Atom_patternComprehension :: Name
_Atom_patternComprehension = (String -> Name
Core.Name String
"patternComprehension")

_Atom_quantifier :: Name
_Atom_quantifier = (String -> Name
Core.Name String
"quantifier")

_Atom_patternPredicate :: Name
_Atom_patternPredicate = (String -> Name
Core.Name String
"patternPredicate")

_Atom_parenthesized :: Name
_Atom_parenthesized = (String -> Name
Core.Name String
"parenthesized")

_Atom_functionInvocation :: Name
_Atom_functionInvocation = (String -> Name
Core.Name String
"functionInvocation")

_Atom_existentialSubquery :: Name
_Atom_existentialSubquery = (String -> Name
Core.Name String
"existentialSubquery")

_Atom_variable :: Name
_Atom_variable = (String -> Name
Core.Name String
"variable")

data CaseExpression = 
  CaseExpression {
    CaseExpression -> Maybe Expression
caseExpressionExpression :: (Maybe Expression),
    CaseExpression -> [CaseAlternative]
caseExpressionAlternatives :: [CaseAlternative],
    CaseExpression -> Maybe Expression
caseExpressionElse :: (Maybe Expression)}
  deriving (CaseExpression -> CaseExpression -> Bool
(CaseExpression -> CaseExpression -> Bool)
-> (CaseExpression -> CaseExpression -> Bool) -> Eq CaseExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CaseExpression -> CaseExpression -> Bool
== :: CaseExpression -> CaseExpression -> Bool
$c/= :: CaseExpression -> CaseExpression -> Bool
/= :: CaseExpression -> CaseExpression -> Bool
Eq, Eq CaseExpression
Eq CaseExpression =>
(CaseExpression -> CaseExpression -> Ordering)
-> (CaseExpression -> CaseExpression -> Bool)
-> (CaseExpression -> CaseExpression -> Bool)
-> (CaseExpression -> CaseExpression -> Bool)
-> (CaseExpression -> CaseExpression -> Bool)
-> (CaseExpression -> CaseExpression -> CaseExpression)
-> (CaseExpression -> CaseExpression -> CaseExpression)
-> Ord CaseExpression
CaseExpression -> CaseExpression -> Bool
CaseExpression -> CaseExpression -> Ordering
CaseExpression -> CaseExpression -> CaseExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CaseExpression -> CaseExpression -> Ordering
compare :: CaseExpression -> CaseExpression -> Ordering
$c< :: CaseExpression -> CaseExpression -> Bool
< :: CaseExpression -> CaseExpression -> Bool
$c<= :: CaseExpression -> CaseExpression -> Bool
<= :: CaseExpression -> CaseExpression -> Bool
$c> :: CaseExpression -> CaseExpression -> Bool
> :: CaseExpression -> CaseExpression -> Bool
$c>= :: CaseExpression -> CaseExpression -> Bool
>= :: CaseExpression -> CaseExpression -> Bool
$cmax :: CaseExpression -> CaseExpression -> CaseExpression
max :: CaseExpression -> CaseExpression -> CaseExpression
$cmin :: CaseExpression -> CaseExpression -> CaseExpression
min :: CaseExpression -> CaseExpression -> CaseExpression
Ord, ReadPrec [CaseExpression]
ReadPrec CaseExpression
Int -> ReadS CaseExpression
ReadS [CaseExpression]
(Int -> ReadS CaseExpression)
-> ReadS [CaseExpression]
-> ReadPrec CaseExpression
-> ReadPrec [CaseExpression]
-> Read CaseExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CaseExpression
readsPrec :: Int -> ReadS CaseExpression
$creadList :: ReadS [CaseExpression]
readList :: ReadS [CaseExpression]
$creadPrec :: ReadPrec CaseExpression
readPrec :: ReadPrec CaseExpression
$creadListPrec :: ReadPrec [CaseExpression]
readListPrec :: ReadPrec [CaseExpression]
Read, Int -> CaseExpression -> ShowS
[CaseExpression] -> ShowS
CaseExpression -> String
(Int -> CaseExpression -> ShowS)
-> (CaseExpression -> String)
-> ([CaseExpression] -> ShowS)
-> Show CaseExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CaseExpression -> ShowS
showsPrec :: Int -> CaseExpression -> ShowS
$cshow :: CaseExpression -> String
show :: CaseExpression -> String
$cshowList :: [CaseExpression] -> ShowS
showList :: [CaseExpression] -> ShowS
Show)

_CaseExpression :: Name
_CaseExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.CaseExpression")

_CaseExpression_expression :: Name
_CaseExpression_expression = (String -> Name
Core.Name String
"expression")

_CaseExpression_alternatives :: Name
_CaseExpression_alternatives = (String -> Name
Core.Name String
"alternatives")

_CaseExpression_else :: Name
_CaseExpression_else = (String -> Name
Core.Name String
"else")

data CaseAlternative = 
  CaseAlternative {
    CaseAlternative -> Expression
caseAlternativeCondition :: Expression,
    CaseAlternative -> Expression
caseAlternativeResult :: Expression}
  deriving (CaseAlternative -> CaseAlternative -> Bool
(CaseAlternative -> CaseAlternative -> Bool)
-> (CaseAlternative -> CaseAlternative -> Bool)
-> Eq CaseAlternative
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CaseAlternative -> CaseAlternative -> Bool
== :: CaseAlternative -> CaseAlternative -> Bool
$c/= :: CaseAlternative -> CaseAlternative -> Bool
/= :: CaseAlternative -> CaseAlternative -> Bool
Eq, Eq CaseAlternative
Eq CaseAlternative =>
(CaseAlternative -> CaseAlternative -> Ordering)
-> (CaseAlternative -> CaseAlternative -> Bool)
-> (CaseAlternative -> CaseAlternative -> Bool)
-> (CaseAlternative -> CaseAlternative -> Bool)
-> (CaseAlternative -> CaseAlternative -> Bool)
-> (CaseAlternative -> CaseAlternative -> CaseAlternative)
-> (CaseAlternative -> CaseAlternative -> CaseAlternative)
-> Ord CaseAlternative
CaseAlternative -> CaseAlternative -> Bool
CaseAlternative -> CaseAlternative -> Ordering
CaseAlternative -> CaseAlternative -> CaseAlternative
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CaseAlternative -> CaseAlternative -> Ordering
compare :: CaseAlternative -> CaseAlternative -> Ordering
$c< :: CaseAlternative -> CaseAlternative -> Bool
< :: CaseAlternative -> CaseAlternative -> Bool
$c<= :: CaseAlternative -> CaseAlternative -> Bool
<= :: CaseAlternative -> CaseAlternative -> Bool
$c> :: CaseAlternative -> CaseAlternative -> Bool
> :: CaseAlternative -> CaseAlternative -> Bool
$c>= :: CaseAlternative -> CaseAlternative -> Bool
>= :: CaseAlternative -> CaseAlternative -> Bool
$cmax :: CaseAlternative -> CaseAlternative -> CaseAlternative
max :: CaseAlternative -> CaseAlternative -> CaseAlternative
$cmin :: CaseAlternative -> CaseAlternative -> CaseAlternative
min :: CaseAlternative -> CaseAlternative -> CaseAlternative
Ord, ReadPrec [CaseAlternative]
ReadPrec CaseAlternative
Int -> ReadS CaseAlternative
ReadS [CaseAlternative]
(Int -> ReadS CaseAlternative)
-> ReadS [CaseAlternative]
-> ReadPrec CaseAlternative
-> ReadPrec [CaseAlternative]
-> Read CaseAlternative
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CaseAlternative
readsPrec :: Int -> ReadS CaseAlternative
$creadList :: ReadS [CaseAlternative]
readList :: ReadS [CaseAlternative]
$creadPrec :: ReadPrec CaseAlternative
readPrec :: ReadPrec CaseAlternative
$creadListPrec :: ReadPrec [CaseAlternative]
readListPrec :: ReadPrec [CaseAlternative]
Read, Int -> CaseAlternative -> ShowS
[CaseAlternative] -> ShowS
CaseAlternative -> String
(Int -> CaseAlternative -> ShowS)
-> (CaseAlternative -> String)
-> ([CaseAlternative] -> ShowS)
-> Show CaseAlternative
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CaseAlternative -> ShowS
showsPrec :: Int -> CaseAlternative -> ShowS
$cshow :: CaseAlternative -> String
show :: CaseAlternative -> String
$cshowList :: [CaseAlternative] -> ShowS
showList :: [CaseAlternative] -> ShowS
Show)

_CaseAlternative :: Name
_CaseAlternative = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.CaseAlternative")

_CaseAlternative_condition :: Name
_CaseAlternative_condition = (String -> Name
Core.Name String
"condition")

_CaseAlternative_result :: Name
_CaseAlternative_result = (String -> Name
Core.Name String
"result")

data ListComprehension = 
  ListComprehension {
    ListComprehension -> FilterExpression
listComprehensionLeft :: FilterExpression,
    ListComprehension -> Maybe Expression
listComprehensionRight :: (Maybe Expression)}
  deriving (ListComprehension -> ListComprehension -> Bool
(ListComprehension -> ListComprehension -> Bool)
-> (ListComprehension -> ListComprehension -> Bool)
-> Eq ListComprehension
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListComprehension -> ListComprehension -> Bool
== :: ListComprehension -> ListComprehension -> Bool
$c/= :: ListComprehension -> ListComprehension -> Bool
/= :: ListComprehension -> ListComprehension -> Bool
Eq, Eq ListComprehension
Eq ListComprehension =>
(ListComprehension -> ListComprehension -> Ordering)
-> (ListComprehension -> ListComprehension -> Bool)
-> (ListComprehension -> ListComprehension -> Bool)
-> (ListComprehension -> ListComprehension -> Bool)
-> (ListComprehension -> ListComprehension -> Bool)
-> (ListComprehension -> ListComprehension -> ListComprehension)
-> (ListComprehension -> ListComprehension -> ListComprehension)
-> Ord ListComprehension
ListComprehension -> ListComprehension -> Bool
ListComprehension -> ListComprehension -> Ordering
ListComprehension -> ListComprehension -> ListComprehension
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ListComprehension -> ListComprehension -> Ordering
compare :: ListComprehension -> ListComprehension -> Ordering
$c< :: ListComprehension -> ListComprehension -> Bool
< :: ListComprehension -> ListComprehension -> Bool
$c<= :: ListComprehension -> ListComprehension -> Bool
<= :: ListComprehension -> ListComprehension -> Bool
$c> :: ListComprehension -> ListComprehension -> Bool
> :: ListComprehension -> ListComprehension -> Bool
$c>= :: ListComprehension -> ListComprehension -> Bool
>= :: ListComprehension -> ListComprehension -> Bool
$cmax :: ListComprehension -> ListComprehension -> ListComprehension
max :: ListComprehension -> ListComprehension -> ListComprehension
$cmin :: ListComprehension -> ListComprehension -> ListComprehension
min :: ListComprehension -> ListComprehension -> ListComprehension
Ord, ReadPrec [ListComprehension]
ReadPrec ListComprehension
Int -> ReadS ListComprehension
ReadS [ListComprehension]
(Int -> ReadS ListComprehension)
-> ReadS [ListComprehension]
-> ReadPrec ListComprehension
-> ReadPrec [ListComprehension]
-> Read ListComprehension
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ListComprehension
readsPrec :: Int -> ReadS ListComprehension
$creadList :: ReadS [ListComprehension]
readList :: ReadS [ListComprehension]
$creadPrec :: ReadPrec ListComprehension
readPrec :: ReadPrec ListComprehension
$creadListPrec :: ReadPrec [ListComprehension]
readListPrec :: ReadPrec [ListComprehension]
Read, Int -> ListComprehension -> ShowS
[ListComprehension] -> ShowS
ListComprehension -> String
(Int -> ListComprehension -> ShowS)
-> (ListComprehension -> String)
-> ([ListComprehension] -> ShowS)
-> Show ListComprehension
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListComprehension -> ShowS
showsPrec :: Int -> ListComprehension -> ShowS
$cshow :: ListComprehension -> String
show :: ListComprehension -> String
$cshowList :: [ListComprehension] -> ShowS
showList :: [ListComprehension] -> ShowS
Show)

_ListComprehension :: Name
_ListComprehension = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ListComprehension")

_ListComprehension_left :: Name
_ListComprehension_left = (String -> Name
Core.Name String
"left")

_ListComprehension_right :: Name
_ListComprehension_right = (String -> Name
Core.Name String
"right")

data PatternComprehension = 
  PatternComprehension {
    PatternComprehension -> Maybe Variable
patternComprehensionVariable :: (Maybe Variable),
    PatternComprehension -> RelationshipsPattern
patternComprehensionPattern :: RelationshipsPattern,
    PatternComprehension -> Maybe Where
patternComprehensionWhere :: (Maybe Where),
    PatternComprehension -> Expression
patternComprehensionRight :: Expression}
  deriving (PatternComprehension -> PatternComprehension -> Bool
(PatternComprehension -> PatternComprehension -> Bool)
-> (PatternComprehension -> PatternComprehension -> Bool)
-> Eq PatternComprehension
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PatternComprehension -> PatternComprehension -> Bool
== :: PatternComprehension -> PatternComprehension -> Bool
$c/= :: PatternComprehension -> PatternComprehension -> Bool
/= :: PatternComprehension -> PatternComprehension -> Bool
Eq, Eq PatternComprehension
Eq PatternComprehension =>
(PatternComprehension -> PatternComprehension -> Ordering)
-> (PatternComprehension -> PatternComprehension -> Bool)
-> (PatternComprehension -> PatternComprehension -> Bool)
-> (PatternComprehension -> PatternComprehension -> Bool)
-> (PatternComprehension -> PatternComprehension -> Bool)
-> (PatternComprehension
    -> PatternComprehension -> PatternComprehension)
-> (PatternComprehension
    -> PatternComprehension -> PatternComprehension)
-> Ord PatternComprehension
PatternComprehension -> PatternComprehension -> Bool
PatternComprehension -> PatternComprehension -> Ordering
PatternComprehension
-> PatternComprehension -> PatternComprehension
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PatternComprehension -> PatternComprehension -> Ordering
compare :: PatternComprehension -> PatternComprehension -> Ordering
$c< :: PatternComprehension -> PatternComprehension -> Bool
< :: PatternComprehension -> PatternComprehension -> Bool
$c<= :: PatternComprehension -> PatternComprehension -> Bool
<= :: PatternComprehension -> PatternComprehension -> Bool
$c> :: PatternComprehension -> PatternComprehension -> Bool
> :: PatternComprehension -> PatternComprehension -> Bool
$c>= :: PatternComprehension -> PatternComprehension -> Bool
>= :: PatternComprehension -> PatternComprehension -> Bool
$cmax :: PatternComprehension
-> PatternComprehension -> PatternComprehension
max :: PatternComprehension
-> PatternComprehension -> PatternComprehension
$cmin :: PatternComprehension
-> PatternComprehension -> PatternComprehension
min :: PatternComprehension
-> PatternComprehension -> PatternComprehension
Ord, ReadPrec [PatternComprehension]
ReadPrec PatternComprehension
Int -> ReadS PatternComprehension
ReadS [PatternComprehension]
(Int -> ReadS PatternComprehension)
-> ReadS [PatternComprehension]
-> ReadPrec PatternComprehension
-> ReadPrec [PatternComprehension]
-> Read PatternComprehension
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PatternComprehension
readsPrec :: Int -> ReadS PatternComprehension
$creadList :: ReadS [PatternComprehension]
readList :: ReadS [PatternComprehension]
$creadPrec :: ReadPrec PatternComprehension
readPrec :: ReadPrec PatternComprehension
$creadListPrec :: ReadPrec [PatternComprehension]
readListPrec :: ReadPrec [PatternComprehension]
Read, Int -> PatternComprehension -> ShowS
[PatternComprehension] -> ShowS
PatternComprehension -> String
(Int -> PatternComprehension -> ShowS)
-> (PatternComprehension -> String)
-> ([PatternComprehension] -> ShowS)
-> Show PatternComprehension
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PatternComprehension -> ShowS
showsPrec :: Int -> PatternComprehension -> ShowS
$cshow :: PatternComprehension -> String
show :: PatternComprehension -> String
$cshowList :: [PatternComprehension] -> ShowS
showList :: [PatternComprehension] -> ShowS
Show)

_PatternComprehension :: Name
_PatternComprehension = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PatternComprehension")

_PatternComprehension_variable :: Name
_PatternComprehension_variable = (String -> Name
Core.Name String
"variable")

_PatternComprehension_pattern :: Name
_PatternComprehension_pattern = (String -> Name
Core.Name String
"pattern")

_PatternComprehension_where :: Name
_PatternComprehension_where = (String -> Name
Core.Name String
"where")

_PatternComprehension_right :: Name
_PatternComprehension_right = (String -> Name
Core.Name String
"right")

data Quantifier = 
  Quantifier {
    Quantifier -> QuantifierOperator
quantifierOperator :: QuantifierOperator,
    Quantifier -> FilterExpression
quantifierExpression :: FilterExpression}
  deriving (Quantifier -> Quantifier -> Bool
(Quantifier -> Quantifier -> Bool)
-> (Quantifier -> Quantifier -> Bool) -> Eq Quantifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Quantifier -> Quantifier -> Bool
== :: Quantifier -> Quantifier -> Bool
$c/= :: Quantifier -> Quantifier -> Bool
/= :: Quantifier -> Quantifier -> Bool
Eq, Eq Quantifier
Eq Quantifier =>
(Quantifier -> Quantifier -> Ordering)
-> (Quantifier -> Quantifier -> Bool)
-> (Quantifier -> Quantifier -> Bool)
-> (Quantifier -> Quantifier -> Bool)
-> (Quantifier -> Quantifier -> Bool)
-> (Quantifier -> Quantifier -> Quantifier)
-> (Quantifier -> Quantifier -> Quantifier)
-> Ord Quantifier
Quantifier -> Quantifier -> Bool
Quantifier -> Quantifier -> Ordering
Quantifier -> Quantifier -> Quantifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Quantifier -> Quantifier -> Ordering
compare :: Quantifier -> Quantifier -> Ordering
$c< :: Quantifier -> Quantifier -> Bool
< :: Quantifier -> Quantifier -> Bool
$c<= :: Quantifier -> Quantifier -> Bool
<= :: Quantifier -> Quantifier -> Bool
$c> :: Quantifier -> Quantifier -> Bool
> :: Quantifier -> Quantifier -> Bool
$c>= :: Quantifier -> Quantifier -> Bool
>= :: Quantifier -> Quantifier -> Bool
$cmax :: Quantifier -> Quantifier -> Quantifier
max :: Quantifier -> Quantifier -> Quantifier
$cmin :: Quantifier -> Quantifier -> Quantifier
min :: Quantifier -> Quantifier -> Quantifier
Ord, ReadPrec [Quantifier]
ReadPrec Quantifier
Int -> ReadS Quantifier
ReadS [Quantifier]
(Int -> ReadS Quantifier)
-> ReadS [Quantifier]
-> ReadPrec Quantifier
-> ReadPrec [Quantifier]
-> Read Quantifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Quantifier
readsPrec :: Int -> ReadS Quantifier
$creadList :: ReadS [Quantifier]
readList :: ReadS [Quantifier]
$creadPrec :: ReadPrec Quantifier
readPrec :: ReadPrec Quantifier
$creadListPrec :: ReadPrec [Quantifier]
readListPrec :: ReadPrec [Quantifier]
Read, Int -> Quantifier -> ShowS
[Quantifier] -> ShowS
Quantifier -> String
(Int -> Quantifier -> ShowS)
-> (Quantifier -> String)
-> ([Quantifier] -> ShowS)
-> Show Quantifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Quantifier -> ShowS
showsPrec :: Int -> Quantifier -> ShowS
$cshow :: Quantifier -> String
show :: Quantifier -> String
$cshowList :: [Quantifier] -> ShowS
showList :: [Quantifier] -> ShowS
Show)

_Quantifier :: Name
_Quantifier = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Quantifier")

_Quantifier_operator :: Name
_Quantifier_operator = (String -> Name
Core.Name String
"operator")

_Quantifier_expression :: Name
_Quantifier_expression = (String -> Name
Core.Name String
"expression")

data QuantifierOperator = 
  QuantifierOperatorAll  |
  QuantifierOperatorAny  |
  QuantifierOperatorNone  |
  QuantifierOperatorSingle 
  deriving (QuantifierOperator -> QuantifierOperator -> Bool
(QuantifierOperator -> QuantifierOperator -> Bool)
-> (QuantifierOperator -> QuantifierOperator -> Bool)
-> Eq QuantifierOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QuantifierOperator -> QuantifierOperator -> Bool
== :: QuantifierOperator -> QuantifierOperator -> Bool
$c/= :: QuantifierOperator -> QuantifierOperator -> Bool
/= :: QuantifierOperator -> QuantifierOperator -> Bool
Eq, Eq QuantifierOperator
Eq QuantifierOperator =>
(QuantifierOperator -> QuantifierOperator -> Ordering)
-> (QuantifierOperator -> QuantifierOperator -> Bool)
-> (QuantifierOperator -> QuantifierOperator -> Bool)
-> (QuantifierOperator -> QuantifierOperator -> Bool)
-> (QuantifierOperator -> QuantifierOperator -> Bool)
-> (QuantifierOperator -> QuantifierOperator -> QuantifierOperator)
-> (QuantifierOperator -> QuantifierOperator -> QuantifierOperator)
-> Ord QuantifierOperator
QuantifierOperator -> QuantifierOperator -> Bool
QuantifierOperator -> QuantifierOperator -> Ordering
QuantifierOperator -> QuantifierOperator -> QuantifierOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: QuantifierOperator -> QuantifierOperator -> Ordering
compare :: QuantifierOperator -> QuantifierOperator -> Ordering
$c< :: QuantifierOperator -> QuantifierOperator -> Bool
< :: QuantifierOperator -> QuantifierOperator -> Bool
$c<= :: QuantifierOperator -> QuantifierOperator -> Bool
<= :: QuantifierOperator -> QuantifierOperator -> Bool
$c> :: QuantifierOperator -> QuantifierOperator -> Bool
> :: QuantifierOperator -> QuantifierOperator -> Bool
$c>= :: QuantifierOperator -> QuantifierOperator -> Bool
>= :: QuantifierOperator -> QuantifierOperator -> Bool
$cmax :: QuantifierOperator -> QuantifierOperator -> QuantifierOperator
max :: QuantifierOperator -> QuantifierOperator -> QuantifierOperator
$cmin :: QuantifierOperator -> QuantifierOperator -> QuantifierOperator
min :: QuantifierOperator -> QuantifierOperator -> QuantifierOperator
Ord, ReadPrec [QuantifierOperator]
ReadPrec QuantifierOperator
Int -> ReadS QuantifierOperator
ReadS [QuantifierOperator]
(Int -> ReadS QuantifierOperator)
-> ReadS [QuantifierOperator]
-> ReadPrec QuantifierOperator
-> ReadPrec [QuantifierOperator]
-> Read QuantifierOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS QuantifierOperator
readsPrec :: Int -> ReadS QuantifierOperator
$creadList :: ReadS [QuantifierOperator]
readList :: ReadS [QuantifierOperator]
$creadPrec :: ReadPrec QuantifierOperator
readPrec :: ReadPrec QuantifierOperator
$creadListPrec :: ReadPrec [QuantifierOperator]
readListPrec :: ReadPrec [QuantifierOperator]
Read, Int -> QuantifierOperator -> ShowS
[QuantifierOperator] -> ShowS
QuantifierOperator -> String
(Int -> QuantifierOperator -> ShowS)
-> (QuantifierOperator -> String)
-> ([QuantifierOperator] -> ShowS)
-> Show QuantifierOperator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QuantifierOperator -> ShowS
showsPrec :: Int -> QuantifierOperator -> ShowS
$cshow :: QuantifierOperator -> String
show :: QuantifierOperator -> String
$cshowList :: [QuantifierOperator] -> ShowS
showList :: [QuantifierOperator] -> ShowS
Show)

_QuantifierOperator :: Name
_QuantifierOperator = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.QuantifierOperator")

_QuantifierOperator_all :: Name
_QuantifierOperator_all = (String -> Name
Core.Name String
"all")

_QuantifierOperator_any :: Name
_QuantifierOperator_any = (String -> Name
Core.Name String
"any")

_QuantifierOperator_none :: Name
_QuantifierOperator_none = (String -> Name
Core.Name String
"none")

_QuantifierOperator_single :: Name
_QuantifierOperator_single = (String -> Name
Core.Name String
"single")

data FilterExpression = 
  FilterExpression {
    FilterExpression -> IdInColl
filterExpressionIdInColl :: IdInColl,
    FilterExpression -> Maybe Where
filterExpressionWhere :: (Maybe Where)}
  deriving (FilterExpression -> FilterExpression -> Bool
(FilterExpression -> FilterExpression -> Bool)
-> (FilterExpression -> FilterExpression -> Bool)
-> Eq FilterExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FilterExpression -> FilterExpression -> Bool
== :: FilterExpression -> FilterExpression -> Bool
$c/= :: FilterExpression -> FilterExpression -> Bool
/= :: FilterExpression -> FilterExpression -> Bool
Eq, Eq FilterExpression
Eq FilterExpression =>
(FilterExpression -> FilterExpression -> Ordering)
-> (FilterExpression -> FilterExpression -> Bool)
-> (FilterExpression -> FilterExpression -> Bool)
-> (FilterExpression -> FilterExpression -> Bool)
-> (FilterExpression -> FilterExpression -> Bool)
-> (FilterExpression -> FilterExpression -> FilterExpression)
-> (FilterExpression -> FilterExpression -> FilterExpression)
-> Ord FilterExpression
FilterExpression -> FilterExpression -> Bool
FilterExpression -> FilterExpression -> Ordering
FilterExpression -> FilterExpression -> FilterExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FilterExpression -> FilterExpression -> Ordering
compare :: FilterExpression -> FilterExpression -> Ordering
$c< :: FilterExpression -> FilterExpression -> Bool
< :: FilterExpression -> FilterExpression -> Bool
$c<= :: FilterExpression -> FilterExpression -> Bool
<= :: FilterExpression -> FilterExpression -> Bool
$c> :: FilterExpression -> FilterExpression -> Bool
> :: FilterExpression -> FilterExpression -> Bool
$c>= :: FilterExpression -> FilterExpression -> Bool
>= :: FilterExpression -> FilterExpression -> Bool
$cmax :: FilterExpression -> FilterExpression -> FilterExpression
max :: FilterExpression -> FilterExpression -> FilterExpression
$cmin :: FilterExpression -> FilterExpression -> FilterExpression
min :: FilterExpression -> FilterExpression -> FilterExpression
Ord, ReadPrec [FilterExpression]
ReadPrec FilterExpression
Int -> ReadS FilterExpression
ReadS [FilterExpression]
(Int -> ReadS FilterExpression)
-> ReadS [FilterExpression]
-> ReadPrec FilterExpression
-> ReadPrec [FilterExpression]
-> Read FilterExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FilterExpression
readsPrec :: Int -> ReadS FilterExpression
$creadList :: ReadS [FilterExpression]
readList :: ReadS [FilterExpression]
$creadPrec :: ReadPrec FilterExpression
readPrec :: ReadPrec FilterExpression
$creadListPrec :: ReadPrec [FilterExpression]
readListPrec :: ReadPrec [FilterExpression]
Read, Int -> FilterExpression -> ShowS
[FilterExpression] -> ShowS
FilterExpression -> String
(Int -> FilterExpression -> ShowS)
-> (FilterExpression -> String)
-> ([FilterExpression] -> ShowS)
-> Show FilterExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FilterExpression -> ShowS
showsPrec :: Int -> FilterExpression -> ShowS
$cshow :: FilterExpression -> String
show :: FilterExpression -> String
$cshowList :: [FilterExpression] -> ShowS
showList :: [FilterExpression] -> ShowS
Show)

_FilterExpression :: Name
_FilterExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.FilterExpression")

_FilterExpression_idInColl :: Name
_FilterExpression_idInColl = (String -> Name
Core.Name String
"idInColl")

_FilterExpression_where :: Name
_FilterExpression_where = (String -> Name
Core.Name String
"where")

newtype PatternPredicate = 
  PatternPredicate {
    PatternPredicate -> RelationshipsPattern
unPatternPredicate :: RelationshipsPattern}
  deriving (PatternPredicate -> PatternPredicate -> Bool
(PatternPredicate -> PatternPredicate -> Bool)
-> (PatternPredicate -> PatternPredicate -> Bool)
-> Eq PatternPredicate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PatternPredicate -> PatternPredicate -> Bool
== :: PatternPredicate -> PatternPredicate -> Bool
$c/= :: PatternPredicate -> PatternPredicate -> Bool
/= :: PatternPredicate -> PatternPredicate -> Bool
Eq, Eq PatternPredicate
Eq PatternPredicate =>
(PatternPredicate -> PatternPredicate -> Ordering)
-> (PatternPredicate -> PatternPredicate -> Bool)
-> (PatternPredicate -> PatternPredicate -> Bool)
-> (PatternPredicate -> PatternPredicate -> Bool)
-> (PatternPredicate -> PatternPredicate -> Bool)
-> (PatternPredicate -> PatternPredicate -> PatternPredicate)
-> (PatternPredicate -> PatternPredicate -> PatternPredicate)
-> Ord PatternPredicate
PatternPredicate -> PatternPredicate -> Bool
PatternPredicate -> PatternPredicate -> Ordering
PatternPredicate -> PatternPredicate -> PatternPredicate
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PatternPredicate -> PatternPredicate -> Ordering
compare :: PatternPredicate -> PatternPredicate -> Ordering
$c< :: PatternPredicate -> PatternPredicate -> Bool
< :: PatternPredicate -> PatternPredicate -> Bool
$c<= :: PatternPredicate -> PatternPredicate -> Bool
<= :: PatternPredicate -> PatternPredicate -> Bool
$c> :: PatternPredicate -> PatternPredicate -> Bool
> :: PatternPredicate -> PatternPredicate -> Bool
$c>= :: PatternPredicate -> PatternPredicate -> Bool
>= :: PatternPredicate -> PatternPredicate -> Bool
$cmax :: PatternPredicate -> PatternPredicate -> PatternPredicate
max :: PatternPredicate -> PatternPredicate -> PatternPredicate
$cmin :: PatternPredicate -> PatternPredicate -> PatternPredicate
min :: PatternPredicate -> PatternPredicate -> PatternPredicate
Ord, ReadPrec [PatternPredicate]
ReadPrec PatternPredicate
Int -> ReadS PatternPredicate
ReadS [PatternPredicate]
(Int -> ReadS PatternPredicate)
-> ReadS [PatternPredicate]
-> ReadPrec PatternPredicate
-> ReadPrec [PatternPredicate]
-> Read PatternPredicate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PatternPredicate
readsPrec :: Int -> ReadS PatternPredicate
$creadList :: ReadS [PatternPredicate]
readList :: ReadS [PatternPredicate]
$creadPrec :: ReadPrec PatternPredicate
readPrec :: ReadPrec PatternPredicate
$creadListPrec :: ReadPrec [PatternPredicate]
readListPrec :: ReadPrec [PatternPredicate]
Read, Int -> PatternPredicate -> ShowS
[PatternPredicate] -> ShowS
PatternPredicate -> String
(Int -> PatternPredicate -> ShowS)
-> (PatternPredicate -> String)
-> ([PatternPredicate] -> ShowS)
-> Show PatternPredicate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PatternPredicate -> ShowS
showsPrec :: Int -> PatternPredicate -> ShowS
$cshow :: PatternPredicate -> String
show :: PatternPredicate -> String
$cshowList :: [PatternPredicate] -> ShowS
showList :: [PatternPredicate] -> ShowS
Show)

_PatternPredicate :: Name
_PatternPredicate = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PatternPredicate")

newtype ParenthesizedExpression = 
  ParenthesizedExpression {
    ParenthesizedExpression -> Expression
unParenthesizedExpression :: Expression}
  deriving (ParenthesizedExpression -> ParenthesizedExpression -> Bool
(ParenthesizedExpression -> ParenthesizedExpression -> Bool)
-> (ParenthesizedExpression -> ParenthesizedExpression -> Bool)
-> Eq ParenthesizedExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
== :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
$c/= :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
/= :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
Eq, Eq ParenthesizedExpression
Eq ParenthesizedExpression =>
(ParenthesizedExpression -> ParenthesizedExpression -> Ordering)
-> (ParenthesizedExpression -> ParenthesizedExpression -> Bool)
-> (ParenthesizedExpression -> ParenthesizedExpression -> Bool)
-> (ParenthesizedExpression -> ParenthesizedExpression -> Bool)
-> (ParenthesizedExpression -> ParenthesizedExpression -> Bool)
-> (ParenthesizedExpression
    -> ParenthesizedExpression -> ParenthesizedExpression)
-> (ParenthesizedExpression
    -> ParenthesizedExpression -> ParenthesizedExpression)
-> Ord ParenthesizedExpression
ParenthesizedExpression -> ParenthesizedExpression -> Bool
ParenthesizedExpression -> ParenthesizedExpression -> Ordering
ParenthesizedExpression
-> ParenthesizedExpression -> ParenthesizedExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ParenthesizedExpression -> ParenthesizedExpression -> Ordering
compare :: ParenthesizedExpression -> ParenthesizedExpression -> Ordering
$c< :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
< :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
$c<= :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
<= :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
$c> :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
> :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
$c>= :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
>= :: ParenthesizedExpression -> ParenthesizedExpression -> Bool
$cmax :: ParenthesizedExpression
-> ParenthesizedExpression -> ParenthesizedExpression
max :: ParenthesizedExpression
-> ParenthesizedExpression -> ParenthesizedExpression
$cmin :: ParenthesizedExpression
-> ParenthesizedExpression -> ParenthesizedExpression
min :: ParenthesizedExpression
-> ParenthesizedExpression -> ParenthesizedExpression
Ord, ReadPrec [ParenthesizedExpression]
ReadPrec ParenthesizedExpression
Int -> ReadS ParenthesizedExpression
ReadS [ParenthesizedExpression]
(Int -> ReadS ParenthesizedExpression)
-> ReadS [ParenthesizedExpression]
-> ReadPrec ParenthesizedExpression
-> ReadPrec [ParenthesizedExpression]
-> Read ParenthesizedExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ParenthesizedExpression
readsPrec :: Int -> ReadS ParenthesizedExpression
$creadList :: ReadS [ParenthesizedExpression]
readList :: ReadS [ParenthesizedExpression]
$creadPrec :: ReadPrec ParenthesizedExpression
readPrec :: ReadPrec ParenthesizedExpression
$creadListPrec :: ReadPrec [ParenthesizedExpression]
readListPrec :: ReadPrec [ParenthesizedExpression]
Read, Int -> ParenthesizedExpression -> ShowS
[ParenthesizedExpression] -> ShowS
ParenthesizedExpression -> String
(Int -> ParenthesizedExpression -> ShowS)
-> (ParenthesizedExpression -> String)
-> ([ParenthesizedExpression] -> ShowS)
-> Show ParenthesizedExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ParenthesizedExpression -> ShowS
showsPrec :: Int -> ParenthesizedExpression -> ShowS
$cshow :: ParenthesizedExpression -> String
show :: ParenthesizedExpression -> String
$cshowList :: [ParenthesizedExpression] -> ShowS
showList :: [ParenthesizedExpression] -> ShowS
Show)

_ParenthesizedExpression :: Name
_ParenthesizedExpression = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ParenthesizedExpression")

data IdInColl = 
  IdInColl {
    IdInColl -> Variable
idInCollVariable :: Variable,
    IdInColl -> Expression
idInCollExpression :: Expression}
  deriving (IdInColl -> IdInColl -> Bool
(IdInColl -> IdInColl -> Bool)
-> (IdInColl -> IdInColl -> Bool) -> Eq IdInColl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IdInColl -> IdInColl -> Bool
== :: IdInColl -> IdInColl -> Bool
$c/= :: IdInColl -> IdInColl -> Bool
/= :: IdInColl -> IdInColl -> Bool
Eq, Eq IdInColl
Eq IdInColl =>
(IdInColl -> IdInColl -> Ordering)
-> (IdInColl -> IdInColl -> Bool)
-> (IdInColl -> IdInColl -> Bool)
-> (IdInColl -> IdInColl -> Bool)
-> (IdInColl -> IdInColl -> Bool)
-> (IdInColl -> IdInColl -> IdInColl)
-> (IdInColl -> IdInColl -> IdInColl)
-> Ord IdInColl
IdInColl -> IdInColl -> Bool
IdInColl -> IdInColl -> Ordering
IdInColl -> IdInColl -> IdInColl
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IdInColl -> IdInColl -> Ordering
compare :: IdInColl -> IdInColl -> Ordering
$c< :: IdInColl -> IdInColl -> Bool
< :: IdInColl -> IdInColl -> Bool
$c<= :: IdInColl -> IdInColl -> Bool
<= :: IdInColl -> IdInColl -> Bool
$c> :: IdInColl -> IdInColl -> Bool
> :: IdInColl -> IdInColl -> Bool
$c>= :: IdInColl -> IdInColl -> Bool
>= :: IdInColl -> IdInColl -> Bool
$cmax :: IdInColl -> IdInColl -> IdInColl
max :: IdInColl -> IdInColl -> IdInColl
$cmin :: IdInColl -> IdInColl -> IdInColl
min :: IdInColl -> IdInColl -> IdInColl
Ord, ReadPrec [IdInColl]
ReadPrec IdInColl
Int -> ReadS IdInColl
ReadS [IdInColl]
(Int -> ReadS IdInColl)
-> ReadS [IdInColl]
-> ReadPrec IdInColl
-> ReadPrec [IdInColl]
-> Read IdInColl
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IdInColl
readsPrec :: Int -> ReadS IdInColl
$creadList :: ReadS [IdInColl]
readList :: ReadS [IdInColl]
$creadPrec :: ReadPrec IdInColl
readPrec :: ReadPrec IdInColl
$creadListPrec :: ReadPrec [IdInColl]
readListPrec :: ReadPrec [IdInColl]
Read, Int -> IdInColl -> ShowS
[IdInColl] -> ShowS
IdInColl -> String
(Int -> IdInColl -> ShowS)
-> (IdInColl -> String) -> ([IdInColl] -> ShowS) -> Show IdInColl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IdInColl -> ShowS
showsPrec :: Int -> IdInColl -> ShowS
$cshow :: IdInColl -> String
show :: IdInColl -> String
$cshowList :: [IdInColl] -> ShowS
showList :: [IdInColl] -> ShowS
Show)

_IdInColl :: Name
_IdInColl = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.IdInColl")

_IdInColl_variable :: Name
_IdInColl_variable = (String -> Name
Core.Name String
"variable")

_IdInColl_expression :: Name
_IdInColl_expression = (String -> Name
Core.Name String
"expression")

data FunctionInvocation = 
  FunctionInvocation {
    FunctionInvocation -> QualifiedName
functionInvocationName :: QualifiedName,
    FunctionInvocation -> Bool
functionInvocationDistinct :: Bool,
    FunctionInvocation -> [Expression]
functionInvocationArguments :: [Expression]}
  deriving (FunctionInvocation -> FunctionInvocation -> Bool
(FunctionInvocation -> FunctionInvocation -> Bool)
-> (FunctionInvocation -> FunctionInvocation -> Bool)
-> Eq FunctionInvocation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FunctionInvocation -> FunctionInvocation -> Bool
== :: FunctionInvocation -> FunctionInvocation -> Bool
$c/= :: FunctionInvocation -> FunctionInvocation -> Bool
/= :: FunctionInvocation -> FunctionInvocation -> Bool
Eq, Eq FunctionInvocation
Eq FunctionInvocation =>
(FunctionInvocation -> FunctionInvocation -> Ordering)
-> (FunctionInvocation -> FunctionInvocation -> Bool)
-> (FunctionInvocation -> FunctionInvocation -> Bool)
-> (FunctionInvocation -> FunctionInvocation -> Bool)
-> (FunctionInvocation -> FunctionInvocation -> Bool)
-> (FunctionInvocation -> FunctionInvocation -> FunctionInvocation)
-> (FunctionInvocation -> FunctionInvocation -> FunctionInvocation)
-> Ord FunctionInvocation
FunctionInvocation -> FunctionInvocation -> Bool
FunctionInvocation -> FunctionInvocation -> Ordering
FunctionInvocation -> FunctionInvocation -> FunctionInvocation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FunctionInvocation -> FunctionInvocation -> Ordering
compare :: FunctionInvocation -> FunctionInvocation -> Ordering
$c< :: FunctionInvocation -> FunctionInvocation -> Bool
< :: FunctionInvocation -> FunctionInvocation -> Bool
$c<= :: FunctionInvocation -> FunctionInvocation -> Bool
<= :: FunctionInvocation -> FunctionInvocation -> Bool
$c> :: FunctionInvocation -> FunctionInvocation -> Bool
> :: FunctionInvocation -> FunctionInvocation -> Bool
$c>= :: FunctionInvocation -> FunctionInvocation -> Bool
>= :: FunctionInvocation -> FunctionInvocation -> Bool
$cmax :: FunctionInvocation -> FunctionInvocation -> FunctionInvocation
max :: FunctionInvocation -> FunctionInvocation -> FunctionInvocation
$cmin :: FunctionInvocation -> FunctionInvocation -> FunctionInvocation
min :: FunctionInvocation -> FunctionInvocation -> FunctionInvocation
Ord, ReadPrec [FunctionInvocation]
ReadPrec FunctionInvocation
Int -> ReadS FunctionInvocation
ReadS [FunctionInvocation]
(Int -> ReadS FunctionInvocation)
-> ReadS [FunctionInvocation]
-> ReadPrec FunctionInvocation
-> ReadPrec [FunctionInvocation]
-> Read FunctionInvocation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FunctionInvocation
readsPrec :: Int -> ReadS FunctionInvocation
$creadList :: ReadS [FunctionInvocation]
readList :: ReadS [FunctionInvocation]
$creadPrec :: ReadPrec FunctionInvocation
readPrec :: ReadPrec FunctionInvocation
$creadListPrec :: ReadPrec [FunctionInvocation]
readListPrec :: ReadPrec [FunctionInvocation]
Read, Int -> FunctionInvocation -> ShowS
[FunctionInvocation] -> ShowS
FunctionInvocation -> String
(Int -> FunctionInvocation -> ShowS)
-> (FunctionInvocation -> String)
-> ([FunctionInvocation] -> ShowS)
-> Show FunctionInvocation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FunctionInvocation -> ShowS
showsPrec :: Int -> FunctionInvocation -> ShowS
$cshow :: FunctionInvocation -> String
show :: FunctionInvocation -> String
$cshowList :: [FunctionInvocation] -> ShowS
showList :: [FunctionInvocation] -> ShowS
Show)

_FunctionInvocation :: Name
_FunctionInvocation = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.FunctionInvocation")

_FunctionInvocation_name :: Name
_FunctionInvocation_name = (String -> Name
Core.Name String
"name")

_FunctionInvocation_distinct :: Name
_FunctionInvocation_distinct = (String -> Name
Core.Name String
"distinct")

_FunctionInvocation_arguments :: Name
_FunctionInvocation_arguments = (String -> Name
Core.Name String
"arguments")

data QualifiedName = 
  QualifiedName {
    QualifiedName -> String
qualifiedNameNamespace :: String,
    QualifiedName -> String
qualifiedNameLocal :: String}
  deriving (QualifiedName -> QualifiedName -> Bool
(QualifiedName -> QualifiedName -> Bool)
-> (QualifiedName -> QualifiedName -> Bool) -> Eq QualifiedName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualifiedName -> QualifiedName -> Bool
== :: QualifiedName -> QualifiedName -> Bool
$c/= :: QualifiedName -> QualifiedName -> Bool
/= :: QualifiedName -> QualifiedName -> Bool
Eq, Eq QualifiedName
Eq QualifiedName =>
(QualifiedName -> QualifiedName -> Ordering)
-> (QualifiedName -> QualifiedName -> Bool)
-> (QualifiedName -> QualifiedName -> Bool)
-> (QualifiedName -> QualifiedName -> Bool)
-> (QualifiedName -> QualifiedName -> Bool)
-> (QualifiedName -> QualifiedName -> QualifiedName)
-> (QualifiedName -> QualifiedName -> QualifiedName)
-> Ord QualifiedName
QualifiedName -> QualifiedName -> Bool
QualifiedName -> QualifiedName -> Ordering
QualifiedName -> QualifiedName -> QualifiedName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: QualifiedName -> QualifiedName -> Ordering
compare :: QualifiedName -> QualifiedName -> Ordering
$c< :: QualifiedName -> QualifiedName -> Bool
< :: QualifiedName -> QualifiedName -> Bool
$c<= :: QualifiedName -> QualifiedName -> Bool
<= :: QualifiedName -> QualifiedName -> Bool
$c> :: QualifiedName -> QualifiedName -> Bool
> :: QualifiedName -> QualifiedName -> Bool
$c>= :: QualifiedName -> QualifiedName -> Bool
>= :: QualifiedName -> QualifiedName -> Bool
$cmax :: QualifiedName -> QualifiedName -> QualifiedName
max :: QualifiedName -> QualifiedName -> QualifiedName
$cmin :: QualifiedName -> QualifiedName -> QualifiedName
min :: QualifiedName -> QualifiedName -> QualifiedName
Ord, ReadPrec [QualifiedName]
ReadPrec QualifiedName
Int -> ReadS QualifiedName
ReadS [QualifiedName]
(Int -> ReadS QualifiedName)
-> ReadS [QualifiedName]
-> ReadPrec QualifiedName
-> ReadPrec [QualifiedName]
-> Read QualifiedName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS QualifiedName
readsPrec :: Int -> ReadS QualifiedName
$creadList :: ReadS [QualifiedName]
readList :: ReadS [QualifiedName]
$creadPrec :: ReadPrec QualifiedName
readPrec :: ReadPrec QualifiedName
$creadListPrec :: ReadPrec [QualifiedName]
readListPrec :: ReadPrec [QualifiedName]
Read, Int -> QualifiedName -> ShowS
[QualifiedName] -> ShowS
QualifiedName -> String
(Int -> QualifiedName -> ShowS)
-> (QualifiedName -> String)
-> ([QualifiedName] -> ShowS)
-> Show QualifiedName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QualifiedName -> ShowS
showsPrec :: Int -> QualifiedName -> ShowS
$cshow :: QualifiedName -> String
show :: QualifiedName -> String
$cshowList :: [QualifiedName] -> ShowS
showList :: [QualifiedName] -> ShowS
Show)

_QualifiedName :: Name
_QualifiedName = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.QualifiedName")

_QualifiedName_namespace :: Name
_QualifiedName_namespace = (String -> Name
Core.Name String
"namespace")

_QualifiedName_local :: Name
_QualifiedName_local = (String -> Name
Core.Name String
"local")

data PatternWhere = 
  PatternWhere {
    PatternWhere -> Pattern
patternWherePattern :: Pattern,
    PatternWhere -> Maybe Where
patternWhereWhere :: (Maybe Where)}
  deriving (PatternWhere -> PatternWhere -> Bool
(PatternWhere -> PatternWhere -> Bool)
-> (PatternWhere -> PatternWhere -> Bool) -> Eq PatternWhere
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PatternWhere -> PatternWhere -> Bool
== :: PatternWhere -> PatternWhere -> Bool
$c/= :: PatternWhere -> PatternWhere -> Bool
/= :: PatternWhere -> PatternWhere -> Bool
Eq, Eq PatternWhere
Eq PatternWhere =>
(PatternWhere -> PatternWhere -> Ordering)
-> (PatternWhere -> PatternWhere -> Bool)
-> (PatternWhere -> PatternWhere -> Bool)
-> (PatternWhere -> PatternWhere -> Bool)
-> (PatternWhere -> PatternWhere -> Bool)
-> (PatternWhere -> PatternWhere -> PatternWhere)
-> (PatternWhere -> PatternWhere -> PatternWhere)
-> Ord PatternWhere
PatternWhere -> PatternWhere -> Bool
PatternWhere -> PatternWhere -> Ordering
PatternWhere -> PatternWhere -> PatternWhere
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PatternWhere -> PatternWhere -> Ordering
compare :: PatternWhere -> PatternWhere -> Ordering
$c< :: PatternWhere -> PatternWhere -> Bool
< :: PatternWhere -> PatternWhere -> Bool
$c<= :: PatternWhere -> PatternWhere -> Bool
<= :: PatternWhere -> PatternWhere -> Bool
$c> :: PatternWhere -> PatternWhere -> Bool
> :: PatternWhere -> PatternWhere -> Bool
$c>= :: PatternWhere -> PatternWhere -> Bool
>= :: PatternWhere -> PatternWhere -> Bool
$cmax :: PatternWhere -> PatternWhere -> PatternWhere
max :: PatternWhere -> PatternWhere -> PatternWhere
$cmin :: PatternWhere -> PatternWhere -> PatternWhere
min :: PatternWhere -> PatternWhere -> PatternWhere
Ord, ReadPrec [PatternWhere]
ReadPrec PatternWhere
Int -> ReadS PatternWhere
ReadS [PatternWhere]
(Int -> ReadS PatternWhere)
-> ReadS [PatternWhere]
-> ReadPrec PatternWhere
-> ReadPrec [PatternWhere]
-> Read PatternWhere
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PatternWhere
readsPrec :: Int -> ReadS PatternWhere
$creadList :: ReadS [PatternWhere]
readList :: ReadS [PatternWhere]
$creadPrec :: ReadPrec PatternWhere
readPrec :: ReadPrec PatternWhere
$creadListPrec :: ReadPrec [PatternWhere]
readListPrec :: ReadPrec [PatternWhere]
Read, Int -> PatternWhere -> ShowS
[PatternWhere] -> ShowS
PatternWhere -> String
(Int -> PatternWhere -> ShowS)
-> (PatternWhere -> String)
-> ([PatternWhere] -> ShowS)
-> Show PatternWhere
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PatternWhere -> ShowS
showsPrec :: Int -> PatternWhere -> ShowS
$cshow :: PatternWhere -> String
show :: PatternWhere -> String
$cshowList :: [PatternWhere] -> ShowS
showList :: [PatternWhere] -> ShowS
Show)

_PatternWhere :: Name
_PatternWhere = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PatternWhere")

_PatternWhere_pattern :: Name
_PatternWhere_pattern = (String -> Name
Core.Name String
"pattern")

_PatternWhere_where :: Name
_PatternWhere_where = (String -> Name
Core.Name String
"where")

data ExistentialSubquery = 
  ExistentialSubqueryRegular RegularQuery |
  ExistentialSubqueryPattern PatternWhere
  deriving (ExistentialSubquery -> ExistentialSubquery -> Bool
(ExistentialSubquery -> ExistentialSubquery -> Bool)
-> (ExistentialSubquery -> ExistentialSubquery -> Bool)
-> Eq ExistentialSubquery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExistentialSubquery -> ExistentialSubquery -> Bool
== :: ExistentialSubquery -> ExistentialSubquery -> Bool
$c/= :: ExistentialSubquery -> ExistentialSubquery -> Bool
/= :: ExistentialSubquery -> ExistentialSubquery -> Bool
Eq, Eq ExistentialSubquery
Eq ExistentialSubquery =>
(ExistentialSubquery -> ExistentialSubquery -> Ordering)
-> (ExistentialSubquery -> ExistentialSubquery -> Bool)
-> (ExistentialSubquery -> ExistentialSubquery -> Bool)
-> (ExistentialSubquery -> ExistentialSubquery -> Bool)
-> (ExistentialSubquery -> ExistentialSubquery -> Bool)
-> (ExistentialSubquery
    -> ExistentialSubquery -> ExistentialSubquery)
-> (ExistentialSubquery
    -> ExistentialSubquery -> ExistentialSubquery)
-> Ord ExistentialSubquery
ExistentialSubquery -> ExistentialSubquery -> Bool
ExistentialSubquery -> ExistentialSubquery -> Ordering
ExistentialSubquery -> ExistentialSubquery -> ExistentialSubquery
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ExistentialSubquery -> ExistentialSubquery -> Ordering
compare :: ExistentialSubquery -> ExistentialSubquery -> Ordering
$c< :: ExistentialSubquery -> ExistentialSubquery -> Bool
< :: ExistentialSubquery -> ExistentialSubquery -> Bool
$c<= :: ExistentialSubquery -> ExistentialSubquery -> Bool
<= :: ExistentialSubquery -> ExistentialSubquery -> Bool
$c> :: ExistentialSubquery -> ExistentialSubquery -> Bool
> :: ExistentialSubquery -> ExistentialSubquery -> Bool
$c>= :: ExistentialSubquery -> ExistentialSubquery -> Bool
>= :: ExistentialSubquery -> ExistentialSubquery -> Bool
$cmax :: ExistentialSubquery -> ExistentialSubquery -> ExistentialSubquery
max :: ExistentialSubquery -> ExistentialSubquery -> ExistentialSubquery
$cmin :: ExistentialSubquery -> ExistentialSubquery -> ExistentialSubquery
min :: ExistentialSubquery -> ExistentialSubquery -> ExistentialSubquery
Ord, ReadPrec [ExistentialSubquery]
ReadPrec ExistentialSubquery
Int -> ReadS ExistentialSubquery
ReadS [ExistentialSubquery]
(Int -> ReadS ExistentialSubquery)
-> ReadS [ExistentialSubquery]
-> ReadPrec ExistentialSubquery
-> ReadPrec [ExistentialSubquery]
-> Read ExistentialSubquery
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExistentialSubquery
readsPrec :: Int -> ReadS ExistentialSubquery
$creadList :: ReadS [ExistentialSubquery]
readList :: ReadS [ExistentialSubquery]
$creadPrec :: ReadPrec ExistentialSubquery
readPrec :: ReadPrec ExistentialSubquery
$creadListPrec :: ReadPrec [ExistentialSubquery]
readListPrec :: ReadPrec [ExistentialSubquery]
Read, Int -> ExistentialSubquery -> ShowS
[ExistentialSubquery] -> ShowS
ExistentialSubquery -> String
(Int -> ExistentialSubquery -> ShowS)
-> (ExistentialSubquery -> String)
-> ([ExistentialSubquery] -> ShowS)
-> Show ExistentialSubquery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExistentialSubquery -> ShowS
showsPrec :: Int -> ExistentialSubquery -> ShowS
$cshow :: ExistentialSubquery -> String
show :: ExistentialSubquery -> String
$cshowList :: [ExistentialSubquery] -> ShowS
showList :: [ExistentialSubquery] -> ShowS
Show)

_ExistentialSubquery :: Name
_ExistentialSubquery = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ExistentialSubquery")

_ExistentialSubquery_regular :: Name
_ExistentialSubquery_regular = (String -> Name
Core.Name String
"regular")

_ExistentialSubquery_pattern :: Name
_ExistentialSubquery_pattern = (String -> Name
Core.Name String
"pattern")

data ExplicitProcedureInvocation = 
  ExplicitProcedureInvocation {
    ExplicitProcedureInvocation -> QualifiedName
explicitProcedureInvocationName :: QualifiedName,
    ExplicitProcedureInvocation -> [Expression]
explicitProcedureInvocationArguments :: [Expression]}
  deriving (ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
(ExplicitProcedureInvocation
 -> ExplicitProcedureInvocation -> Bool)
-> (ExplicitProcedureInvocation
    -> ExplicitProcedureInvocation -> Bool)
-> Eq ExplicitProcedureInvocation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
== :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
$c/= :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
/= :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
Eq, Eq ExplicitProcedureInvocation
Eq ExplicitProcedureInvocation =>
(ExplicitProcedureInvocation
 -> ExplicitProcedureInvocation -> Ordering)
-> (ExplicitProcedureInvocation
    -> ExplicitProcedureInvocation -> Bool)
-> (ExplicitProcedureInvocation
    -> ExplicitProcedureInvocation -> Bool)
-> (ExplicitProcedureInvocation
    -> ExplicitProcedureInvocation -> Bool)
-> (ExplicitProcedureInvocation
    -> ExplicitProcedureInvocation -> Bool)
-> (ExplicitProcedureInvocation
    -> ExplicitProcedureInvocation -> ExplicitProcedureInvocation)
-> (ExplicitProcedureInvocation
    -> ExplicitProcedureInvocation -> ExplicitProcedureInvocation)
-> Ord ExplicitProcedureInvocation
ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
ExplicitProcedureInvocation
-> ExplicitProcedureInvocation -> Ordering
ExplicitProcedureInvocation
-> ExplicitProcedureInvocation -> ExplicitProcedureInvocation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ExplicitProcedureInvocation
-> ExplicitProcedureInvocation -> Ordering
compare :: ExplicitProcedureInvocation
-> ExplicitProcedureInvocation -> Ordering
$c< :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
< :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
$c<= :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
<= :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
$c> :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
> :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
$c>= :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
>= :: ExplicitProcedureInvocation -> ExplicitProcedureInvocation -> Bool
$cmax :: ExplicitProcedureInvocation
-> ExplicitProcedureInvocation -> ExplicitProcedureInvocation
max :: ExplicitProcedureInvocation
-> ExplicitProcedureInvocation -> ExplicitProcedureInvocation
$cmin :: ExplicitProcedureInvocation
-> ExplicitProcedureInvocation -> ExplicitProcedureInvocation
min :: ExplicitProcedureInvocation
-> ExplicitProcedureInvocation -> ExplicitProcedureInvocation
Ord, ReadPrec [ExplicitProcedureInvocation]
ReadPrec ExplicitProcedureInvocation
Int -> ReadS ExplicitProcedureInvocation
ReadS [ExplicitProcedureInvocation]
(Int -> ReadS ExplicitProcedureInvocation)
-> ReadS [ExplicitProcedureInvocation]
-> ReadPrec ExplicitProcedureInvocation
-> ReadPrec [ExplicitProcedureInvocation]
-> Read ExplicitProcedureInvocation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExplicitProcedureInvocation
readsPrec :: Int -> ReadS ExplicitProcedureInvocation
$creadList :: ReadS [ExplicitProcedureInvocation]
readList :: ReadS [ExplicitProcedureInvocation]
$creadPrec :: ReadPrec ExplicitProcedureInvocation
readPrec :: ReadPrec ExplicitProcedureInvocation
$creadListPrec :: ReadPrec [ExplicitProcedureInvocation]
readListPrec :: ReadPrec [ExplicitProcedureInvocation]
Read, Int -> ExplicitProcedureInvocation -> ShowS
[ExplicitProcedureInvocation] -> ShowS
ExplicitProcedureInvocation -> String
(Int -> ExplicitProcedureInvocation -> ShowS)
-> (ExplicitProcedureInvocation -> String)
-> ([ExplicitProcedureInvocation] -> ShowS)
-> Show ExplicitProcedureInvocation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExplicitProcedureInvocation -> ShowS
showsPrec :: Int -> ExplicitProcedureInvocation -> ShowS
$cshow :: ExplicitProcedureInvocation -> String
show :: ExplicitProcedureInvocation -> String
$cshowList :: [ExplicitProcedureInvocation] -> ShowS
showList :: [ExplicitProcedureInvocation] -> ShowS
Show)

_ExplicitProcedureInvocation :: Name
_ExplicitProcedureInvocation = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ExplicitProcedureInvocation")

_ExplicitProcedureInvocation_name :: Name
_ExplicitProcedureInvocation_name = (String -> Name
Core.Name String
"name")

_ExplicitProcedureInvocation_arguments :: Name
_ExplicitProcedureInvocation_arguments = (String -> Name
Core.Name String
"arguments")

newtype ImplicitProcedureInvocation = 
  ImplicitProcedureInvocation {
    ImplicitProcedureInvocation -> QualifiedName
unImplicitProcedureInvocation :: QualifiedName}
  deriving (ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
(ImplicitProcedureInvocation
 -> ImplicitProcedureInvocation -> Bool)
-> (ImplicitProcedureInvocation
    -> ImplicitProcedureInvocation -> Bool)
-> Eq ImplicitProcedureInvocation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
== :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
$c/= :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
/= :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
Eq, Eq ImplicitProcedureInvocation
Eq ImplicitProcedureInvocation =>
(ImplicitProcedureInvocation
 -> ImplicitProcedureInvocation -> Ordering)
-> (ImplicitProcedureInvocation
    -> ImplicitProcedureInvocation -> Bool)
-> (ImplicitProcedureInvocation
    -> ImplicitProcedureInvocation -> Bool)
-> (ImplicitProcedureInvocation
    -> ImplicitProcedureInvocation -> Bool)
-> (ImplicitProcedureInvocation
    -> ImplicitProcedureInvocation -> Bool)
-> (ImplicitProcedureInvocation
    -> ImplicitProcedureInvocation -> ImplicitProcedureInvocation)
-> (ImplicitProcedureInvocation
    -> ImplicitProcedureInvocation -> ImplicitProcedureInvocation)
-> Ord ImplicitProcedureInvocation
ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
ImplicitProcedureInvocation
-> ImplicitProcedureInvocation -> Ordering
ImplicitProcedureInvocation
-> ImplicitProcedureInvocation -> ImplicitProcedureInvocation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ImplicitProcedureInvocation
-> ImplicitProcedureInvocation -> Ordering
compare :: ImplicitProcedureInvocation
-> ImplicitProcedureInvocation -> Ordering
$c< :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
< :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
$c<= :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
<= :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
$c> :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
> :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
$c>= :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
>= :: ImplicitProcedureInvocation -> ImplicitProcedureInvocation -> Bool
$cmax :: ImplicitProcedureInvocation
-> ImplicitProcedureInvocation -> ImplicitProcedureInvocation
max :: ImplicitProcedureInvocation
-> ImplicitProcedureInvocation -> ImplicitProcedureInvocation
$cmin :: ImplicitProcedureInvocation
-> ImplicitProcedureInvocation -> ImplicitProcedureInvocation
min :: ImplicitProcedureInvocation
-> ImplicitProcedureInvocation -> ImplicitProcedureInvocation
Ord, ReadPrec [ImplicitProcedureInvocation]
ReadPrec ImplicitProcedureInvocation
Int -> ReadS ImplicitProcedureInvocation
ReadS [ImplicitProcedureInvocation]
(Int -> ReadS ImplicitProcedureInvocation)
-> ReadS [ImplicitProcedureInvocation]
-> ReadPrec ImplicitProcedureInvocation
-> ReadPrec [ImplicitProcedureInvocation]
-> Read ImplicitProcedureInvocation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ImplicitProcedureInvocation
readsPrec :: Int -> ReadS ImplicitProcedureInvocation
$creadList :: ReadS [ImplicitProcedureInvocation]
readList :: ReadS [ImplicitProcedureInvocation]
$creadPrec :: ReadPrec ImplicitProcedureInvocation
readPrec :: ReadPrec ImplicitProcedureInvocation
$creadListPrec :: ReadPrec [ImplicitProcedureInvocation]
readListPrec :: ReadPrec [ImplicitProcedureInvocation]
Read, Int -> ImplicitProcedureInvocation -> ShowS
[ImplicitProcedureInvocation] -> ShowS
ImplicitProcedureInvocation -> String
(Int -> ImplicitProcedureInvocation -> ShowS)
-> (ImplicitProcedureInvocation -> String)
-> ([ImplicitProcedureInvocation] -> ShowS)
-> Show ImplicitProcedureInvocation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImplicitProcedureInvocation -> ShowS
showsPrec :: Int -> ImplicitProcedureInvocation -> ShowS
$cshow :: ImplicitProcedureInvocation -> String
show :: ImplicitProcedureInvocation -> String
$cshowList :: [ImplicitProcedureInvocation] -> ShowS
showList :: [ImplicitProcedureInvocation] -> ShowS
Show)

_ImplicitProcedureInvocation :: Name
_ImplicitProcedureInvocation = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ImplicitProcedureInvocation")

newtype ProcedureResultField = 
  ProcedureResultField {
    ProcedureResultField -> String
unProcedureResultField :: String}
  deriving (ProcedureResultField -> ProcedureResultField -> Bool
(ProcedureResultField -> ProcedureResultField -> Bool)
-> (ProcedureResultField -> ProcedureResultField -> Bool)
-> Eq ProcedureResultField
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProcedureResultField -> ProcedureResultField -> Bool
== :: ProcedureResultField -> ProcedureResultField -> Bool
$c/= :: ProcedureResultField -> ProcedureResultField -> Bool
/= :: ProcedureResultField -> ProcedureResultField -> Bool
Eq, Eq ProcedureResultField
Eq ProcedureResultField =>
(ProcedureResultField -> ProcedureResultField -> Ordering)
-> (ProcedureResultField -> ProcedureResultField -> Bool)
-> (ProcedureResultField -> ProcedureResultField -> Bool)
-> (ProcedureResultField -> ProcedureResultField -> Bool)
-> (ProcedureResultField -> ProcedureResultField -> Bool)
-> (ProcedureResultField
    -> ProcedureResultField -> ProcedureResultField)
-> (ProcedureResultField
    -> ProcedureResultField -> ProcedureResultField)
-> Ord ProcedureResultField
ProcedureResultField -> ProcedureResultField -> Bool
ProcedureResultField -> ProcedureResultField -> Ordering
ProcedureResultField
-> ProcedureResultField -> ProcedureResultField
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ProcedureResultField -> ProcedureResultField -> Ordering
compare :: ProcedureResultField -> ProcedureResultField -> Ordering
$c< :: ProcedureResultField -> ProcedureResultField -> Bool
< :: ProcedureResultField -> ProcedureResultField -> Bool
$c<= :: ProcedureResultField -> ProcedureResultField -> Bool
<= :: ProcedureResultField -> ProcedureResultField -> Bool
$c> :: ProcedureResultField -> ProcedureResultField -> Bool
> :: ProcedureResultField -> ProcedureResultField -> Bool
$c>= :: ProcedureResultField -> ProcedureResultField -> Bool
>= :: ProcedureResultField -> ProcedureResultField -> Bool
$cmax :: ProcedureResultField
-> ProcedureResultField -> ProcedureResultField
max :: ProcedureResultField
-> ProcedureResultField -> ProcedureResultField
$cmin :: ProcedureResultField
-> ProcedureResultField -> ProcedureResultField
min :: ProcedureResultField
-> ProcedureResultField -> ProcedureResultField
Ord, ReadPrec [ProcedureResultField]
ReadPrec ProcedureResultField
Int -> ReadS ProcedureResultField
ReadS [ProcedureResultField]
(Int -> ReadS ProcedureResultField)
-> ReadS [ProcedureResultField]
-> ReadPrec ProcedureResultField
-> ReadPrec [ProcedureResultField]
-> Read ProcedureResultField
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ProcedureResultField
readsPrec :: Int -> ReadS ProcedureResultField
$creadList :: ReadS [ProcedureResultField]
readList :: ReadS [ProcedureResultField]
$creadPrec :: ReadPrec ProcedureResultField
readPrec :: ReadPrec ProcedureResultField
$creadListPrec :: ReadPrec [ProcedureResultField]
readListPrec :: ReadPrec [ProcedureResultField]
Read, Int -> ProcedureResultField -> ShowS
[ProcedureResultField] -> ShowS
ProcedureResultField -> String
(Int -> ProcedureResultField -> ShowS)
-> (ProcedureResultField -> String)
-> ([ProcedureResultField] -> ShowS)
-> Show ProcedureResultField
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProcedureResultField -> ShowS
showsPrec :: Int -> ProcedureResultField -> ShowS
$cshow :: ProcedureResultField -> String
show :: ProcedureResultField -> String
$cshowList :: [ProcedureResultField] -> ShowS
showList :: [ProcedureResultField] -> ShowS
Show)

_ProcedureResultField :: Name
_ProcedureResultField = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ProcedureResultField")

newtype Variable = 
  Variable {
    Variable -> String
unVariable :: String}
  deriving (Variable -> Variable -> Bool
(Variable -> Variable -> Bool)
-> (Variable -> Variable -> Bool) -> Eq Variable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Variable -> Variable -> Bool
== :: Variable -> Variable -> Bool
$c/= :: Variable -> Variable -> Bool
/= :: Variable -> Variable -> Bool
Eq, Eq Variable
Eq Variable =>
(Variable -> Variable -> Ordering)
-> (Variable -> Variable -> Bool)
-> (Variable -> Variable -> Bool)
-> (Variable -> Variable -> Bool)
-> (Variable -> Variable -> Bool)
-> (Variable -> Variable -> Variable)
-> (Variable -> Variable -> Variable)
-> Ord Variable
Variable -> Variable -> Bool
Variable -> Variable -> Ordering
Variable -> Variable -> Variable
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Variable -> Variable -> Ordering
compare :: Variable -> Variable -> Ordering
$c< :: Variable -> Variable -> Bool
< :: Variable -> Variable -> Bool
$c<= :: Variable -> Variable -> Bool
<= :: Variable -> Variable -> Bool
$c> :: Variable -> Variable -> Bool
> :: Variable -> Variable -> Bool
$c>= :: Variable -> Variable -> Bool
>= :: Variable -> Variable -> Bool
$cmax :: Variable -> Variable -> Variable
max :: Variable -> Variable -> Variable
$cmin :: Variable -> Variable -> Variable
min :: Variable -> Variable -> Variable
Ord, ReadPrec [Variable]
ReadPrec Variable
Int -> ReadS Variable
ReadS [Variable]
(Int -> ReadS Variable)
-> ReadS [Variable]
-> ReadPrec Variable
-> ReadPrec [Variable]
-> Read Variable
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Variable
readsPrec :: Int -> ReadS Variable
$creadList :: ReadS [Variable]
readList :: ReadS [Variable]
$creadPrec :: ReadPrec Variable
readPrec :: ReadPrec Variable
$creadListPrec :: ReadPrec [Variable]
readListPrec :: ReadPrec [Variable]
Read, Int -> Variable -> ShowS
[Variable] -> ShowS
Variable -> String
(Int -> Variable -> ShowS)
-> (Variable -> String) -> ([Variable] -> ShowS) -> Show Variable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Variable -> ShowS
showsPrec :: Int -> Variable -> ShowS
$cshow :: Variable -> String
show :: Variable -> String
$cshowList :: [Variable] -> ShowS
showList :: [Variable] -> ShowS
Show)

_Variable :: Name
_Variable = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Variable")

data Literal = 
  LiteralBoolean Bool |
  LiteralNull  |
  LiteralNumber NumberLiteral |
  LiteralString StringLiteral |
  LiteralList ListLiteral |
  LiteralMap MapLiteral
  deriving (Literal -> Literal -> Bool
(Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool) -> Eq Literal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Literal -> Literal -> Bool
== :: Literal -> Literal -> Bool
$c/= :: Literal -> Literal -> Bool
/= :: Literal -> Literal -> Bool
Eq, Eq Literal
Eq Literal =>
(Literal -> Literal -> Ordering)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Literal)
-> (Literal -> Literal -> Literal)
-> Ord Literal
Literal -> Literal -> Bool
Literal -> Literal -> Ordering
Literal -> Literal -> Literal
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Literal -> Literal -> Ordering
compare :: Literal -> Literal -> Ordering
$c< :: Literal -> Literal -> Bool
< :: Literal -> Literal -> Bool
$c<= :: Literal -> Literal -> Bool
<= :: Literal -> Literal -> Bool
$c> :: Literal -> Literal -> Bool
> :: Literal -> Literal -> Bool
$c>= :: Literal -> Literal -> Bool
>= :: Literal -> Literal -> Bool
$cmax :: Literal -> Literal -> Literal
max :: Literal -> Literal -> Literal
$cmin :: Literal -> Literal -> Literal
min :: Literal -> Literal -> Literal
Ord, ReadPrec [Literal]
ReadPrec Literal
Int -> ReadS Literal
ReadS [Literal]
(Int -> ReadS Literal)
-> ReadS [Literal]
-> ReadPrec Literal
-> ReadPrec [Literal]
-> Read Literal
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Literal
readsPrec :: Int -> ReadS Literal
$creadList :: ReadS [Literal]
readList :: ReadS [Literal]
$creadPrec :: ReadPrec Literal
readPrec :: ReadPrec Literal
$creadListPrec :: ReadPrec [Literal]
readListPrec :: ReadPrec [Literal]
Read, Int -> Literal -> ShowS
[Literal] -> ShowS
Literal -> String
(Int -> Literal -> ShowS)
-> (Literal -> String) -> ([Literal] -> ShowS) -> Show Literal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Literal -> ShowS
showsPrec :: Int -> Literal -> ShowS
$cshow :: Literal -> String
show :: Literal -> String
$cshowList :: [Literal] -> ShowS
showList :: [Literal] -> ShowS
Show)

_Literal :: Name
_Literal = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Literal")

_Literal_boolean :: Name
_Literal_boolean = (String -> Name
Core.Name String
"boolean")

_Literal_null :: Name
_Literal_null = (String -> Name
Core.Name String
"null")

_Literal_number :: Name
_Literal_number = (String -> Name
Core.Name String
"number")

_Literal_string :: Name
_Literal_string = (String -> Name
Core.Name String
"string")

_Literal_list :: Name
_Literal_list = (String -> Name
Core.Name String
"list")

_Literal_map :: Name
_Literal_map = (String -> Name
Core.Name String
"map")

data NumberLiteral = 
  NumberLiteralDouble Double |
  NumberLiteralInteger Integer
  deriving (NumberLiteral -> NumberLiteral -> Bool
(NumberLiteral -> NumberLiteral -> Bool)
-> (NumberLiteral -> NumberLiteral -> Bool) -> Eq NumberLiteral
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NumberLiteral -> NumberLiteral -> Bool
== :: NumberLiteral -> NumberLiteral -> Bool
$c/= :: NumberLiteral -> NumberLiteral -> Bool
/= :: NumberLiteral -> NumberLiteral -> Bool
Eq, Eq NumberLiteral
Eq NumberLiteral =>
(NumberLiteral -> NumberLiteral -> Ordering)
-> (NumberLiteral -> NumberLiteral -> Bool)
-> (NumberLiteral -> NumberLiteral -> Bool)
-> (NumberLiteral -> NumberLiteral -> Bool)
-> (NumberLiteral -> NumberLiteral -> Bool)
-> (NumberLiteral -> NumberLiteral -> NumberLiteral)
-> (NumberLiteral -> NumberLiteral -> NumberLiteral)
-> Ord NumberLiteral
NumberLiteral -> NumberLiteral -> Bool
NumberLiteral -> NumberLiteral -> Ordering
NumberLiteral -> NumberLiteral -> NumberLiteral
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NumberLiteral -> NumberLiteral -> Ordering
compare :: NumberLiteral -> NumberLiteral -> Ordering
$c< :: NumberLiteral -> NumberLiteral -> Bool
< :: NumberLiteral -> NumberLiteral -> Bool
$c<= :: NumberLiteral -> NumberLiteral -> Bool
<= :: NumberLiteral -> NumberLiteral -> Bool
$c> :: NumberLiteral -> NumberLiteral -> Bool
> :: NumberLiteral -> NumberLiteral -> Bool
$c>= :: NumberLiteral -> NumberLiteral -> Bool
>= :: NumberLiteral -> NumberLiteral -> Bool
$cmax :: NumberLiteral -> NumberLiteral -> NumberLiteral
max :: NumberLiteral -> NumberLiteral -> NumberLiteral
$cmin :: NumberLiteral -> NumberLiteral -> NumberLiteral
min :: NumberLiteral -> NumberLiteral -> NumberLiteral
Ord, ReadPrec [NumberLiteral]
ReadPrec NumberLiteral
Int -> ReadS NumberLiteral
ReadS [NumberLiteral]
(Int -> ReadS NumberLiteral)
-> ReadS [NumberLiteral]
-> ReadPrec NumberLiteral
-> ReadPrec [NumberLiteral]
-> Read NumberLiteral
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NumberLiteral
readsPrec :: Int -> ReadS NumberLiteral
$creadList :: ReadS [NumberLiteral]
readList :: ReadS [NumberLiteral]
$creadPrec :: ReadPrec NumberLiteral
readPrec :: ReadPrec NumberLiteral
$creadListPrec :: ReadPrec [NumberLiteral]
readListPrec :: ReadPrec [NumberLiteral]
Read, Int -> NumberLiteral -> ShowS
[NumberLiteral] -> ShowS
NumberLiteral -> String
(Int -> NumberLiteral -> ShowS)
-> (NumberLiteral -> String)
-> ([NumberLiteral] -> ShowS)
-> Show NumberLiteral
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NumberLiteral -> ShowS
showsPrec :: Int -> NumberLiteral -> ShowS
$cshow :: NumberLiteral -> String
show :: NumberLiteral -> String
$cshowList :: [NumberLiteral] -> ShowS
showList :: [NumberLiteral] -> ShowS
Show)

_NumberLiteral :: Name
_NumberLiteral = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.NumberLiteral")

_NumberLiteral_double :: Name
_NumberLiteral_double = (String -> Name
Core.Name String
"double")

_NumberLiteral_integer :: Name
_NumberLiteral_integer = (String -> Name
Core.Name String
"integer")

newtype StringLiteral = 
  StringLiteral {
    StringLiteral -> String
unStringLiteral :: String}
  deriving (StringLiteral -> StringLiteral -> Bool
(StringLiteral -> StringLiteral -> Bool)
-> (StringLiteral -> StringLiteral -> Bool) -> Eq StringLiteral
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StringLiteral -> StringLiteral -> Bool
== :: StringLiteral -> StringLiteral -> Bool
$c/= :: StringLiteral -> StringLiteral -> Bool
/= :: StringLiteral -> StringLiteral -> Bool
Eq, Eq StringLiteral
Eq StringLiteral =>
(StringLiteral -> StringLiteral -> Ordering)
-> (StringLiteral -> StringLiteral -> Bool)
-> (StringLiteral -> StringLiteral -> Bool)
-> (StringLiteral -> StringLiteral -> Bool)
-> (StringLiteral -> StringLiteral -> Bool)
-> (StringLiteral -> StringLiteral -> StringLiteral)
-> (StringLiteral -> StringLiteral -> StringLiteral)
-> Ord StringLiteral
StringLiteral -> StringLiteral -> Bool
StringLiteral -> StringLiteral -> Ordering
StringLiteral -> StringLiteral -> StringLiteral
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StringLiteral -> StringLiteral -> Ordering
compare :: StringLiteral -> StringLiteral -> Ordering
$c< :: StringLiteral -> StringLiteral -> Bool
< :: StringLiteral -> StringLiteral -> Bool
$c<= :: StringLiteral -> StringLiteral -> Bool
<= :: StringLiteral -> StringLiteral -> Bool
$c> :: StringLiteral -> StringLiteral -> Bool
> :: StringLiteral -> StringLiteral -> Bool
$c>= :: StringLiteral -> StringLiteral -> Bool
>= :: StringLiteral -> StringLiteral -> Bool
$cmax :: StringLiteral -> StringLiteral -> StringLiteral
max :: StringLiteral -> StringLiteral -> StringLiteral
$cmin :: StringLiteral -> StringLiteral -> StringLiteral
min :: StringLiteral -> StringLiteral -> StringLiteral
Ord, ReadPrec [StringLiteral]
ReadPrec StringLiteral
Int -> ReadS StringLiteral
ReadS [StringLiteral]
(Int -> ReadS StringLiteral)
-> ReadS [StringLiteral]
-> ReadPrec StringLiteral
-> ReadPrec [StringLiteral]
-> Read StringLiteral
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StringLiteral
readsPrec :: Int -> ReadS StringLiteral
$creadList :: ReadS [StringLiteral]
readList :: ReadS [StringLiteral]
$creadPrec :: ReadPrec StringLiteral
readPrec :: ReadPrec StringLiteral
$creadListPrec :: ReadPrec [StringLiteral]
readListPrec :: ReadPrec [StringLiteral]
Read, Int -> StringLiteral -> ShowS
[StringLiteral] -> ShowS
StringLiteral -> String
(Int -> StringLiteral -> ShowS)
-> (StringLiteral -> String)
-> ([StringLiteral] -> ShowS)
-> Show StringLiteral
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StringLiteral -> ShowS
showsPrec :: Int -> StringLiteral -> ShowS
$cshow :: StringLiteral -> String
show :: StringLiteral -> String
$cshowList :: [StringLiteral] -> ShowS
showList :: [StringLiteral] -> ShowS
Show)

_StringLiteral :: Name
_StringLiteral = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.StringLiteral")

newtype ListLiteral = 
  ListLiteral {
    ListLiteral -> [Expression]
unListLiteral :: [Expression]}
  deriving (ListLiteral -> ListLiteral -> Bool
(ListLiteral -> ListLiteral -> Bool)
-> (ListLiteral -> ListLiteral -> Bool) -> Eq ListLiteral
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListLiteral -> ListLiteral -> Bool
== :: ListLiteral -> ListLiteral -> Bool
$c/= :: ListLiteral -> ListLiteral -> Bool
/= :: ListLiteral -> ListLiteral -> Bool
Eq, Eq ListLiteral
Eq ListLiteral =>
(ListLiteral -> ListLiteral -> Ordering)
-> (ListLiteral -> ListLiteral -> Bool)
-> (ListLiteral -> ListLiteral -> Bool)
-> (ListLiteral -> ListLiteral -> Bool)
-> (ListLiteral -> ListLiteral -> Bool)
-> (ListLiteral -> ListLiteral -> ListLiteral)
-> (ListLiteral -> ListLiteral -> ListLiteral)
-> Ord ListLiteral
ListLiteral -> ListLiteral -> Bool
ListLiteral -> ListLiteral -> Ordering
ListLiteral -> ListLiteral -> ListLiteral
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ListLiteral -> ListLiteral -> Ordering
compare :: ListLiteral -> ListLiteral -> Ordering
$c< :: ListLiteral -> ListLiteral -> Bool
< :: ListLiteral -> ListLiteral -> Bool
$c<= :: ListLiteral -> ListLiteral -> Bool
<= :: ListLiteral -> ListLiteral -> Bool
$c> :: ListLiteral -> ListLiteral -> Bool
> :: ListLiteral -> ListLiteral -> Bool
$c>= :: ListLiteral -> ListLiteral -> Bool
>= :: ListLiteral -> ListLiteral -> Bool
$cmax :: ListLiteral -> ListLiteral -> ListLiteral
max :: ListLiteral -> ListLiteral -> ListLiteral
$cmin :: ListLiteral -> ListLiteral -> ListLiteral
min :: ListLiteral -> ListLiteral -> ListLiteral
Ord, ReadPrec [ListLiteral]
ReadPrec ListLiteral
Int -> ReadS ListLiteral
ReadS [ListLiteral]
(Int -> ReadS ListLiteral)
-> ReadS [ListLiteral]
-> ReadPrec ListLiteral
-> ReadPrec [ListLiteral]
-> Read ListLiteral
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ListLiteral
readsPrec :: Int -> ReadS ListLiteral
$creadList :: ReadS [ListLiteral]
readList :: ReadS [ListLiteral]
$creadPrec :: ReadPrec ListLiteral
readPrec :: ReadPrec ListLiteral
$creadListPrec :: ReadPrec [ListLiteral]
readListPrec :: ReadPrec [ListLiteral]
Read, Int -> ListLiteral -> ShowS
[ListLiteral] -> ShowS
ListLiteral -> String
(Int -> ListLiteral -> ShowS)
-> (ListLiteral -> String)
-> ([ListLiteral] -> ShowS)
-> Show ListLiteral
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListLiteral -> ShowS
showsPrec :: Int -> ListLiteral -> ShowS
$cshow :: ListLiteral -> String
show :: ListLiteral -> String
$cshowList :: [ListLiteral] -> ShowS
showList :: [ListLiteral] -> ShowS
Show)

_ListLiteral :: Name
_ListLiteral = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.ListLiteral")

newtype MapLiteral = 
  MapLiteral {
    MapLiteral -> [KeyValuePair]
unMapLiteral :: [KeyValuePair]}
  deriving (MapLiteral -> MapLiteral -> Bool
(MapLiteral -> MapLiteral -> Bool)
-> (MapLiteral -> MapLiteral -> Bool) -> Eq MapLiteral
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MapLiteral -> MapLiteral -> Bool
== :: MapLiteral -> MapLiteral -> Bool
$c/= :: MapLiteral -> MapLiteral -> Bool
/= :: MapLiteral -> MapLiteral -> Bool
Eq, Eq MapLiteral
Eq MapLiteral =>
(MapLiteral -> MapLiteral -> Ordering)
-> (MapLiteral -> MapLiteral -> Bool)
-> (MapLiteral -> MapLiteral -> Bool)
-> (MapLiteral -> MapLiteral -> Bool)
-> (MapLiteral -> MapLiteral -> Bool)
-> (MapLiteral -> MapLiteral -> MapLiteral)
-> (MapLiteral -> MapLiteral -> MapLiteral)
-> Ord MapLiteral
MapLiteral -> MapLiteral -> Bool
MapLiteral -> MapLiteral -> Ordering
MapLiteral -> MapLiteral -> MapLiteral
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MapLiteral -> MapLiteral -> Ordering
compare :: MapLiteral -> MapLiteral -> Ordering
$c< :: MapLiteral -> MapLiteral -> Bool
< :: MapLiteral -> MapLiteral -> Bool
$c<= :: MapLiteral -> MapLiteral -> Bool
<= :: MapLiteral -> MapLiteral -> Bool
$c> :: MapLiteral -> MapLiteral -> Bool
> :: MapLiteral -> MapLiteral -> Bool
$c>= :: MapLiteral -> MapLiteral -> Bool
>= :: MapLiteral -> MapLiteral -> Bool
$cmax :: MapLiteral -> MapLiteral -> MapLiteral
max :: MapLiteral -> MapLiteral -> MapLiteral
$cmin :: MapLiteral -> MapLiteral -> MapLiteral
min :: MapLiteral -> MapLiteral -> MapLiteral
Ord, ReadPrec [MapLiteral]
ReadPrec MapLiteral
Int -> ReadS MapLiteral
ReadS [MapLiteral]
(Int -> ReadS MapLiteral)
-> ReadS [MapLiteral]
-> ReadPrec MapLiteral
-> ReadPrec [MapLiteral]
-> Read MapLiteral
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MapLiteral
readsPrec :: Int -> ReadS MapLiteral
$creadList :: ReadS [MapLiteral]
readList :: ReadS [MapLiteral]
$creadPrec :: ReadPrec MapLiteral
readPrec :: ReadPrec MapLiteral
$creadListPrec :: ReadPrec [MapLiteral]
readListPrec :: ReadPrec [MapLiteral]
Read, Int -> MapLiteral -> ShowS
[MapLiteral] -> ShowS
MapLiteral -> String
(Int -> MapLiteral -> ShowS)
-> (MapLiteral -> String)
-> ([MapLiteral] -> ShowS)
-> Show MapLiteral
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MapLiteral -> ShowS
showsPrec :: Int -> MapLiteral -> ShowS
$cshow :: MapLiteral -> String
show :: MapLiteral -> String
$cshowList :: [MapLiteral] -> ShowS
showList :: [MapLiteral] -> ShowS
Show)

_MapLiteral :: Name
_MapLiteral = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.MapLiteral")

data KeyValuePair = 
  KeyValuePair {
    KeyValuePair -> PropertyKeyName
keyValuePairKey :: PropertyKeyName,
    KeyValuePair -> Expression
keyValuePairValue :: Expression}
  deriving (KeyValuePair -> KeyValuePair -> Bool
(KeyValuePair -> KeyValuePair -> Bool)
-> (KeyValuePair -> KeyValuePair -> Bool) -> Eq KeyValuePair
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyValuePair -> KeyValuePair -> Bool
== :: KeyValuePair -> KeyValuePair -> Bool
$c/= :: KeyValuePair -> KeyValuePair -> Bool
/= :: KeyValuePair -> KeyValuePair -> Bool
Eq, Eq KeyValuePair
Eq KeyValuePair =>
(KeyValuePair -> KeyValuePair -> Ordering)
-> (KeyValuePair -> KeyValuePair -> Bool)
-> (KeyValuePair -> KeyValuePair -> Bool)
-> (KeyValuePair -> KeyValuePair -> Bool)
-> (KeyValuePair -> KeyValuePair -> Bool)
-> (KeyValuePair -> KeyValuePair -> KeyValuePair)
-> (KeyValuePair -> KeyValuePair -> KeyValuePair)
-> Ord KeyValuePair
KeyValuePair -> KeyValuePair -> Bool
KeyValuePair -> KeyValuePair -> Ordering
KeyValuePair -> KeyValuePair -> KeyValuePair
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: KeyValuePair -> KeyValuePair -> Ordering
compare :: KeyValuePair -> KeyValuePair -> Ordering
$c< :: KeyValuePair -> KeyValuePair -> Bool
< :: KeyValuePair -> KeyValuePair -> Bool
$c<= :: KeyValuePair -> KeyValuePair -> Bool
<= :: KeyValuePair -> KeyValuePair -> Bool
$c> :: KeyValuePair -> KeyValuePair -> Bool
> :: KeyValuePair -> KeyValuePair -> Bool
$c>= :: KeyValuePair -> KeyValuePair -> Bool
>= :: KeyValuePair -> KeyValuePair -> Bool
$cmax :: KeyValuePair -> KeyValuePair -> KeyValuePair
max :: KeyValuePair -> KeyValuePair -> KeyValuePair
$cmin :: KeyValuePair -> KeyValuePair -> KeyValuePair
min :: KeyValuePair -> KeyValuePair -> KeyValuePair
Ord, ReadPrec [KeyValuePair]
ReadPrec KeyValuePair
Int -> ReadS KeyValuePair
ReadS [KeyValuePair]
(Int -> ReadS KeyValuePair)
-> ReadS [KeyValuePair]
-> ReadPrec KeyValuePair
-> ReadPrec [KeyValuePair]
-> Read KeyValuePair
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS KeyValuePair
readsPrec :: Int -> ReadS KeyValuePair
$creadList :: ReadS [KeyValuePair]
readList :: ReadS [KeyValuePair]
$creadPrec :: ReadPrec KeyValuePair
readPrec :: ReadPrec KeyValuePair
$creadListPrec :: ReadPrec [KeyValuePair]
readListPrec :: ReadPrec [KeyValuePair]
Read, Int -> KeyValuePair -> ShowS
[KeyValuePair] -> ShowS
KeyValuePair -> String
(Int -> KeyValuePair -> ShowS)
-> (KeyValuePair -> String)
-> ([KeyValuePair] -> ShowS)
-> Show KeyValuePair
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyValuePair -> ShowS
showsPrec :: Int -> KeyValuePair -> ShowS
$cshow :: KeyValuePair -> String
show :: KeyValuePair -> String
$cshowList :: [KeyValuePair] -> ShowS
showList :: [KeyValuePair] -> ShowS
Show)

_KeyValuePair :: Name
_KeyValuePair = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.KeyValuePair")

_KeyValuePair_key :: Name
_KeyValuePair_key = (String -> Name
Core.Name String
"key")

_KeyValuePair_value :: Name
_KeyValuePair_value = (String -> Name
Core.Name String
"value")

newtype PropertyKeyName = 
  PropertyKeyName {
    PropertyKeyName -> String
unPropertyKeyName :: String}
  deriving (PropertyKeyName -> PropertyKeyName -> Bool
(PropertyKeyName -> PropertyKeyName -> Bool)
-> (PropertyKeyName -> PropertyKeyName -> Bool)
-> Eq PropertyKeyName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PropertyKeyName -> PropertyKeyName -> Bool
== :: PropertyKeyName -> PropertyKeyName -> Bool
$c/= :: PropertyKeyName -> PropertyKeyName -> Bool
/= :: PropertyKeyName -> PropertyKeyName -> Bool
Eq, Eq PropertyKeyName
Eq PropertyKeyName =>
(PropertyKeyName -> PropertyKeyName -> Ordering)
-> (PropertyKeyName -> PropertyKeyName -> Bool)
-> (PropertyKeyName -> PropertyKeyName -> Bool)
-> (PropertyKeyName -> PropertyKeyName -> Bool)
-> (PropertyKeyName -> PropertyKeyName -> Bool)
-> (PropertyKeyName -> PropertyKeyName -> PropertyKeyName)
-> (PropertyKeyName -> PropertyKeyName -> PropertyKeyName)
-> Ord PropertyKeyName
PropertyKeyName -> PropertyKeyName -> Bool
PropertyKeyName -> PropertyKeyName -> Ordering
PropertyKeyName -> PropertyKeyName -> PropertyKeyName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PropertyKeyName -> PropertyKeyName -> Ordering
compare :: PropertyKeyName -> PropertyKeyName -> Ordering
$c< :: PropertyKeyName -> PropertyKeyName -> Bool
< :: PropertyKeyName -> PropertyKeyName -> Bool
$c<= :: PropertyKeyName -> PropertyKeyName -> Bool
<= :: PropertyKeyName -> PropertyKeyName -> Bool
$c> :: PropertyKeyName -> PropertyKeyName -> Bool
> :: PropertyKeyName -> PropertyKeyName -> Bool
$c>= :: PropertyKeyName -> PropertyKeyName -> Bool
>= :: PropertyKeyName -> PropertyKeyName -> Bool
$cmax :: PropertyKeyName -> PropertyKeyName -> PropertyKeyName
max :: PropertyKeyName -> PropertyKeyName -> PropertyKeyName
$cmin :: PropertyKeyName -> PropertyKeyName -> PropertyKeyName
min :: PropertyKeyName -> PropertyKeyName -> PropertyKeyName
Ord, ReadPrec [PropertyKeyName]
ReadPrec PropertyKeyName
Int -> ReadS PropertyKeyName
ReadS [PropertyKeyName]
(Int -> ReadS PropertyKeyName)
-> ReadS [PropertyKeyName]
-> ReadPrec PropertyKeyName
-> ReadPrec [PropertyKeyName]
-> Read PropertyKeyName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PropertyKeyName
readsPrec :: Int -> ReadS PropertyKeyName
$creadList :: ReadS [PropertyKeyName]
readList :: ReadS [PropertyKeyName]
$creadPrec :: ReadPrec PropertyKeyName
readPrec :: ReadPrec PropertyKeyName
$creadListPrec :: ReadPrec [PropertyKeyName]
readListPrec :: ReadPrec [PropertyKeyName]
Read, Int -> PropertyKeyName -> ShowS
[PropertyKeyName] -> ShowS
PropertyKeyName -> String
(Int -> PropertyKeyName -> ShowS)
-> (PropertyKeyName -> String)
-> ([PropertyKeyName] -> ShowS)
-> Show PropertyKeyName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PropertyKeyName -> ShowS
showsPrec :: Int -> PropertyKeyName -> ShowS
$cshow :: PropertyKeyName -> String
show :: PropertyKeyName -> String
$cshowList :: [PropertyKeyName] -> ShowS
showList :: [PropertyKeyName] -> ShowS
Show)

_PropertyKeyName :: Name
_PropertyKeyName = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.PropertyKeyName")

data Parameter = 
  ParameterSymbolic String |
  ParameterInteger Integer
  deriving (Parameter -> Parameter -> Bool
(Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Bool) -> Eq Parameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Parameter -> Parameter -> Bool
== :: Parameter -> Parameter -> Bool
$c/= :: Parameter -> Parameter -> Bool
/= :: Parameter -> Parameter -> Bool
Eq, Eq Parameter
Eq Parameter =>
(Parameter -> Parameter -> Ordering)
-> (Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Parameter)
-> (Parameter -> Parameter -> Parameter)
-> Ord Parameter
Parameter -> Parameter -> Bool
Parameter -> Parameter -> Ordering
Parameter -> Parameter -> Parameter
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Parameter -> Parameter -> Ordering
compare :: Parameter -> Parameter -> Ordering
$c< :: Parameter -> Parameter -> Bool
< :: Parameter -> Parameter -> Bool
$c<= :: Parameter -> Parameter -> Bool
<= :: Parameter -> Parameter -> Bool
$c> :: Parameter -> Parameter -> Bool
> :: Parameter -> Parameter -> Bool
$c>= :: Parameter -> Parameter -> Bool
>= :: Parameter -> Parameter -> Bool
$cmax :: Parameter -> Parameter -> Parameter
max :: Parameter -> Parameter -> Parameter
$cmin :: Parameter -> Parameter -> Parameter
min :: Parameter -> Parameter -> Parameter
Ord, ReadPrec [Parameter]
ReadPrec Parameter
Int -> ReadS Parameter
ReadS [Parameter]
(Int -> ReadS Parameter)
-> ReadS [Parameter]
-> ReadPrec Parameter
-> ReadPrec [Parameter]
-> Read Parameter
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Parameter
readsPrec :: Int -> ReadS Parameter
$creadList :: ReadS [Parameter]
readList :: ReadS [Parameter]
$creadPrec :: ReadPrec Parameter
readPrec :: ReadPrec Parameter
$creadListPrec :: ReadPrec [Parameter]
readListPrec :: ReadPrec [Parameter]
Read, Int -> Parameter -> ShowS
[Parameter] -> ShowS
Parameter -> String
(Int -> Parameter -> ShowS)
-> (Parameter -> String)
-> ([Parameter] -> ShowS)
-> Show Parameter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Parameter -> ShowS
showsPrec :: Int -> Parameter -> ShowS
$cshow :: Parameter -> String
show :: Parameter -> String
$cshowList :: [Parameter] -> ShowS
showList :: [Parameter] -> ShowS
Show)

_Parameter :: Name
_Parameter = (String -> Name
Core.Name String
"hydra/langs/cypher/openCypher.Parameter")

_Parameter_symbolic :: Name
_Parameter_symbolic = (String -> Name
Core.Name String
"symbolic")

_Parameter_integer :: Name
_Parameter_integer = (String -> Name
Core.Name String
"integer")