{-# LANGUAGE OverloadedStrings #-}

module Hydra.Sources.Tier4.Langs.Tinkerpop.Gremlin where

import Hydra.Sources.Tier3.All
import Hydra.Dsl.Annotations
import Hydra.Dsl.Bootstrap
import Hydra.Dsl.Types as Types

import Hydra.Sources.Core


gremlinModule :: Module
gremlinModule :: Module
gremlinModule = Namespace
-> [Element] -> [Module] -> [Module] -> Maybe [Char] -> Module
Module Namespace
ns [Element]
elements [Module
hydraCoreModule] [Module]
tier0Modules (Maybe [Char] -> Module) -> Maybe [Char] -> Module
forall a b. (a -> b) -> a -> b
$
    [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just ([Char]
"A Gremlin model, based on the Gremlin ANTLR grammar "
      [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"(master branch, as of 2024-06-30).")
  where
    ns :: Namespace
ns = [Char] -> Namespace
Namespace [Char]
"hydra/langs/tinkerpop/gremlin"
    gremlin :: [Char] -> Type
gremlin = Namespace -> [Char] -> Type
typeref Namespace
ns
    def :: [Char] -> Type -> Element
def = Namespace -> [Char] -> Type -> Element
datatype Namespace
ns

    defArgument :: [Char] -> Type -> Element
defArgument [Char]
name Type
typ =  [Char] -> Type -> Element
def [Char]
name (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
      [Char]
"value"[Char] -> Type -> FieldType
>: Type
typ,
      [Char]
"variable"[Char] -> Type -> FieldType
>: Type
variable]

    booleanLiteral :: Type
booleanLiteral = Type
boolean
    booleanArgument :: Type
booleanArgument = [Char] -> Type
gremlin [Char]
"BooleanArgument"
    classType :: Type
classType = Type
identifier
    dateArgument :: Type
dateArgument = [Char] -> Type
gremlin [Char]
"DateArgument"
    dateLiteral :: Type
dateLiteral = [Char] -> Type
gremlin [Char]
"DateLiteral"
    floatArgument :: Type
floatArgument = [Char] -> Type
gremlin [Char]
"FloatArgument"
    floatLiteral :: Type
floatLiteral = [Char] -> Type
gremlin [Char]
"FloatLiteral"
    genericLiteral :: Type
genericLiteral = [Char] -> Type
gremlin [Char]
"GenericLiteral"
    genericLiteralArgument :: Type
genericLiteralArgument = [Char] -> Type
gremlin [Char]
"GenericLiteralArgument"
    genericLiteralCollection :: Type
genericLiteralCollection = [Char] -> Type
gremlin [Char]
"GenericLiteralCollection"
    genericLiteralList :: Type
genericLiteralList = [Char] -> Type
gremlin [Char]
"GenericLiteralList"
    genericLiteralMap :: Type
genericLiteralMap = [Char] -> Type
gremlin [Char]
"GenericLiteralMap"
    genericLiteralMapArgument :: Type
genericLiteralMapArgument = [Char] -> Type
gremlin [Char]
"GenericLiteralMapArgument"
    genericLiteralMapNullableArgument :: Type
genericLiteralMapNullableArgument = [Char] -> Type
gremlin [Char]
"GenericLiteralMapNullableArgument"
    genericLiteralRange :: Type
genericLiteralRange = [Char] -> Type
gremlin [Char]
"GenericLiteralRange"
    genericLiteralSet :: Type
genericLiteralSet = [Char] -> Type
gremlin [Char]
"GenericLiteralSet"
    genericLiteralVarargs :: Type
genericLiteralVarargs = Type -> Type
nonemptyList Type
genericLiteralArgument
    identifier :: Type
identifier = [Char] -> Type
gremlin [Char]
"Identifier"
    integerArgument :: Type
integerArgument = [Char] -> Type
gremlin [Char]
"IntegerArgument"
    integerLiteral :: Type
integerLiteral = [Char] -> Type
gremlin [Char]
"IntegerLiteral"
    keyword :: Type
keyword = [Char] -> Type
gremlin [Char]
"Keyword"
    nestedTraversal :: Type
nestedTraversal = [Char] -> Type
gremlin [Char]
"NestedTraversal"
    nestedTraversalList :: Type
nestedTraversalList = Type -> Type
list Type
nestedTraversal
    numericLiteral :: Type
numericLiteral = [Char] -> Type
gremlin [Char]
"NumericLiteral"
    optionalGenericLiteralVarargs :: Type
optionalGenericLiteralVarargs = Type -> Type
list Type
genericLiteralArgument
    optionalStringLiteralVarargs :: Type
optionalStringLiteralVarargs = Type -> Type
list Type
stringNullableArgument
    stringArgument :: Type
stringArgument = [Char] -> Type
gremlin [Char]
"StringArgument"
    stringLiteral :: Type
stringLiteral = Type
string
    stringLiteralVarargs :: Type
stringLiteralVarargs = Type -> Type
nonemptyList Type
stringNullableArgument
    stringNullableArgument :: Type
stringNullableArgument = [Char] -> Type
gremlin [Char]
"StringNullableArgument"
    stringNullableLiteral :: Type
stringNullableLiteral = Type -> Type
optional Type
stringLiteral
    structureVertex :: Type
structureVertex = [Char] -> Type
gremlin [Char]
"StructureVertex"
    structureVertexArgument :: Type
structureVertexArgument = [Char] -> Type
gremlin [Char]
"StructureVertexArgument"
    terminatedTraversal :: Type
terminatedTraversal = [Char] -> Type
gremlin [Char]
"TerminatedTraversal"
    traversalBarrier :: Type
traversalBarrier = Type
unit
    traversalBiFunctionArgument :: Type
traversalBiFunctionArgument = [Char] -> Type
gremlin [Char]
"TraversalBiFunctionArgument"
    traversalCardinality :: Type
traversalCardinality = [Char] -> Type
gremlin [Char]
"TraversalCardinality"
    traversalCardinalityArgument :: Type
traversalCardinalityArgument = [Char] -> Type
gremlin [Char]
"TraversalCardinalityArgument"
    traversalColumn :: Type
traversalColumn = [Char] -> Type
gremlin [Char]
"TraversalColumn"
    traversalColumnArgument :: Type
traversalColumnArgument = [Char] -> Type
gremlin [Char]
"TraversalColumnArgument"
    traversalComparator :: Type
traversalComparator = Type
traversalOrder
    traversalComparatorArgument :: Type
traversalComparatorArgument = [Char] -> Type
gremlin [Char]
"TraversalComparatorArgument"
    traversalDT :: Type
traversalDT = [Char] -> Type
gremlin [Char]
"TraversalDT"
    traversalDirection :: Type
traversalDirection = [Char] -> Type
gremlin [Char]
"TraversalDirection"
    traversalDirectionArgument :: Type
traversalDirectionArgument = [Char] -> Type
gremlin [Char]
"TraversalDirectionArgument"
    traversalFunction :: Type
traversalFunction = [Char] -> Type
gremlin [Char]
"TraversalFunction"
    traversalFunctionArgument :: Type
traversalFunctionArgument = [Char] -> Type
gremlin [Char]
"TraversalFunctionArgument"
    traversalMergeArgument :: Type
traversalMergeArgument = [Char] -> Type
gremlin [Char]
"TraversalMergeArgument"
    traversalOperator :: Type
traversalOperator = [Char] -> Type
gremlin [Char]
"TraversalOperator"
    traversalOrder :: Type
traversalOrder = [Char] -> Type
gremlin [Char]
"TraversalOrder"
    traversalOrderArgument :: Type
traversalOrderArgument = [Char] -> Type
gremlin [Char]
"TraversalOrderArgument"
    traversalMerge :: Type
traversalMerge = [Char] -> Type
gremlin [Char]
"TraversalMerge"
    traversalMethod :: Type
traversalMethod = [Char] -> Type
gremlin [Char]
"TraversalMethod"
    traversalPick :: Type
traversalPick = [Char] -> Type
gremlin [Char]
"TraversalPick"
    traversalPop :: Type
traversalPop = [Char] -> Type
gremlin [Char]
"TraversalPop"
    traversalPopArgument :: Type
traversalPopArgument = [Char] -> Type
gremlin [Char]
"TraversalPopArgument"
    traversalPredicate :: Type
traversalPredicate = [Char] -> Type
gremlin [Char]
"TraversalPredicate"
    traversalSackMethod :: Type
traversalSackMethod = Type
traversalBarrier
    traversalScope :: Type
traversalScope = [Char] -> Type
gremlin [Char]
"TraversalScope"
    traversalScopeArgument :: Type
traversalScopeArgument = [Char] -> Type
gremlin [Char]
"TraversalScopeArgument"
    traversalToken :: Type
traversalToken = [Char] -> Type
gremlin [Char]
"TraversalToken"
    traversalTokenArgument :: Type
traversalTokenArgument = [Char] -> Type
gremlin [Char]
"TraversalTokenArgument"
    variable :: Type
variable = Type
identifier

    elements :: [Element]
elements = [

-- /*
--  * Licensed to the Apache Software Foundation (ASF) under one
--  * or more contributor license agreements.  See the NOTICE file
--  * distributed with this work for additional information
--  * regarding copyright ownership.  The ASF licenses this file
--  * to you under the Apache License, Version 2.0 (the
--  * "License"); you may not use this file except in compliance
--  * with the License.  You may obtain a copy of the License at
--  *
--  * http://www.apache.org/licenses/LICENSE-2.0
--  *
--  * Unless required by applicable law or agreed to in writing,
--  * software distributed under the License is distributed on an
--  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
--  * KIND, either express or implied.  See the License for the
--  * specific language governing permissions and limitations
--  * under the License.
--  */
-- grammar Gremlin;
--
-- /*********************************************
--     PARSER RULES
-- **********************************************/
--
-- queryList
--     : query (SEMI? query)* SEMI? EOF
--     ;

      [Char] -> Type -> Element
def [Char]
"QueryList" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ Type -> Type
nonemptyList (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"Query",

-- query
      [Char] -> Type -> Element
def [Char]
"Query" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
--     : traversalSource
--     | traversalSource DOT transactionPart
        [Char]
"traversalSource"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalSourceQuery",
--     | rootTraversal
--     | rootTraversal DOT traversalTerminalMethod
        [Char]
"rootTraversal"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"RootTraversalQuery",
--     | query DOT 'toString' LPAREN RPAREN
       [Char]
"toString"[Char] -> Type -> FieldType
>: Type
unit,
--     | emptyQuery
       [Char]
"empty"[Char] -> Type -> FieldType
>: Type
unit],
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalSourceQuery" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"source"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalSource",
        [Char]
"transactionPart"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"TransactionPart"],

      [Char] -> Type -> Element
def [Char]
"RootTraversalQuery" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"root"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"RootTraversal",
        [Char]
"terminalMethod"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"TraversalTerminalMethod"],

-- emptyQuery
--     : EmptyStringLiteral
--     ;
--
-- traversalSource
--     : TRAVERSAL_ROOT
--     | TRAVERSAL_ROOT DOT traversalSourceSelfMethod
--     | traversalSource DOT traversalSourceSelfMethod
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalSource" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ Type -> Type
list (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"TraversalSourceSelfMethod",

-- transactionPart
--     : 'tx' LPAREN RPAREN DOT 'begin' LPAREN RPAREN
--     | 'tx' LPAREN RPAREN DOT 'commit' LPAREN RPAREN
--     | 'tx' LPAREN RPAREN DOT 'rollback' LPAREN RPAREN
--     ;

      [Char] -> Type -> Element
def [Char]
"TransactionPart" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"begin",
        [Char]
"commit",
        [Char]
"rollback"],

-- rootTraversal
--     : traversalSource DOT traversalSourceSpawnMethod
--     | traversalSource DOT traversalSourceSpawnMethod DOT chainedTraversal
--     | traversalSource DOT traversalSourceSpawnMethod DOT chainedParentOfGraphTraversal
--     ;

      [Char] -> Type -> Element
def [Char]
"RootTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"source"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalSource",
        [Char]
"spawnMethod"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalSourceSpawnMethod",
        [Char]
"chained"[Char] -> Type -> FieldType
>: Type -> Type
list (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"ChainedTraversalElement"],

-- traversalSourceSelfMethod
      [Char] -> Type -> Element
def [Char]
"TraversalSourceSelfMethod" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
--     : traversalSourceSelfMethod_withBulk
        [Char]
"withBulk"[Char] -> Type -> FieldType
>: Type
boolean,
--     | traversalSourceSelfMethod_withPath
        [Char]
"withPath"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalSourceSelfMethod_withSack
        [Char]
"withSack"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"GenericLiteralArgumentAndOptionalTraversalBiFunctionArgument",
--     | traversalSourceSelfMethod_withSideEffect
        [Char]
"withSideEffect"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"StringArgumentAndGenericLiteralArgument",
--     | traversalSourceSelfMethod_withStrategies
        [Char]
"withStrategies"[Char] -> Type -> FieldType
>: Type -> Type
nonemptyList (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"TraversalStrategy",
--     | traversalSourceSelfMethod_withoutStrategies
        [Char]
"withoutStrategies"[Char] -> Type -> FieldType
>: Type -> Type
nonemptyList Type
classType,
--     | traversalSourceSelfMethod_with
        [Char]
"with"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"StringArgumentAndOptionalGenericLiteralArgument"],
--     ;

-- traversalSourceSelfMethod_withBulk
--     : 'withBulk' LPAREN booleanArgument RPAREN
--     ;
--
-- traversalSourceSelfMethod_withPath
--     : 'withPath' LPAREN RPAREN
--     ;
--
-- traversalSourceSelfMethod_withSack
--     : 'withSack' LPAREN genericLiteralArgument RPAREN
--     | 'withSack' LPAREN genericLiteralArgument COMMA traversalBiFunctionArgument RPAREN
--     ;

      [Char] -> Type -> Element
def [Char]
"GenericLiteralArgumentAndOptionalTraversalBiFunctionArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"literal"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
        [Char]
"biFunction"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalBiFunctionArgument],

-- traversalSourceSelfMethod_withSideEffect
--     : 'withSideEffect' LPAREN stringArgument COMMA genericLiteralArgument RPAREN
--     ;

      [Char] -> Type -> Element
def [Char]
"StringArgumentAndGenericLiteralArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringArgument,
        [Char]
"literal"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument],

-- traversalSourceSelfMethod_withStrategies
--     : 'withStrategies' LPAREN traversalStrategy (COMMA traversalStrategyList)? RPAREN
--     ;
--
-- traversalSourceSelfMethod_withoutStrategies
--     : 'withoutStrategies' LPAREN classType (COMMA classTypeList)? RPAREN
--     ;
--
-- traversalSourceSelfMethod_with
--     : 'with' LPAREN stringArgument RPAREN
--     | 'with' LPAREN stringArgument COMMA genericLiteralArgument RPAREN
--     ;

      [Char] -> Type -> Element
def [Char]
"StringArgumentAndOptionalGenericLiteralArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringArgument,
        [Char]
"literal"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
genericLiteralArgument],

-- traversalSourceSpawnMethod
      [Char] -> Type -> Element
def [Char]
"TraversalSourceSpawnMethod" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
--     : traversalSourceSpawnMethod_addE
        [Char]
"addE"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"StringArgumentOrNestedTraversal",
--     | traversalSourceSpawnMethod_addV
        [Char]
"addV"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"StringArgumentOrNestedTraversal",
--     | traversalSourceSpawnMethod_E
        [Char]
"e"[Char] -> Type -> FieldType
>: Type
genericLiteralVarargs,
--     | traversalSourceSpawnMethod_V
        [Char]
"v"[Char] -> Type -> FieldType
>: Type
genericLiteralVarargs,
--     | traversalSourceSpawnMethod_mergeE
        [Char]
"mergeV"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"GenericLiteralMapNullableArgumentOrNestedTraversal",
--     | traversalSourceSpawnMethod_mergeV
        [Char]
"mergeE"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"GenericLiteralMapNullableArgumentOrNestedTraversal",
--     | traversalSourceSpawnMethod_inject
        [Char]
"inject"[Char] -> Type -> FieldType
>: Type
genericLiteralVarargs,
--     | traversalSourceSpawnMethod_io
        [Char]
"io"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalSourceSpawnMethod_call
        [Char]
"call"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"ServiceCall",
--     | traversalSourceSpawnMethod_union
        [Char]
"union"[Char] -> Type -> FieldType
>: Type
nestedTraversalList],
--     ;

-- traversalSourceSpawnMethod_addE
--     : 'addE' LPAREN stringArgument RPAREN
--     | 'addE' LPAREN nestedTraversal RPAREN
--     ;

-- traversalSourceSpawnMethod_addV
--     : 'addV' LPAREN RPAREN
--     | 'addV' LPAREN stringArgument RPAREN
--     | 'addV' LPAREN nestedTraversal RPAREN
--     ;
--
-- traversalSourceSpawnMethod_E
--     : 'E' LPAREN genericLiteralVarargs RPAREN
--     ;
--
-- traversalSourceSpawnMethod_V
--     : 'V' LPAREN genericLiteralVarargs RPAREN
--     ;
--
-- traversalSourceSpawnMethod_inject
--     : 'inject' LPAREN genericLiteralVarargs RPAREN
--     ;
--
-- traversalSourceSpawnMethod_io
--     : 'io' LPAREN stringArgument RPAREN
--     ;
--
-- traversalSourceSpawnMethod_mergeV
--     : 'mergeV' LPAREN genericLiteralMapNullableArgument RPAREN #traversalSourceSpawnMethod_mergeV_Map
--     | 'mergeV' LPAREN nestedTraversal RPAREN #traversalSourceSpawnMethod_mergeV_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"GenericLiteralMapNullableArgumentOrNestedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"map"[Char] -> Type -> FieldType
>: Type
genericLiteralMapNullableArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

-- traversalSourceSpawnMethod_mergeE
--     : 'mergeE' LPAREN genericLiteralMapNullableArgument RPAREN #traversalSourceSpawnMethod_mergeE_Map
--     | 'mergeE' LPAREN nestedTraversal RPAREN #traversalSourceSpawnMethod_mergeE_Traversal
--     ;
--
-- traversalSourceSpawnMethod_call
--     : 'call' LPAREN RPAREN #traversalSourceSpawnMethod_call_empty
--     | 'call' LPAREN stringArgument RPAREN #traversalSourceSpawnMethod_call_string
--     | 'call' LPAREN stringArgument COMMA genericLiteralMapArgument RPAREN #traversalSourceSpawnMethod_call_string_map
--     | 'call' LPAREN stringArgument COMMA nestedTraversal RPAREN #traversalSourceSpawnMethod_call_string_traversal
--     | 'call' LPAREN stringArgument COMMA genericLiteralMapArgument COMMA nestedTraversal RPAREN #traversalSourceSpawnMethod_call_string_map_traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"ServiceCall" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"service"[Char] -> Type -> FieldType
>: Type
stringArgument,
        [Char]
"arguments"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ServiceArguments"],

      [Char] -> Type -> Element
def [Char]
"ServiceArguments" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"map"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
genericLiteralMapArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
nestedTraversal],

-- traversalSourceSpawnMethod_union
--     : 'union' LPAREN nestedTraversalList RPAREN
--     ;
--
-- chainedTraversal
--     : traversalMethod
--     | chainedTraversal DOT traversalMethod
--     | chainedTraversal DOT chainedParentOfGraphTraversal
--     ;

      [Char] -> Type -> Element
def [Char]
"ChainedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"first"[Char] -> Type -> FieldType
>: Type
traversalMethod,
        [Char]
"rest"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ChainedTraversalElement"],

      [Char] -> Type -> Element
def [Char]
"ChainedTraversalElement" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"method"[Char] -> Type -> FieldType
>: Type
traversalMethod,
        [Char]
"self"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalSelfMethod"],

-- chainedParentOfGraphTraversal
--     : traversalSelfMethod
--     | chainedParentOfGraphTraversal DOT traversalSelfMethod
--     ;
--
-- nestedTraversal
--     : rootTraversal
--     | chainedTraversal
--     | ANON_TRAVERSAL_ROOT DOT chainedTraversal
--     ;

      [Char] -> Type -> Element
def [Char]
"NestedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"root"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"RootTraversal",
        [Char]
"chained"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ChainedTraversal",
        [Char]
"anonymous"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ChainedTraversal"],

-- terminatedTraversal
--     : rootTraversal DOT traversalTerminalMethod
--     ;

      [Char] -> Type -> Element
def [Char]
"TerminatedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"root"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"RootTraversal",
        [Char]
"terminal"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalTerminalMethod"],

-- traversalMethod
      [Char] -> Type -> Element
def [Char]
"TraversalMethod" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [ -- TODO
--     : traversalMethod_V
        [Char]
"v"[Char] -> Type -> FieldType
>: Type
genericLiteralVarargs,
--     | traversalMethod_E
        [Char]
"e"[Char] -> Type -> FieldType
>: Type
genericLiteralVarargs,
--     | traversalMethod_addE
        [Char]
"addE"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"StringArgumentOrNestedTraversal",
--     | traversalMethod_addV
        [Char]
"addV"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"StringArgumentOrNestedTraversal",
--     | traversalMethod_mergeE
        [Char]
"mergeE"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"GenericLiteralMapNullableArgumentOrNestedTraversal",
--     | traversalMethod_mergeV
        [Char]
"mergeV"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"GenericLiteralMapNullableArgumentOrNestedTraversal",
--     | traversalMethod_aggregate
        [Char]
"aggregate"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"OptionalTraversalScopeArgumentAndStringArgument",
--     | traversalMethod_all
        [Char]
"all"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
--     | traversalMethod_and
        [Char]
"and"[Char] -> Type -> FieldType
>: Type
nestedTraversalList,
--     | traversalMethod_any
        [Char]
"any"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
--     | traversalMethod_as
        [Char]
"as"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"StringArgumentAndOptionalStringLiteralVarargs",
--     | traversalMethod_barrier
        [Char]
"barrier"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"TraversalSackMethodArgumentOrIntegerArgument",
--     | traversalMethod_both
        [Char]
"both"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_bothE
        [Char]
"bothE"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_bothV
        [Char]
"bothV"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_branch
        [Char]
"branch"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
--     | traversalMethod_by
        [Char]
"by"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ByArgs",
--     | traversalMethod_cap
        [Char]
"cap"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"StringArgumentAndOptionalStringLiteralVarargs",
--     | traversalMethod_choose
        [Char]
"choose"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ChooseArgs",
--     | traversalMethod_coalesce
        [Char]
"coalesce"[Char] -> Type -> FieldType
>: Type
nestedTraversalList,
--     | traversalMethod_coin
        [Char]
"coin"[Char] -> Type -> FieldType
>: Type
floatArgument,
--     | traversalMethod_conjoin
        [Char]
"conjoin"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalMethod_connectedComponent
        [Char]
"connectedComponent"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_constant
        [Char]
"constant"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalMethod_count
        [Char]
"count"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_cyclicPath
        [Char]
"cyclicPath"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_dedup
        [Char]
"dedup"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"DedupArgs",
--     | traversalMethod_difference
        [Char]
"difference"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalMethod_disjunct
        [Char]
"disjunct"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalMethod_drop
        [Char]
"drop"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_elementMap
        [Char]
"elementMap"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_emit
        [Char]
"emit"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"PredicateOrTraversal",
--     | traversalMethod_filter
        [Char]
"filter"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"PredicateOrTraversal",
--     | traversalMethod_flatMap
        [Char]
"flatMap"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
--     | traversalMethod_fold
        [Char]
"fold"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"GenericLiteralArgumentAndTraversalBiFunctionArgument",
--     | traversalMethod_from
        [Char]
"from"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"FromArgs",
--     | traversalMethod_group
        [Char]
"group"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
stringArgument,
--     | traversalMethod_groupCount
        [Char]
"groupCount"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
stringArgument,
--     | traversalMethod_has
        [Char]
"has"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"HasArgs",
--     | traversalMethod_hasId
        [Char]
"hasId"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"GenericLiteralArgumentAndTraversalPredicate",
--     | traversalMethod_hasKey
        [Char]
"hasKey"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalPredicateOrStringLiteralVarargs",
--     | traversalMethod_hasLabel
        [Char]
"hasLabel"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalPredicateOrStringLiteralVarargs",
--     | traversalMethod_hasNot
        [Char]
"hasNot"[Char] -> Type -> FieldType
>: Type
stringNullableArgument,
--     | traversalMethod_hasValue
        [Char]
"hasValue"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalPredicateOrGenericLiteralArgument",
--     | traversalMethod_id
        [Char]
"id"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_identity
        [Char]
"identity"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_in
        [Char]
"in"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_inE
        [Char]
"inE"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_intersect
        [Char]
"intersect"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalMethod_inV
        [Char]
"inV"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_index
        [Char]
"index"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_inject
        [Char]
"inject"[Char] -> Type -> FieldType
>: Type
genericLiteralVarargs,
--     | traversalMethod_is
        [Char]
"is"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalPredicateOrGenericLiteralArgument",
--     | traversalMethod_key
        [Char]
"key"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_label
        [Char]
"label"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_limit
        [Char]
"limit"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"OptionalTraversalScopeArgumentAndIntegerArgument",
--     | traversalMethod_local
        [Char]
"local"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
--     | traversalMethod_loops
        [Char]
"loops"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
stringArgument,
--     | traversalMethod_map
        [Char]
"map"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
--     | traversalMethod_match
        [Char]
"match"[Char] -> Type -> FieldType
>: Type
nestedTraversalList,
--     | traversalMethod_math
        [Char]
"math"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalMethod_max
        [Char]
"max"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_mean
        [Char]
"mean"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_min
        [Char]
"min"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_none
        [Char]
"none"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
--     | traversalMethod_not
        [Char]
"not"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
--     | traversalMethod_option
        [Char]
"option"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"OptionArgs",
--     | traversalMethod_optional
        [Char]
"optional"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
--     | traversalMethod_or
        [Char]
"or"[Char] -> Type -> FieldType
>: Type
nestedTraversalList,
--     | traversalMethod_order
        [Char]
"order"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_otherV
        [Char]
"otherV"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_out
        [Char]
"out"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_outE
        [Char]
"outE"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_outV
        [Char]
"outV"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_pageRank
        [Char]
"pageRank"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
floatArgument,
--     | traversalMethod_path
        [Char]
"path"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_peerPressure
        [Char]
"peerPressure"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_profile
        [Char]
"profile"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
stringArgument,
--     | traversalMethod_project
        [Char]
"project"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"StringArgumentAndOptionalStringLiteralVarargs",
--     | traversalMethod_properties
        [Char]
"properties"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_property
        [Char]
"property"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"PropertyArgs",
--     | traversalMethod_propertyMap
        [Char]
"propertyMap"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_range
        [Char]
"range"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"RangeArgs",
--     | traversalMethod_read
        [Char]
"read"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_repeat
        [Char]
"repeat"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"OptionalStringArgumentAndNestedTraversal",
--     | traversalMethod_sack
        [Char]
"sack"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalBiFunctionArgument,
--     | traversalMethod_sample
        [Char]
"sample"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"OptionalTraversalScopeArgumentAndIntegerArgument",
--     | traversalMethod_select
        [Char]
"select"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"SelectArgs",
--     | traversalMethod_combine
        [Char]
"combine"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalMethod_product
        [Char]
"product"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalMethod_merge
        [Char]
"merge"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalMethod_shortestPath
        [Char]
"shortestPath"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_sideEffect
        [Char]
"sideEffect"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
--     | traversalMethod_simplePath
        [Char]
"simplePath"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_skip
        [Char]
"skip"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"OptionalTraversalScopeArgumentAndIntegerArgument",
--     | traversalMethod_store
        [Char]
"store"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalMethod_subgraph
        [Char]
"subgraph"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalMethod_sum
        [Char]
"sum"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_tail
        [Char]
"tail"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"TailArgs",
--     | traversalMethod_fail
        [Char]
"fail"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
stringArgument,
--     | traversalMethod_timeLimit
--     | traversalMethod_times
        [Char]
"times"[Char] -> Type -> FieldType
>: Type
integerArgument,
--     | traversalMethod_to
        [Char]
"to"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ToArgs",
--     | traversalMethod_toE
        [Char]
"toE"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"DirectionAndVarargs",
--     | traversalMethod_toV
        [Char]
"toV"[Char] -> Type -> FieldType
>: Type
traversalDirectionArgument,
--     | traversalMethod_tree
        [Char]
"tree"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
stringArgument,
--     | traversalMethod_unfold
        [Char]
"unfold"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_union
        [Char]
"union"[Char] -> Type -> FieldType
>: Type
nestedTraversalList,
--     | traversalMethod_until
        [Char]
"until"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"PredicateOrTraversal",
--     | traversalMethod_value
        [Char]
"value"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_valueMap
        [Char]
"valueMap"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ValueMapArgs",
--     | traversalMethod_values
        [Char]
"values"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_where
        [Char]
"where"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"WhereArgs",
--     | traversalMethod_with
        [Char]
"with"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"WithArgs",
--     | traversalMethod_write
        [Char]
"write"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_element
        [Char]
"element"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
--     | traversalMethod_call
        [Char]
"call"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ServiceCall",
--     | traversalMethod_concat
        [Char]
"concat"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ConcatArgs",
--     | traversalMethod_asString
        [Char]
"asString"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_format
        [Char]
"format"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalMethod_toUpper
        [Char]
"toUpper"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_toLower
        [Char]
"toLower"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_length
        [Char]
"length"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_trim
        [Char]
"trim"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_lTrim
        [Char]
"lTrim"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_rTrim
        [Char]
"rTrim"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
--     | traversalMethod_reverse
        [Char]
"reverse"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_replace
        [Char]
"replace"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ReplaceArgs",
--     | traversalMethod_split
        [Char]
"split"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"SplitArgs",
--     | traversalMethod_substring
        [Char]
"substring"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"SubstringArgs",
--     | traversalMethod_asDate
        [Char]
"asDate"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalMethod_dateAdd
        [Char]
"dateAdd"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"DateAddArgs",
--     | traversalMethod_dateDiff
        [Char]
"dateDiff"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"DateDiffArgs"],
--     ;

-- traversalMethod_V
--     : 'V' LPAREN genericLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_E
--     : 'E' LPAREN genericLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_addE
--     : 'addE' LPAREN stringArgument RPAREN #traversalMethod_addE_String
--     | 'addE' LPAREN nestedTraversal RPAREN #traversalMethod_addE_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"StringArgumentOrNestedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

-- traversalMethod_addV
--     : 'addV' LPAREN RPAREN #traversalMethod_addV_Empty
--     | 'addV' LPAREN stringArgument RPAREN #traversalMethod_addV_String
--     | 'addV' LPAREN nestedTraversal RPAREN #traversalMethod_addV_Traversal
--     ;

-- traversalMethod_mergeV
--     : 'mergeV' LPAREN RPAREN #traversalMethod_mergeV_empty
--     | 'mergeV' LPAREN genericLiteralMapNullableArgument RPAREN #traversalMethod_mergeV_Map
--     | 'mergeV' LPAREN nestedTraversal RPAREN #traversalMethod_mergeV_Traversal
--     ;

-- traversalMethod_mergeE
--     : 'mergeE' LPAREN RPAREN #traversalMethod_mergeE_empty
--     | 'mergeE' LPAREN genericLiteralMapNullableArgument RPAREN #traversalMethod_mergeE_Map
--     | 'mergeE' LPAREN nestedTraversal RPAREN #traversalMethod_mergeE_Traversal
--     ;

-- traversalMethod_aggregate
--     : 'aggregate' LPAREN traversalScopeArgument COMMA stringArgument RPAREN #traversalMethod_aggregate_Scope_String
--     | 'aggregate' LPAREN stringArgument RPAREN #traversalMethod_aggregate_String
--     ;

      [Char] -> Type -> Element
def [Char]
"OptionalTraversalScopeArgumentAndStringArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"scope"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringArgument],

-- traversalMethod_all
--     : 'all' LPAREN traversalPredicate RPAREN #traversalMethod_all_P
--     ;
--
-- traversalMethod_and
--     : 'and' LPAREN nestedTraversalList RPAREN
--     ;
--
-- traversalMethod_any
--     : 'any' LPAREN traversalPredicate RPAREN #traversalMethod_any_P
--     ;
--
-- traversalMethod_as
--     : 'as' LPAREN stringArgument (COMMA stringLiteralVarargs)? RPAREN
--     ;

      [Char] -> Type -> Element
def [Char]
"StringArgumentAndOptionalStringLiteralVarargs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"first"[Char] -> Type -> FieldType
>: Type
stringArgument,
        [Char]
"rest"[Char] -> Type -> FieldType
>: Type
optionalStringLiteralVarargs],

-- traversalMethod_barrier
--     : 'barrier' LPAREN traversalSackMethodArgument RPAREN #traversalMethod_barrier_Consumer
--     | 'barrier' LPAREN RPAREN #traversalMethod_barrier_Empty
--     | 'barrier' LPAREN integerArgument RPAREN #traversalMethod_barrier_int
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalSackMethodArgumentOrIntegerArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"consumer"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalSackMethodArgument",
        [Char]
"int"[Char] -> Type -> FieldType
>: Type
integerArgument],

--
-- traversalMethod_both
--     : 'both' LPAREN stringLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_bothE
--     : 'bothE' LPAREN stringLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_bothV
--     : 'bothV' LPAREN RPAREN
--     ;
--
-- traversalMethod_branch
--     : 'branch' LPAREN nestedTraversal RPAREN
--     ;
--
-- traversalMethod_by
--     : 'by' LPAREN traversalComparatorArgument RPAREN #traversalMethod_by_Comparator
--     | 'by' LPAREN RPAREN #traversalMethod_by_Empty
--     | 'by' LPAREN traversalFunctionArgument RPAREN #traversalMethod_by_Function
--     | 'by' LPAREN traversalFunctionArgument COMMA traversalComparatorArgument RPAREN #traversalMethod_by_Function_Comparator
--     | 'by' LPAREN traversalOrderArgument RPAREN #traversalMethod_by_Order
--     | 'by' LPAREN stringArgument RPAREN #traversalMethod_by_String
--     | 'by' LPAREN stringArgument COMMA traversalComparatorArgument RPAREN #traversalMethod_by_String_Comparator
--     | 'by' LPAREN traversalTokenArgument RPAREN #traversalMethod_by_T
--     | 'by' LPAREN nestedTraversal RPAREN #traversalMethod_by_Traversal
--     | 'by' LPAREN nestedTraversal COMMA traversalComparatorArgument RPAREN #traversalMethod_by_Traversal_Comparator
--     ;

      [Char] -> Type -> Element
def [Char]
"ByArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"order"[Char] -> Type -> FieldType
>: Type
traversalOrderArgument,
        [Char]
"token"[Char] -> Type -> FieldType
>: Type
traversalTokenArgument,
        [Char]
"other"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ByOtherArgs"],

      [Char] -> Type -> Element
def [Char]
"ByOtherArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"comparator"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalComparatorArgument,
        [Char]
"other"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"TraversalFunctionArgumentOrStringArgumentOrNestedTraversal"],

      [Char] -> Type -> Element
def [Char]
"TraversalFunctionArgumentOrStringArgumentOrNestedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"function"[Char] -> Type -> FieldType
>: Type
traversalFunctionArgument,
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

-- traversalMethod_cap
--     : 'cap' LPAREN stringArgument (COMMA stringLiteralVarargs)? RPAREN
--     ;
--
-- traversalMethod_choose
--     : 'choose' LPAREN traversalFunctionArgument RPAREN #traversalMethod_choose_Function
--     | 'choose' LPAREN traversalPredicate COMMA nestedTraversal RPAREN #traversalMethod_choose_Predicate_Traversal
--     | 'choose' LPAREN traversalPredicate COMMA nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Predicate_Traversal_Traversal
--     | 'choose' LPAREN nestedTraversal RPAREN #traversalMethod_choose_Traversal
--     | 'choose' LPAREN nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Traversal_Traversal
--     | 'choose' LPAREN nestedTraversal COMMA nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Traversal_Traversal_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"ChooseArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"function"[Char] -> Type -> FieldType
>: Type
traversalFunctionArgument,
        [Char]
"predicateTraversal"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"PredicateTraversalArgument",
        [Char]
"traversal"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"NestedTraversalArgument"],

      [Char] -> Type -> Element
def [Char]
"PredicateTraversalArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"predicate"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
        [Char]
"traversal1"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
        [Char]
"traversal2"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ Type
nestedTraversal],

      [Char] -> Type -> Element
def [Char]
"NestedTraversalArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"traversal1"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
        [Char]
"traversal2"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ Type
nestedTraversal,
        [Char]
"traversal3"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ Type
nestedTraversal],

-- traversalMethod_coalesce
--     : 'coalesce' LPAREN nestedTraversalList RPAREN
--     ;
--
-- traversalMethod_coin
--     : 'coin' LPAREN floatArgument RPAREN
--     ;
--
-- traversalMethod_combine
--     : 'combine' LPAREN genericLiteralArgument RPAREN #traversalMethod_combine_Object
--     ;
--
-- traversalMethod_connectedComponent
--     : 'connectedComponent' LPAREN RPAREN
--     ;
--
-- traversalMethod_constant
--     : 'constant' LPAREN genericLiteralArgument RPAREN
--     ;
--
-- traversalMethod_count
--     : 'count' LPAREN RPAREN #traversalMethod_count_Empty
--     | 'count' LPAREN traversalScopeArgument RPAREN #traversalMethod_count_Scope
--     ;
--
-- traversalMethod_cyclicPath
--     : 'cyclicPath' LPAREN RPAREN
--     ;
--
-- traversalMethod_dedup
--     : 'dedup' LPAREN traversalScopeArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_dedup_Scope_String
--     | 'dedup' LPAREN stringLiteralVarargs RPAREN #traversalMethod_dedup_String
--     ;

      [Char] -> Type -> Element
def [Char]
"DedupArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"scopeString"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ScopeStringArgument",
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs],

      [Char] -> Type -> Element
def [Char]
"ScopeStringArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"scope"[Char] -> Type -> FieldType
>: Type
traversalScopeArgument,
        [Char]
"strings"[Char] -> Type -> FieldType
>: Type
optionalStringLiteralVarargs],

-- traversalMethod_difference
--     : 'difference' LPAREN genericLiteralArgument RPAREN #traversalMethod_difference_Object
--     ;
--
-- traversalMethod_disjunct
--     : 'disjunct' LPAREN genericLiteralArgument RPAREN #traversalMethod_disjunct_Object
--     ;
--
-- traversalMethod_drop
--     : 'drop' LPAREN RPAREN
--     ;
--
-- traversalMethod_elementMap
--     : 'elementMap' LPAREN stringLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_emit
--     : 'emit' LPAREN RPAREN #traversalMethod_emit_Empty
--     | 'emit' LPAREN traversalPredicate RPAREN #traversalMethod_emit_Predicate
--     | 'emit' LPAREN nestedTraversal RPAREN #traversalMethod_emit_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"PredicateOrTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"predicate"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

-- traversalMethod_filter
--     : 'filter' LPAREN traversalPredicate RPAREN #traversalMethod_filter_Predicate
--     | 'filter' LPAREN nestedTraversal RPAREN #traversalMethod_filter_Traversal
--     ;

-- traversalMethod_flatMap
--     : 'flatMap' LPAREN nestedTraversal RPAREN
--     ;
--
-- traversalMethod_fold
--     : 'fold' LPAREN RPAREN #traversalMethod_fold_Empty
--     | 'fold' LPAREN genericLiteralArgument COMMA traversalBiFunctionArgument RPAREN #traversalMethod_fold_Object_BiFunction
--     ;

      [Char] -> Type -> Element
def [Char]
"GenericLiteralArgumentAndTraversalBiFunctionArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"literal"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
        [Char]
"biFunction"[Char] -> Type -> FieldType
>: Type
traversalBiFunctionArgument],

-- traversalMethod_from
--     : 'from' LPAREN stringArgument RPAREN #traversalMethod_from_String
--     | 'from' LPAREN structureVertexArgument RPAREN #traversalMethod_from_Vertex
--     | 'from' LPAREN nestedTraversal RPAREN #traversalMethod_from_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"FromArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringArgument,
        [Char]
"vertex"[Char] -> Type -> FieldType
>: Type
structureVertexArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

-- traversalMethod_group
--     : 'group' LPAREN RPAREN #traversalMethod_group_Empty
--     | 'group' LPAREN stringArgument RPAREN #traversalMethod_group_String
--     ;
--
-- traversalMethod_groupCount
--     : 'groupCount' LPAREN RPAREN #traversalMethod_groupCount_Empty
--     | 'groupCount' LPAREN stringArgument RPAREN #traversalMethod_groupCount_String
--     ;
--
-- traversalMethod_has
--     : 'has' LPAREN stringNullableArgument RPAREN #traversalMethod_has_String
--     | 'has' LPAREN stringNullableArgument COMMA genericLiteralArgument RPAREN #traversalMethod_has_String_Object
--     | 'has' LPAREN stringNullableArgument COMMA traversalPredicate RPAREN #traversalMethod_has_String_P
--     | 'has' LPAREN stringNullableArgument COMMA stringNullableArgument COMMA genericLiteralArgument RPAREN #traversalMethod_has_String_String_Object
--     | 'has' LPAREN stringNullableArgument COMMA stringNullableArgument COMMA traversalPredicate RPAREN #traversalMethod_has_String_String_P
--     | 'has' LPAREN stringNullableArgument COMMA nestedTraversal RPAREN #traversalMethod_has_String_Traversal
--     | 'has' LPAREN traversalTokenArgument COMMA genericLiteralArgument RPAREN #traversalMethod_has_T_Object
--     | 'has' LPAREN traversalTokenArgument COMMA traversalPredicate RPAREN #traversalMethod_has_T_P
--     | 'has' LPAREN traversalTokenArgument COMMA nestedTraversal RPAREN #traversalMethod_has_T_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"HasArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"string"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"HasStringArgumentAndOptionalStringLiteralVarargs",
        [Char]
"traversalToken"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"HasTraversalTokenArgs"],

      [Char] -> Type -> Element
def [Char]
"HasStringArgumentAndOptionalStringLiteralVarargs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringNullableArgument,
        [Char]
"rest"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"HasStringArgumentAndOptionalStringLiteralVarargsRest"],

      [Char] -> Type -> Element
def [Char]
"HasStringArgumentAndOptionalStringLiteralVarargsRest" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"object"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
        [Char]
"predicate"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
        [Char]
"stringObject"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"StringNullableArgumentAndGenericLiteralArgument",
        [Char]
"stringPredicate"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"StringNullableArgumentAndTraversalPredicate",
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

      [Char] -> Type -> Element
def [Char]
"StringNullableArgumentAndGenericLiteralArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringNullableArgument,
        [Char]
"literal"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument],

      [Char] -> Type -> Element
def [Char]
"StringNullableArgumentAndTraversalPredicate" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringNullableArgument,
        [Char]
"predicate"[Char] -> Type -> FieldType
>: Type
traversalPredicate],

      [Char] -> Type -> Element
def [Char]
"HasTraversalTokenArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"traversalToken"[Char] -> Type -> FieldType
>: Type
traversalTokenArgument,
        [Char]
"rest"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"HasTraversalTokenArgsRest"],

      [Char] -> Type -> Element
def [Char]
"HasTraversalTokenArgsRest" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"literal"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
        [Char]
"predicate"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

-- traversalMethod_hasId
--     : 'hasId' LPAREN genericLiteralArgument (COMMA genericLiteralVarargs)? RPAREN #traversalMethod_hasId_Object_Object
--     | 'hasId' LPAREN traversalPredicate RPAREN #traversalMethod_hasId_P
--     ;

      [Char] -> Type -> Element
def [Char]
"GenericLiteralArgumentAndTraversalPredicate" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"literal"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
        [Char]
"predicate"[Char] -> Type -> FieldType
>: Type
traversalPredicate],

-- traversalMethod_hasKey
--     : 'hasKey' LPAREN traversalPredicate RPAREN #traversalMethod_hasKey_P
--     | 'hasKey' LPAREN stringNullableArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_hasKey_String_String
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalPredicateOrStringLiteralVarargs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"predicate"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs],

-- traversalMethod_hasLabel
--     : 'hasLabel' LPAREN traversalPredicate RPAREN #traversalMethod_hasLabel_P
--     | 'hasLabel' LPAREN stringNullableArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_hasLabel_String_String
--     ;
--
-- traversalMethod_hasNot
--     : 'hasNot' LPAREN stringNullableArgument RPAREN
--     ;
--
-- traversalMethod_hasValue
--     : 'hasValue' LPAREN genericLiteralArgument (COMMA genericLiteralVarargs)? RPAREN #traversalMethod_hasValue_Object_Object
--     | 'hasValue' LPAREN traversalPredicate RPAREN #traversalMethod_hasValue_P
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalPredicateOrGenericLiteralArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"predicate"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
        [Char]
"literal"[Char] -> Type -> FieldType
>: Type -> Type
list Type
genericLiteralArgument],

-- traversalMethod_id
--     : 'id' LPAREN RPAREN
--     ;
--
-- traversalMethod_identity
--     : 'identity' LPAREN RPAREN
--     ;
--
-- traversalMethod_in
--     : 'in' LPAREN stringLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_inE
--     : 'inE' LPAREN stringLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_intersect
--     : 'intersect' LPAREN genericLiteralArgument RPAREN #traversalMethod_intersect_Object
--     ;
--
-- traversalMethod_inV
--     : 'inV' LPAREN RPAREN
--     ;
--
-- traversalMethod_index
--     : 'index' LPAREN RPAREN
--     ;
--
-- traversalMethod_inject
--     : 'inject' LPAREN genericLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_is
--     : 'is' LPAREN genericLiteralArgument RPAREN #traversalMethod_is_Object
--     | 'is' LPAREN traversalPredicate RPAREN #traversalMethod_is_P
--     ;
--
-- traversalMethod_conjoin
--     : 'conjoin' LPAREN stringArgument RPAREN #traversalMethod_conjoin_String
--     ;
--
-- traversalMethod_key
--     : 'key' LPAREN RPAREN
--     ;
--
-- traversalMethod_label
--     : 'label' LPAREN RPAREN
--     ;
--
-- traversalMethod_limit
--     : 'limit' LPAREN traversalScopeArgument COMMA integerArgument RPAREN #traversalMethod_limit_Scope_long
--     | 'limit' LPAREN integerArgument RPAREN #traversalMethod_limit_long
--     ;

-- traversalMethod_local
--     : 'local' LPAREN nestedTraversal RPAREN
--     ;
--
-- traversalMethod_loops
--     : 'loops' LPAREN RPAREN #traversalMethod_loops_Empty
--     | 'loops' LPAREN stringArgument RPAREN #traversalMethod_loops_String
--     ;
--
-- traversalMethod_map
--     : 'map' LPAREN nestedTraversal RPAREN
--     ;
--
-- traversalMethod_match
--     : 'match' LPAREN nestedTraversalList RPAREN
--     ;
--
-- traversalMethod_math
--     : 'math' LPAREN stringArgument RPAREN
--     ;
--
-- traversalMethod_max
--     : 'max' LPAREN RPAREN #traversalMethod_max_Empty
--     | 'max' LPAREN traversalScopeArgument RPAREN #traversalMethod_max_Scope
--     ;
--
-- traversalMethod_mean
--     : 'mean' LPAREN RPAREN #traversalMethod_mean_Empty
--     | 'mean' LPAREN traversalScopeArgument RPAREN #traversalMethod_mean_Scope
--     ;
--
-- traversalMethod_merge
--     : 'merge' LPAREN genericLiteralArgument RPAREN #traversalMethod_merge_Object
--     ;
--
-- traversalMethod_min
--     : 'min' LPAREN RPAREN #traversalMethod_min_Empty
--     | 'min' LPAREN traversalScopeArgument RPAREN #traversalMethod_min_Scope
--     ;
--
-- traversalMethod_none
--     : 'none' LPAREN traversalPredicate RPAREN #traversalMethod_none_P
--     ;
--
-- traversalMethod_not
--     : 'not' LPAREN nestedTraversal RPAREN
--     ;
--
-- traversalMethod_option
--     : 'option' LPAREN traversalPredicate COMMA nestedTraversal RPAREN #traversalMethod_option_Predicate_Traversal
--     | 'option' LPAREN traversalMergeArgument COMMA genericLiteralMapNullableArgument RPAREN #traversalMethod_option_Merge_Map
--     | 'option' LPAREN traversalMergeArgument COMMA genericLiteralMapNullableArgument COMMA traversalCardinality RPAREN #traversalMethod_option_Merge_Map_Cardinality
--     | 'option' LPAREN traversalMergeArgument COMMA nestedTraversal RPAREN #traversalMethod_option_Merge_Traversal
--     | 'option' LPAREN genericLiteralArgument COMMA nestedTraversal RPAREN #traversalMethod_option_Object_Traversal
--     | 'option' LPAREN nestedTraversal RPAREN #traversalMethod_option_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"OptionArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"predicateTraversal"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalPredicateAndNestedTraversal",
        [Char]
"mergeMap"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalMergeArgumentAndGenericLiteralMapNullableArgument",
        [Char]
"mergeTraversal"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalMergeArgumentAndNestedTraversal",
        [Char]
"objectTraversal"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"GenericLiteralArgumentAndNestedTraversal",
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

      [Char] -> Type -> Element
def [Char]
"TraversalPredicateAndNestedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"predicate"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

      [Char] -> Type -> Element
def [Char]
"TraversalMergeArgumentAndGenericLiteralMapNullableArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"merge"[Char] -> Type -> FieldType
>: Type
traversalMergeArgument,
        [Char]
"map"[Char] -> Type -> FieldType
>: Type
genericLiteralMapNullableArgument,
        [Char]
"cardinality"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalCardinality],

      [Char] -> Type -> Element
def [Char]
"TraversalMergeArgumentAndNestedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"merge"[Char] -> Type -> FieldType
>: Type
traversalMergeArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

      [Char] -> Type -> Element
def [Char]
"GenericLiteralArgumentAndNestedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"object"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

-- traversalMethod_optional
--     : 'optional' LPAREN nestedTraversal RPAREN
--     ;
--
-- traversalMethod_or
--     : 'or' LPAREN nestedTraversalList RPAREN
--     ;
--
-- traversalMethod_order
--     : 'order' LPAREN RPAREN #traversalMethod_order_Empty
--     | 'order' LPAREN traversalScopeArgument RPAREN #traversalMethod_order_Scope
--     ;
--
-- traversalMethod_otherV
--     : 'otherV' LPAREN RPAREN
--     ;
--
-- traversalMethod_out
--     : 'out' LPAREN stringLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_outE
--     : 'outE' LPAREN stringLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_outV
--     : 'outV' LPAREN RPAREN
--     ;
--
-- traversalMethod_pageRank
--     : 'pageRank' LPAREN RPAREN #traversalMethod_pageRank_Empty
--     | 'pageRank' LPAREN floatArgument RPAREN #traversalMethod_pageRank_double
--     ;
--
-- traversalMethod_path
--     : 'path' LPAREN RPAREN
--     ;
--
-- traversalMethod_peerPressure
--     : 'peerPressure' LPAREN RPAREN
--     ;
--
-- traversalMethod_product
--     : 'product' LPAREN genericLiteralArgument RPAREN #traversalMethod_product_Object
--     ;
--
-- traversalMethod_profile
--     : 'profile' LPAREN RPAREN #traversalMethod_profile_Empty
--     | 'profile' LPAREN stringArgument RPAREN #traversalMethod_profile_String
--     ;
--
-- traversalMethod_project
--     : 'project' LPAREN stringArgument (COMMA stringLiteralVarargs)? RPAREN
--     ;

-- traversalMethod_properties
--     : 'properties' LPAREN stringLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_property
--     : 'property' LPAREN traversalCardinalityArgument COMMA genericLiteralArgument COMMA genericLiteralArgument (COMMA genericLiteralVarargs)? RPAREN #traversalMethod_property_Cardinality_Object_Object_Object
--     | 'property' LPAREN genericLiteralArgument COMMA genericLiteralArgument (COMMA genericLiteralVarargs)? RPAREN #traversalMethod_property_Object_Object_Object
--     | 'property' LPAREN genericLiteralMapNullableArgument RPAREN # traversalMethod_property_Object
--     | 'property' LPAREN traversalCardinalityArgument COMMA genericLiteralMapNullableArgument RPAREN # traversalMethod_property_Cardinality_Object
--     ;

      [Char] -> Type -> Element
def [Char]
"PropertyArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"cardinalityObjects"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalCardinalityArgumentAndObjects",
        [Char]
"objects"[Char] -> Type -> FieldType
>: Int -> Type -> Type
minLengthList Int
2 Type
genericLiteralArgument,
        [Char]
"object"[Char] -> Type -> FieldType
>: Type
genericLiteralMapNullableArgument,
        [Char]
"cardinalityObject"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"GenericLiteralMapNullableArgumentAndTraversalCardinalityArgument"],

      [Char] -> Type -> Element
def [Char]
"TraversalCardinalityArgumentAndObjects" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"cardinality"[Char] -> Type -> FieldType
>: Type
traversalCardinalityArgument,
        [Char]
"objects"[Char] -> Type -> FieldType
>: Int -> Type -> Type
minLengthList Int
2 Type
genericLiteralArgument],

      [Char] -> Type -> Element
def [Char]
"GenericLiteralMapNullableArgumentAndTraversalCardinalityArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"cardinality"[Char] -> Type -> FieldType
>: Type
traversalCardinalityArgument,
        [Char]
"object"[Char] -> Type -> FieldType
>: Type
genericLiteralMapNullableArgument],

-- traversalMethod_propertyMap
--     : 'propertyMap' LPAREN stringLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_range
--     : 'range' LPAREN traversalScopeArgument COMMA integerArgument COMMA integerArgument RPAREN #traversalMethod_range_Scope_long_long
--     | 'range' LPAREN integerArgument COMMA integerArgument RPAREN #traversalMethod_range_long_long
--     ;

      [Char] -> Type -> Element
def [Char]
"RangeArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"scope"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
        [Char]
"min"[Char] -> Type -> FieldType
>: Type
integerArgument,
        [Char]
"max"[Char] -> Type -> FieldType
>: Type
integerArgument],

-- traversalMethod_read
--     : 'read' LPAREN RPAREN
--     ;
--
-- traversalMethod_repeat
--     : 'repeat' LPAREN stringArgument COMMA nestedTraversal RPAREN #traversalMethod_repeat_String_Traversal
--     | 'repeat' LPAREN nestedTraversal RPAREN #traversalMethod_repeat_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"OptionalStringArgumentAndNestedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"string"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
stringArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

-- traversalMethod_reverse
--     : 'reverse' LPAREN RPAREN #traversalMethod_reverse_Empty
--     ;
--
-- traversalMethod_sack
--     : 'sack' LPAREN traversalBiFunctionArgument RPAREN #traversalMethod_sack_BiFunction
--     | 'sack' LPAREN RPAREN #traversalMethod_sack_Empty
--     ;
--
-- traversalMethod_sample
--     : 'sample' LPAREN traversalScopeArgument COMMA integerArgument RPAREN #traversalMethod_sample_Scope_int
--     | 'sample' LPAREN integerArgument RPAREN #traversalMethod_sample_int
--     ;

-- traversalMethod_select
--     : 'select' LPAREN traversalColumnArgument RPAREN #traversalMethod_select_Column
--     | 'select' LPAREN traversalPopArgument COMMA stringArgument RPAREN #traversalMethod_select_Pop_String
--     | 'select' LPAREN traversalPopArgument COMMA stringArgument COMMA stringArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_select_Pop_String_String_String
--     | 'select' LPAREN traversalPopArgument COMMA nestedTraversal RPAREN #traversalMethod_select_Pop_Traversal
--     | 'select' LPAREN stringArgument RPAREN #traversalMethod_select_String
--     | 'select' LPAREN stringArgument COMMA stringArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_select_String_String_String
--     | 'select' LPAREN nestedTraversal RPAREN #traversalMethod_select_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"SelectArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"column"[Char] -> Type -> FieldType
>: Type
traversalColumnArgument,
        [Char]
"popStrings"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"PopStringsArgument",
        [Char]
"popTraversal"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalPopArgumentAndNestedTraversal",
        [Char]
"strings"[Char] -> Type -> FieldType
>: Type -> Type
nonemptyList Type
stringArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

      [Char] -> Type -> Element
def [Char]
"PopStringsArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"pop"[Char] -> Type -> FieldType
>: Type
traversalPopArgument,
        [Char]
"string"[Char] -> Type -> FieldType
>: Type -> Type
nonemptyList Type
stringArgument],

      [Char] -> Type -> Element
def [Char]
"TraversalPopArgumentAndNestedTraversal" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"pop"[Char] -> Type -> FieldType
>: Type
traversalPopArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

-- traversalMethod_shortestPath
--     : 'shortestPath' LPAREN RPAREN
--     ;
--
-- traversalMethod_sideEffect
--     : 'sideEffect' LPAREN nestedTraversal RPAREN
--     ;
--
-- traversalMethod_simplePath
--     : 'simplePath' LPAREN RPAREN
--     ;
--
-- traversalMethod_skip
--     : 'skip' LPAREN traversalScopeArgument COMMA integerArgument RPAREN #traversalMethod_skip_Scope_long
--     | 'skip' LPAREN integerArgument RPAREN #traversalMethod_skip_long
--     ;

      [Char] -> Type -> Element
def [Char]
"OptionalTraversalScopeArgumentAndIntegerArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"scope"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
        [Char]
"long"[Char] -> Type -> FieldType
>: Type
integerArgument],

-- traversalMethod_store
--     : 'store' LPAREN stringArgument RPAREN
--     ;
--
-- traversalMethod_subgraph
--     : 'subgraph' LPAREN stringArgument RPAREN
--     ;
--
-- traversalMethod_sum
--     : 'sum' LPAREN RPAREN #traversalMethod_sum_Empty
--     | 'sum' LPAREN traversalScopeArgument RPAREN #traversalMethod_sum_Scope
--     ;
--
-- traversalMethod_tail
--     : 'tail' LPAREN RPAREN #traversalMethod_tail_Empty
--     | 'tail' LPAREN traversalScopeArgument RPAREN #traversalMethod_tail_Scope
--     | 'tail' LPAREN traversalScopeArgument COMMA integerArgument RPAREN #traversalMethod_tail_Scope_long
--     | 'tail' LPAREN integerArgument RPAREN #traversalMethod_tail_long
--     ;

      [Char] -> Type -> Element
def [Char]
"TailArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"scope"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
        [Char]
"integer"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
integerArgument],

-- traversalMethod_fail
--     : 'fail' LPAREN RPAREN #traversalMethod_fail_Empty
--     | 'fail' LPAREN stringArgument RPAREN #traversalMethod_fail_String
--     ;
--
-- traversalMethod_timeLimit
--     : 'timeLimit' LPAREN integerArgument RPAREN
--     ;
--
-- traversalMethod_times
--     : 'times' LPAREN integerArgument RPAREN
--     ;
--
-- traversalMethod_to
--     : 'to' LPAREN traversalDirectionArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_to_Direction_String
--     | 'to' LPAREN stringArgument RPAREN #traversalMethod_to_String
--     | 'to' LPAREN structureVertexArgument RPAREN #traversalMethod_to_Vertex
--     | 'to' LPAREN nestedTraversal RPAREN #traversalMethod_to_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"ToArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"direction"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"DirectionAndVarargs",
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringArgument,
        [Char]
"vertex"[Char] -> Type -> FieldType
>: Type
structureVertexArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

-- traversalMethod_toE
--     : 'toE' LPAREN traversalDirectionArgument (COMMA stringLiteralVarargs)? RPAREN
--     ;

      [Char] -> Type -> Element
def [Char]
"DirectionAndVarargs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"direction"[Char] -> Type -> FieldType
>: Type
traversalDirectionArgument,
        [Char]
"varargs"[Char] -> Type -> FieldType
>: Type
optionalStringLiteralVarargs],

-- traversalMethod_toV
--     : 'toV' LPAREN traversalDirectionArgument RPAREN
--     ;
--
-- traversalMethod_tree
--     : 'tree' LPAREN RPAREN #traversalMethod_tree_Empty
--     | 'tree' LPAREN stringArgument RPAREN #traversalMethod_tree_String
--     ;
--
-- traversalMethod_unfold
--     : 'unfold' LPAREN RPAREN
--     ;
--
-- traversalMethod_union
--     : 'union' LPAREN nestedTraversalList RPAREN
--     ;
--
-- traversalMethod_until
--     : 'until' LPAREN traversalPredicate RPAREN #traversalMethod_until_Predicate
--     | 'until' LPAREN nestedTraversal RPAREN #traversalMethod_until_Traversal
--     ;
--
-- traversalMethod_value
--     : 'value' LPAREN RPAREN
--     ;
--
-- traversalMethod_valueMap
--     : 'valueMap' LPAREN stringLiteralVarargs RPAREN #traversalMethod_valueMap_String
--     | 'valueMap' LPAREN booleanArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_valueMap_boolean_String
--     ;

      [Char] -> Type -> Element
def [Char]
"ValueMapArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs,
        [Char]
"boolean"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ValueMapBooleanArgs"],

      [Char] -> Type -> Element
def [Char]
"ValueMapBooleanArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"value"[Char] -> Type -> FieldType
>: Type
booleanArgument,
        [Char]
"keys"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
stringLiteralVarargs],

-- traversalMethod_values
--     : 'values' LPAREN stringLiteralVarargs RPAREN
--     ;
--
-- traversalMethod_where
--     : 'where' LPAREN traversalPredicate RPAREN #traversalMethod_where_P
--     | 'where' LPAREN stringArgument COMMA traversalPredicate RPAREN #traversalMethod_where_String_P
--     | 'where' LPAREN nestedTraversal RPAREN #traversalMethod_where_Traversal
--     ;

      [Char] -> Type -> Element
def [Char]
"WhereArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"predicate"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"WhereWithPredicateArgs",
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringArgument,
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal],

      [Char] -> Type -> Element
def [Char]
"WhereWithPredicateArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"leftArg"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
stringArgument,
        [Char]
"predicate"[Char] -> Type -> FieldType
>: Type
traversalPredicate],

-- traversalMethod_with
--     : 'with' LPAREN (withOptionKeys | stringArgument) RPAREN #traversalMethod_with_String
--     | 'with' LPAREN (withOptionKeys | stringArgument) COMMA (withOptionsValues | ioOptionsValues | genericLiteralArgument) RPAREN #traversalMethod_with_String_Object
--     ;

      [Char] -> Type -> Element
def [Char]
"WithArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"keys"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"WithArgsKeys",
        [Char]
"values"[Char] -> Type -> FieldType
>: Type -> Type
optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"WithArgsValues"],

      [Char] -> Type -> Element
def [Char]
"WithArgsKeys" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"withOption"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"WithOptionKeys",
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringArgument],

      [Char] -> Type -> Element
def [Char]
"WithArgsValues" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"withOptions"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"WithOptionsValues",
        [Char]
"io"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"IoOptionsValues",
        [Char]
"object"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument],

-- traversalMethod_write
--     : 'write' LPAREN RPAREN
--     ;
--
-- traversalMethod_element
--     : 'element' LPAREN RPAREN
--     ;
--
-- traversalMethod_call
--     : 'call' LPAREN stringArgument RPAREN #traversalMethod_call_string
--     | 'call' LPAREN stringArgument COMMA genericLiteralMapArgument RPAREN #traversalMethod_call_string_map
--     | 'call' LPAREN stringArgument COMMA nestedTraversal RPAREN #traversalMethod_call_string_traversal
--     | 'call' LPAREN stringArgument COMMA genericLiteralMapArgument COMMA nestedTraversal RPAREN #traversalMethod_call_string_map_traversal
--     ;

-- traversalMethod_concat
--     : 'concat' LPAREN nestedTraversal (COMMA nestedTraversalList)? RPAREN #traversalMethod_concat_Traversal_Traversal
--     | 'concat' LPAREN stringLiteralVarargs RPAREN #traversalMethod_concat_String
--     ;

      [Char] -> Type -> Element
def [Char]
"ConcatArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type -> Type
nonemptyList (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ Type
nestedTraversal,
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringLiteralVarargs],

-- traversalMethod_asString
--     : 'asString' LPAREN RPAREN #traversalMethod_asString_Empty
--     | 'asString' LPAREN traversalScopeArgument RPAREN #traversalMethod_asString_Scope
--     ;
--
-- traversalMethod_format
--     : 'format' LPAREN stringArgument RPAREN #traversalMethod_format_String
--     ;
--
-- traversalMethod_toUpper
--     : 'toUpper' LPAREN RPAREN #traversalMethod_toUpper_Empty
--     | 'toUpper' LPAREN traversalScopeArgument RPAREN #traversalMethod_toUpper_Scope
--     ;
--
-- traversalMethod_toLower
--     : 'toLower' LPAREN RPAREN #traversalMethod_toLower_Empty
--     | 'toLower' LPAREN traversalScopeArgument RPAREN #traversalMethod_toLower_Scope
--     ;
--
-- traversalMethod_length
--     : 'length' LPAREN RPAREN #traversalMethod_length_Empty
--     | 'length' LPAREN traversalScopeArgument RPAREN #traversalMethod_length_Scope
--     ;
--
-- traversalMethod_trim
--     : 'trim' LPAREN RPAREN #traversalMethod_trim_Empty
--     | 'trim' LPAREN traversalScopeArgument RPAREN #traversalMethod_trim_Scope
--     ;
--
-- traversalMethod_lTrim
--     : 'lTrim' LPAREN RPAREN #traversalMethod_lTrim_Empty
--     | 'lTrim' LPAREN traversalScopeArgument RPAREN #traversalMethod_lTrim_Scope
--     ;
--
-- traversalMethod_rTrim
--     : 'rTrim' LPAREN RPAREN #traversalMethod_rTrim_Empty
--     | 'rTrim' LPAREN traversalScopeArgument RPAREN #traversalMethod_rTrim_Scope
--     ;
--
-- traversalMethod_replace
--     : 'replace' LPAREN stringNullableArgument COMMA stringNullableArgument RPAREN #traversalMethod_replace_String_String
--     | 'replace' LPAREN traversalScopeArgument COMMA stringNullableArgument COMMA stringNullableArgument RPAREN #traversalMethod_replace_Scope_String_String
--     ;

      [Char] -> Type -> Element
def [Char]
"ReplaceArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"scope"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
        [Char]
"from"[Char] -> Type -> FieldType
>: Type
stringNullableArgument,
        [Char]
"to"[Char] -> Type -> FieldType
>: Type
stringNullableArgument],

--
-- traversalMethod_split
--     : 'split' LPAREN stringNullableArgument RPAREN #traversalMethod_split_String
--     | 'split' LPAREN traversalScopeArgument COMMA stringNullableArgument RPAREN #traversalMethod_split_Scope_String
--     ;

      [Char] -> Type -> Element
def [Char]
"SplitArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"scope"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
        [Char]
"delimiter"[Char] -> Type -> FieldType
>: Type
stringNullableArgument],

--
-- traversalMethod_substring
--     : 'substring' LPAREN integerArgument RPAREN #traversalMethod_substring_int
--     | 'substring' LPAREN traversalScopeArgument COMMA integerArgument RPAREN #traversalMethod_substring_Scope_int
--     | 'substring' LPAREN integerArgument COMMA integerArgument RPAREN #traversalMethod_substring_int_int
--     | 'substring' LPAREN traversalScopeArgument COMMA integerArgument COMMA integerArgument RPAREN #traversalMethod_substring_Scope_int_int
--     ;

      [Char] -> Type -> Element
def [Char]
"SubstringArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"scope"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
traversalScopeArgument,
        [Char]
"start"[Char] -> Type -> FieldType
>: Type
integerArgument,
        [Char]
"end"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
integerArgument],

-- traversalMethod_asDate
--     : 'asDate' LPAREN RPAREN
--     ;
--
-- traversalMethod_dateAdd
--     : 'dateAdd' LPAREN traversalDTArgument COMMA integerArgument RPAREN
--     ;

      [Char] -> Type -> Element
def [Char]
"DateAddArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"unit"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalDTArgument",
        [Char]
"duration"[Char] -> Type -> FieldType
>: Type
integerArgument],

-- traversalMethod_dateDiff
--     : 'dateDiff' LPAREN nestedTraversal RPAREN #traversalMethod_dateDiff_Traversal
--     | 'dateDiff' LPAREN dateArgument RPAREN #traversalMethod_dateDiff_Date
--     ;

      [Char] -> Type -> Element
def [Char]
"DateDiffArgs" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"traversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
        [Char]
"date"[Char] -> Type -> FieldType
>: Type
dateArgument],

-- /*********************************************
--     ARGUMENT AND TERMINAL RULES
-- **********************************************/
--
-- // There is syntax available in the construction of a ReferenceVertex, that allows the label to not be specified.
-- // That use case is related to OLAP when the StarGraph does not preserve the label of adjacent vertices or other
-- // fail fast scenarios in that processing model. It is not relevant to the grammar however when a user is creating
-- // the Vertex to be used in a Traversal and therefore both id and label are required.
-- structureVertex
--     : NEW? ('Vertex'|'ReferenceVertex') LPAREN genericLiteralArgument COMMA stringArgument RPAREN
--     ;

      [Char] -> Type -> Element
def [Char]
"StructureVertex" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"new"[Char] -> Type -> FieldType
>: Type
boolean,
        [Char]
"id"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
        [Char]
"label"[Char] -> Type -> FieldType
>: Type
stringArgument],

-- traversalStrategy
--     : NEW? classType (LPAREN (configuration (COMMA configuration)*)? RPAREN)?
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalStrategy" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"new"[Char] -> Type -> FieldType
>: Type
boolean,
        [Char]
"class"[Char] -> Type -> FieldType
>: Type
classType,
        [Char]
"configurations"[Char] -> Type -> FieldType
>: Type -> Type
list (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"Configuration"],

-- configuration
--     : keyword COLON genericLiteralArgument
--     | Identifier COLON genericLiteralArgument
--     ;

      [Char] -> Type -> Element
def [Char]
"Configuration" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"key"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"KeywordOrIdentifier",
        [Char]
"value"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument],

      [Char] -> Type -> Element
def [Char]
"KeywordOrIdentifier" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"keyword"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"Keyword",
        [Char]
"identifier"[Char] -> Type -> FieldType
>: Type
identifier],

-- traversalScope
--     : 'local' | 'Scope.local'
--     | 'global' | 'Scope.global'
--     ;
      [Char] -> Type -> Element
def [Char]
"TraversalScope" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"local",
        [Char]
"global"],

-- traversalBarrier
--     : 'normSack' | 'Barrier.normSack'
--     ;

-- traversalToken
--     : 'id' | 'T.id'
--     | 'label' | 'T.label'
--     | 'key' | 'T.key'
--     | 'value' | 'T.value'
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalToken" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"id",
        [Char]
"label",
        [Char]
"key",
        [Char]
"value"],

-- traversalMerge
--     : 'onCreate' | 'Merge.onCreate'
--     | 'onMatch' | 'Merge.onMatch'
--     | 'outV' | 'Merge.outV'
--     | 'inV' | 'Merge.inV'
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalMerge" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"onCreate",
        [Char]
"onMatch",
        [Char]
"outV",
        [Char]
"inV"],

-- traversalOrder
--     : 'incr' | 'Order.incr'
--     | 'decr' | 'Order.decr'
--     | 'asc'  | 'Order.asc'
--     | 'desc' | 'Order.desc'
--     | 'shuffle' | 'Order.shuffle'
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalOrder" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"incr",
        [Char]
"decr",
        [Char]
"asc",
        [Char]
"desc",
        [Char]
"shuffle"],

-- traversalDirection
--     : 'IN' | 'Direction.IN' | 'Direction.from' | 'from'
--     | 'OUT' | 'Direction.OUT' | 'Direction.to' | 'to'
--     | 'BOTH' | 'Direction.BOTH'
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalDirection" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"in",
        [Char]
"out",
        [Char]
"both"],

-- traversalCardinality
--     : 'Cardinality.single' LPAREN genericLiteral RPAREN
--     | 'Cardinality.set' LPAREN genericLiteral RPAREN
--     | 'Cardinality.list' LPAREN genericLiteral RPAREN
--     | 'single' LPAREN genericLiteral RPAREN
--     | 'set' LPAREN genericLiteral RPAREN
--     | 'list' LPAREN genericLiteral RPAREN
--     | 'single' | 'Cardinality.single'
--     | 'set' | 'Cardinality.set'
--     | 'list' | 'Cardinality.list'
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalCardinality" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"single"[Char] -> Type -> FieldType
>: Type
genericLiteral,
        [Char]
"set"[Char] -> Type -> FieldType
>: Type
genericLiteral,
        [Char]
"list"[Char] -> Type -> FieldType
>: Type
genericLiteral],

-- traversalColumn
--     : KEYS | 'Column.keys'
--     | VALUES | 'Column.values'
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalColumn" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"keys",
        [Char]
"values"],

-- traversalPop
--     : 'first' | 'Pop.first'
--     | 'last' | 'Pop.last'
--     | 'all' | 'Pop.all'
--     | 'mixed' | 'Pop.mixed'
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalPop" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"first",
        [Char]
"last",
        [Char]
"all",
        [Char]
"mixed"],

-- traversalOperator
--     : 'addAll' | 'Operator.addAll'
--     | 'and' | 'Operator.and'
--     | 'assign' | 'Operator.assign'
--     | 'div' | 'Operator.div'
--     | 'max' | 'Operator.max'
--     | 'min' | 'Operator.min'
--     | 'minus' | 'Operator.minus'
--     | 'mult' | 'Operator.mult'
--     | 'or' | 'Operator.or'
--     | 'sum' | 'Operator.sum'
--     | 'sumLong' | 'Operator.sumLong'
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalOperator" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"addAll",
        [Char]
"and",
        [Char]
"assign",
        [Char]
"div",
        [Char]
"max",
        [Char]
"min",
        [Char]
"minus",
        [Char]
"mult",
        [Char]
"or",
        [Char]
"sum",
        [Char]
"sumLong"],

-- traversalPick
--     : 'any' | 'Pick.any'
--     | 'none' | 'Pick.none'
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalPick" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"any",
        [Char]
"none"],

-- traversalDT
--     : 'second' | 'DT.second'
--     | 'minute' | 'DT.minute'
--     | 'hour' | 'DT.hour'
--     | 'day' | 'DT.day'
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalDT" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"second",
        [Char]
"minute",
        [Char]
"hour",
        [Char]
"day"],

-- traversalPredicate
      [Char] -> Type -> Element
def [Char]
"TraversalPredicate" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
--     : traversalPredicate_eq
        [Char]
"eq"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalPredicate_neq
        [Char]
"neq"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalPredicate_lt
        [Char]
"lt"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalPredicate_lte
        [Char]
"lte"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalPredicate_gt
        [Char]
"gt"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalPredicate_gte
        [Char]
"gte"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
--     | traversalPredicate_inside
        [Char]
"inside"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"RangeArgument",
--     | traversalPredicate_outside
        [Char]
"outside"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"RangeArgument",
--     | traversalPredicate_between
        [Char]
"between"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"RangeArgument",
--     | traversalPredicate_within
        [Char]
"within"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
genericLiteralArgument,
--     | traversalPredicate_without
        [Char]
"without"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
genericLiteralArgument,
--     | traversalPredicate_not
        [Char]
"not"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
--     | traversalPredicate_startingWith
        [Char]
"startingWith"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalPredicate_notStartingWith
        [Char]
"notStartingWith"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalPredicate_endingWith
        [Char]
"endingWith"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalPredicate_notEndingWith
        [Char]
"notEndingWith"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalPredicate_containing
        [Char]
"containing"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalPredicate_notContaining
        [Char]
"notContaining"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalPredicate_regex
        [Char]
"regex"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalPredicate_notRegex
        [Char]
"notRegex"[Char] -> Type -> FieldType
>: Type
stringArgument,
--     | traversalPredicate DOT 'and' LPAREN traversalPredicate RPAREN
        [Char]
"and"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TwoTraversalPredicates",
--     | traversalPredicate DOT 'or' LPAREN traversalPredicate RPAREN
        [Char]
"or"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TwoTraversalPredicates",
--     | traversalPredicate DOT 'negate' LPAREN RPAREN
        [Char]
"negate"[Char] -> Type -> FieldType
>: Type
traversalPredicate],
--     ;

      [Char] -> Type -> Element
def [Char]
"TwoTraversalPredicates" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"left"[Char] -> Type -> FieldType
>: Type
traversalPredicate,
        [Char]
"right"[Char] -> Type -> FieldType
>: Type
traversalPredicate],

-- traversalTerminalMethod
      [Char] -> Type -> Element
def [Char]
"TraversalTerminalMethod" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [ -- TODO
--     : traversalTerminalMethod_explain
        [Char]
"explain"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalTerminalMethod_iterate
        [Char]
"iterate"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalTerminalMethod_hasNext
        [Char]
"hasNext"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalTerminalMethod_tryNext
        [Char]
"tryNext"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalTerminalMethod_next
        [Char]
"next"[Char] -> Type -> FieldType
>: Type -> Type
optional Type
integerLiteral,
--     | traversalTerminalMethod_toList
        [Char]
"toList"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalTerminalMethod_toSet
        [Char]
"toSet"[Char] -> Type -> FieldType
>: Type
unit,
--     | traversalTerminalMethod_toBulkSet
        [Char]
"toBulkSet"[Char] -> Type -> FieldType
>: Type
unit],
--     ;

-- traversalSackMethod
--     : traversalBarrier
--     ;

-- traversalSelfMethod
      [Char] -> Type -> Element
def [Char]
"TraversalSelfMethod" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
--     : traversalSelfMethod_discard
        [Char]
"discard"],
--     ;

-- // Additional special rules that are derived from above
-- // These are used to restrict broad method signatures that accept lambdas
-- // to a smaller set.
-- traversalComparator
--     : traversalOrder
--     ;

-- traversalFunction
--     : traversalToken
--     | traversalColumn
--     ;

      [Char] -> Type -> Element
def [Char]
"TraversalFunction" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"token"[Char] -> Type -> FieldType
>: Type
traversalToken,
        [Char]
"column"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"TraversalColumn"],

-- traversalBiFunction
--     : traversalOperator
--     ;
--
-- traversalPredicate_eq
--     : ('P.eq' | 'eq') LPAREN genericLiteralArgument RPAREN
--     ;
--
-- traversalPredicate_neq
--     : ('P.neq' | 'neq') LPAREN genericLiteralArgument RPAREN
--     ;
--
-- traversalPredicate_lt
--     : ('P.lt' | 'lt') LPAREN genericLiteralArgument RPAREN
--     ;
--
-- traversalPredicate_lte
--     : ('P.lte' | 'lte') LPAREN genericLiteralArgument RPAREN
--     ;
--
-- traversalPredicate_gt
--     : ('P.gt' | 'gt') LPAREN genericLiteralArgument RPAREN
--     ;
--
-- traversalPredicate_gte
--     : ('P.gte' | 'gte') LPAREN genericLiteralArgument RPAREN
--     ;
--
-- traversalPredicate_inside
--     : ('P.inside' | 'inside') LPAREN genericLiteralArgument COMMA genericLiteralArgument RPAREN
--     ;
--
-- traversalPredicate_outside
--     : ('P.outside' | 'outside') LPAREN genericLiteralArgument COMMA genericLiteralArgument RPAREN
--     ;

      [Char] -> Type -> Element
def [Char]
"RangeArgument" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"min"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument,
        [Char]
"max"[Char] -> Type -> FieldType
>: Type
genericLiteralArgument],

-- traversalPredicate_between
--     : ('P.between' | 'between') LPAREN genericLiteralArgument COMMA genericLiteralArgument RPAREN
--     ;
--
-- traversalPredicate_within
--     : ('P.within' | 'within') LPAREN RPAREN
--     | ('P.within' | 'within') LPAREN genericLiteralListArgument RPAREN
--     ;
--
-- traversalPredicate_without
--     : ('P.without' | 'without') LPAREN RPAREN
--     | ('P.without' | 'without') LPAREN genericLiteralListArgument RPAREN
--     ;
--
-- traversalPredicate_not
--     : ('P.not' | 'not') LPAREN traversalPredicate RPAREN
--     ;
--
-- traversalPredicate_containing
--     : ('TextP.containing' | 'containing') LPAREN stringArgument RPAREN
--     ;
--
-- traversalPredicate_notContaining
--     : ('TextP.notContaining' | 'notContaining') LPAREN stringArgument RPAREN
--     ;
--
-- traversalPredicate_startingWith
--     : ('TextP.startingWith' | 'startingWith') LPAREN stringArgument RPAREN
--     ;
--
-- traversalPredicate_notStartingWith
--     : ('TextP.notStartingWith' | 'notStartingWith') LPAREN stringArgument RPAREN
--     ;
--
-- traversalPredicate_endingWith
--     : ('TextP.endingWith' | 'endingWith') LPAREN stringArgument RPAREN
--     ;
--
-- traversalPredicate_notEndingWith
--     : ('TextP.notEndingWith' | 'notEndingWith') LPAREN stringArgument RPAREN
--     ;
--
-- traversalPredicate_regex
--     : ('TextP.regex' | 'regex') LPAREN stringArgument RPAREN
--     ;
--
-- traversalPredicate_notRegex
--     : ('TextP.notRegex' | 'notRegex') LPAREN stringArgument RPAREN
--     ;
--
-- traversalTerminalMethod_explain
--     : 'explain' LPAREN RPAREN
--     ;
--
-- traversalTerminalMethod_hasNext
--     : 'hasNext' LPAREN RPAREN
--     ;
--
-- traversalTerminalMethod_iterate
--     : 'iterate' LPAREN RPAREN
--     ;
--
-- traversalTerminalMethod_tryNext
--     : 'tryNext' LPAREN RPAREN
--     ;
--
-- traversalTerminalMethod_next
--     : 'next' LPAREN RPAREN
--     | 'next' LPAREN integerLiteral RPAREN
--     ;
--
-- traversalTerminalMethod_toList
--     : 'toList' LPAREN RPAREN
--     ;
--
-- traversalTerminalMethod_toSet
--     : 'toSet' LPAREN RPAREN
--     ;
--
-- traversalTerminalMethod_toBulkSet
--     : 'toBulkSet' LPAREN RPAREN
--     ;
--
-- traversalSelfMethod_discard
--     : 'discard' LPAREN RPAREN
--     ;
--
-- // Gremlin specific lexer rules
--
-- withOptionKeys
--     : shortestPathConstants
--     | connectedComponentConstants
--     | pageRankConstants
--     | peerPressureConstants
--     | ioOptionsKeys
--     | withOptionsConstants_tokens
--     | withOptionsConstants_indexer
--     ;

      [Char] -> Type -> Element
def [Char]
"WithOptionKeys" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"shortestPath"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ShortestPathConstants",
        [Char]
"connectedComponent"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"ConnectedComponentConstants",
        [Char]
"pageRank"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"PageRankConstants",
        [Char]
"peerPressure"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"PeerPressureConstants",
        [Char]
"io"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"IoOptionsKeys",
        [Char]
"withOptionsTokens"[Char] -> Type -> FieldType
>: Type
unit,
        [Char]
"withOptionsIndexer"[Char] -> Type -> FieldType
>: Type
unit],

-- connectedComponentConstants
--     : connectedComponentConstants_component
--     | connectedComponentConstants_edges
--     | connectedComponentConstants_propertyName
--     ;

      [Char] -> Type -> Element
def [Char]
"ConnectedComponentConstants" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"component",
        [Char]
"edges",
        [Char]
"propertyName"],

-- pageRankConstants
--     : pageRankConstants_edges
--     | pageRankConstants_times
--     | pageRankConstants_propertyName
--     ;

      [Char] -> Type -> Element
def [Char]
"PageRankConstants" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"edges",
        [Char]
"times",
        [Char]
"propertyName"],

-- peerPressureConstants
--     : peerPressureConstants_edges
--     | peerPressureConstants_times
--     | peerPressureConstants_propertyName
--     ;

      [Char] -> Type -> Element
def [Char]
"PeerPressureConstants" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"edges",
        [Char]
"times",
        [Char]
"propertyName"],

-- shortestPathConstants
--     : shortestPathConstants_target
--     | shortestPathConstants_edges
--     | shortestPathConstants_distance
--     | shortestPathConstants_maxDistance
--     | shortestPathConstants_includeEdges
--     ;

      [Char] -> Type -> Element
def [Char]
"ShortestPathConstants" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"target",
        [Char]
"edges",
        [Char]
"distance",
        [Char]
"maxDistance",
        [Char]
"includeEdges"],

-- withOptionsValues
--     : withOptionsConstants_tokens
--     | withOptionsConstants_none
--     | withOptionsConstants_ids
--     | withOptionsConstants_labels
--     | withOptionsConstants_keys
--     | withOptionsConstants_values
--     | withOptionsConstants_all
--     | withOptionsConstants_list
--     | withOptionsConstants_map
--     ;

      [Char] -> Type -> Element
def [Char]
"WithOptionsValues" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"tokens",
        [Char]
"none",
        [Char]
"ids",
        [Char]
"labels",
        [Char]
"keys",
        [Char]
"values",
        [Char]
"all",
        [Char]
"list",
        [Char]
"map"],

-- ioOptionsKeys
--     : ioOptionsConstants_reader
--     | ioOptionsConstants_writer
--     ;

      [Char] -> Type -> Element
def [Char]
"IoOptionsKeys" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"reader",
        [Char]
"writer"],

-- ioOptionsValues
--     : ioOptionsConstants_gryo
--     | ioOptionsConstants_graphson
--     | ioOptionsConstants_graphml
--     ;

      [Char] -> Type -> Element
def [Char]
"IoOptionsValues" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"gryo",
        [Char]
"graphson",
        [Char]
"graphml"],

-- connectedComponentConstants_component
--     : connectedComponentStringConstant DOT 'component'
--     ;
--
-- connectedComponentConstants_edges
--     : connectedComponentStringConstant DOT EDGES
--     ;
--
-- connectedComponentConstants_propertyName
--     : connectedComponentStringConstant DOT 'propertyName'
--     ;
--
-- pageRankConstants_edges
--     : pageRankStringConstant DOT EDGES
--     ;
--
-- pageRankConstants_times
--     : pageRankStringConstant DOT 'times'
--     ;
--
-- pageRankConstants_propertyName
--     : pageRankStringConstant DOT 'propertyName'
--     ;
--
-- peerPressureConstants_edges
--     : peerPressureStringConstant DOT EDGES
--     ;
--
-- peerPressureConstants_times
--     : peerPressureStringConstant DOT 'times'
--     ;
--
-- peerPressureConstants_propertyName
--     : peerPressureStringConstant DOT 'propertyName'
--     ;
--
-- shortestPathConstants_target
--     : shortestPathStringConstant DOT 'target'
--     ;
--
-- shortestPathConstants_edges
--     : shortestPathStringConstant DOT EDGES
--     ;
--
-- shortestPathConstants_distance
--     : shortestPathStringConstant DOT 'distance'
--     ;
--
-- shortestPathConstants_maxDistance
--     : shortestPathStringConstant DOT 'maxDistance'
--     ;
--
-- shortestPathConstants_includeEdges
--     : shortestPathStringConstant DOT 'includeEdges'
--     ;
--
-- withOptionsConstants_tokens
--     : withOptionsStringConstant DOT 'tokens'
--     ;
--
-- withOptionsConstants_none
--     : withOptionsStringConstant DOT 'none'
--     ;
--
-- withOptionsConstants_ids
--     : withOptionsStringConstant DOT 'ids'
--     ;
--
-- withOptionsConstants_labels
--     : withOptionsStringConstant DOT 'labels'
--     ;
--
-- withOptionsConstants_keys
--     : withOptionsStringConstant DOT 'keys'
--     ;
--
-- withOptionsConstants_values
--     : withOptionsStringConstant DOT 'values'
--     ;
--
-- withOptionsConstants_all
--     : withOptionsStringConstant DOT 'all'
--     ;
--
-- withOptionsConstants_indexer
--     : withOptionsStringConstant DOT 'indexer'
--     ;
--
-- withOptionsConstants_list
--     : withOptionsStringConstant DOT 'list'
--     ;
--
-- withOptionsConstants_map
--     : withOptionsStringConstant DOT 'map'
--     ;
--
-- ioOptionsConstants_reader
--     : ioOptionsStringConstant DOT 'reader'
--     ;
--
-- ioOptionsConstants_writer
--     : ioOptionsStringConstant DOT 'writer'
--     ;
--
-- ioOptionsConstants_gryo
--     : ioOptionsStringConstant DOT 'gryo'
--     ;
--
-- ioOptionsConstants_graphson
--     : ioOptionsStringConstant DOT 'graphson'
--     ;
--
-- ioOptionsConstants_graphml
--     : ioOptionsStringConstant DOT 'graphml'
--     ;
--
-- connectedComponentStringConstant
--     : 'ConnectedComponent'
--     ;
--
-- pageRankStringConstant
--     : 'PageRank'
--     ;
--
-- peerPressureStringConstant
--     : 'PeerPressure'
--     ;
--
-- shortestPathStringConstant
--     : 'ShortestPath'
--     ;
--
-- withOptionsStringConstant
--     : 'WithOptions'
--     ;
--
-- ioOptionsStringConstant
--     : 'IO'
--     ;
--
-- booleanArgument
--     : booleanLiteral
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"BooleanArgument" Type
booleanLiteral,

-- integerArgument
--     : integerLiteral
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"IntegerArgument" Type
integerLiteral,

--
-- floatArgument
--     : floatLiteral
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"FloatArgument" Type
floatLiteral,

-- stringArgument
--     : stringLiteral
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"StringArgument" Type
stringLiteral,

-- stringNullableArgument
--     : stringNullableLiteral
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"StringNullableArgument" Type
stringNullableLiteral,

-- dateArgument
--     : dateLiteral
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"DateArgument" Type
dateLiteral,

-- genericLiteralArgument
--     : genericLiteral
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"GenericLiteralArgument" Type
genericLiteral,

-- genericLiteralListArgument
--     : genericLiteralList
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"GenericLiteralListArgument" Type
genericLiteralList,

-- genericLiteralMapArgument
--     : genericLiteralMap
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"GenericLiteralMapArgument" Type
genericLiteralMap,

-- genericLiteralMapNullableArgument
--     : genericLiteralMap
--     | nullLiteral
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"GenericLiteralMapNullableArgument" (Type -> Type
optional Type
genericLiteralMap),

-- structureVertexArgument
--     : structureVertex
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"StructureVertexArgument" Type
structureVertex,

-- traversalCardinalityArgument
--     : traversalCardinality
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalCardinalityArgument" Type
traversalCardinality,

-- traversalColumnArgument
--     : traversalColumn
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalColumnArgument" Type
traversalColumn,

-- traversalDirectionArgument
--     : traversalDirection
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalDirectionArgument" Type
traversalDirection,

-- traversalMergeArgument
--     : traversalMerge
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalMergeArgument" Type
traversalMerge,

-- traversalOrderArgument
--     : traversalOrder
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalOrderArgument" Type
traversalOrder,

-- traversalPopArgument
--     : traversalPop
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalPopArgument" Type
traversalPop,

-- traversalSackMethodArgument
--     : traversalSackMethod
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalSackMethodArgument" Type
traversalSackMethod,

-- traversalScopeArgument
--     : traversalScope
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalScopeArgument" Type
traversalScope,

-- traversalTokenArgument
--     : traversalToken
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalTokenArgument" Type
traversalToken,

-- traversalComparatorArgument
--     : traversalComparator
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalComparatorArgument" Type
traversalComparator,

-- traversalFunctionArgument
--     : traversalFunction
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalFunctionArgument" Type
traversalFunction,

-- traversalBiFunctionArgument
--     : traversalBiFunction
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalBiFunctionArgument" Type
traversalOperator,

-- traversalDTArgument
--     : traversalDT
--     | variable
--     ;

      [Char] -> Type -> Element
defArgument [Char]
"TraversalDTArgument" Type
traversalDT,

-- traversalStrategyList
--     : traversalStrategyExpr?
--     ;
--
-- traversalStrategyExpr
--     : traversalStrategy (COMMA traversalStrategy)*
--     ;
--
-- classTypeList
--     : classTypeExpr?
--     ;
--
-- classTypeExpr
--     : classType (COMMA classType)*
--     ;
--
-- nestedTraversalList
--     : nestedTraversalExpr?
--     ;

      -- Use: nestedTraversalList

-- nestedTraversalExpr
--     : nestedTraversal (COMMA nestedTraversal)*
--     ;
--
-- genericLiteralVarargs
--     : (genericLiteralArgument (COMMA genericLiteralArgument)*)?
--     ;

-- genericLiteralList
--     : genericLiteralExpr?
--     ;

      [Char] -> Type -> Element
def [Char]
"GenericLiteralList" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ Type -> Type
list Type
genericLiteral,

-- genericLiteralExpr
--     : genericLiteral (COMMA genericLiteral)*
--     ;
--
-- genericLiteralRange
--     : integerLiteral DOT DOT integerLiteral
--     | stringLiteral DOT DOT stringLiteral
--     ;

      [Char] -> Type -> Element
def [Char]
"GenericLiteralRange" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"integer"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"IntegerRange",
        [Char]
"string"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"StringRange"],

      [Char] -> Type -> Element
def [Char]
"IntegerRange" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"left"[Char] -> Type -> FieldType
>: Type
integerLiteral,
        [Char]
"right"[Char] -> Type -> FieldType
>: Type
integerLiteral],

      [Char] -> Type -> Element
def [Char]
"StringRange" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
record [
        [Char]
"left"[Char] -> Type -> FieldType
>: Type
stringLiteral,
        [Char]
"right"[Char] -> Type -> FieldType
>: Type
stringLiteral],

-- genericLiteralSet
--     : LBRACE (genericLiteral (COMMA genericLiteral)*)? RBRACE
--     ;

      [Char] -> Type -> Element
def [Char]
"GenericLiteralSet" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ Type -> Type
list Type
genericLiteral,

-- genericLiteralCollection
--     : LBRACK (genericLiteral (COMMA genericLiteral)*)? RBRACK
--     ;

      [Char] -> Type -> Element
def [Char]
"GenericLiteralCollection" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ Type -> Type
list Type
genericLiteral,

-- stringLiteralVarargs
--     : (stringNullableArgument (COMMA stringNullableArgument)*)?
--     ;

      -- Use: stringLiteralVarargs

-- stringLiteralList
--     : stringLiteralExpr?
--     | LBRACK stringLiteralExpr? RBRACK
--     ;
--
-- stringLiteralExpr
--     : stringNullableLiteral (COMMA stringNullableLiteral)*
--     ;
--
-- genericLiteral
      [Char] -> Type -> Element
def [Char]
"GenericLiteral" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
--     : numericLiteral
        [Char]
"numeric"[Char] -> Type -> FieldType
>: Type
numericLiteral,
--     | booleanLiteral
        [Char]
"boolean"[Char] -> Type -> FieldType
>: Type
booleanLiteral,
--     | stringLiteral
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringLiteral,
--     | dateLiteral
        [Char]
"date"[Char] -> Type -> FieldType
>: Type
dateLiteral,
--     | nullLiteral
        [Char]
"null"[Char] -> Type -> FieldType
>: Type
unit,
--     | nanLiteral
        [Char]
"nan"[Char] -> Type -> FieldType
>: Type
unit,
--     | infLiteral
        [Char]
"inf"[Char] -> Type -> FieldType
>: Type
unit,
--     // Allow the generic literal to match specific gremlin tokens also
--     | traversalToken
        [Char]
"traversalToken"[Char] -> Type -> FieldType
>: Type
traversalToken,
--     | traversalCardinality
        [Char]
"traversalCardinality"[Char] -> Type -> FieldType
>: Type
traversalCardinality,
--     | traversalDirection
        [Char]
"traversalDirection"[Char] -> Type -> FieldType
>: Type
traversalDirection,
--     | traversalMerge
        [Char]
"traversalMerge"[Char] -> Type -> FieldType
>: Type
traversalMerge,
--     | traversalPick
        [Char]
"traversalPick"[Char] -> Type -> FieldType
>: Type
traversalPick,
--     | traversalDT
        [Char]
"traversalDT"[Char] -> Type -> FieldType
>: Type
traversalDT,
--     | structureVertex
        [Char]
"structureVertex"[Char] -> Type -> FieldType
>: Type
structureVertex,
--     | genericLiteralSet
        [Char]
"genericLiteralSet"[Char] -> Type -> FieldType
>: Type
genericLiteralSet,
--     | genericLiteralCollection
        [Char]
"genericLiteralCollection"[Char] -> Type -> FieldType
>: Type
genericLiteralCollection,
--     | genericLiteralRange
        [Char]
"genericLiteralRange"[Char] -> Type -> FieldType
>: Type
genericLiteralRange,
--     | nestedTraversal
        [Char]
"nestedTraversal"[Char] -> Type -> FieldType
>: Type
nestedTraversal,
--     | terminatedTraversal
        [Char]
"terminatedTraversal"[Char] -> Type -> FieldType
>: Type
terminatedTraversal,
--     | genericLiteralMap
        [Char]
"genericLiteralMap"[Char] -> Type -> FieldType
>: Type
genericLiteralMap],
--     ;

-- genericLiteralMap
--     : LBRACK COLON RBRACK
--     | LBRACK mapEntry (COMMA mapEntry)* RBRACK
--     ;

      [Char] -> Type -> Element
def [Char]
"GenericLiteralMap" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ Type -> Type
list (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ [Char] -> Type
gremlin [Char]
"MapEntry",

-- // allow builds of Map that sorta make sense in the Gremlin context.
-- mapEntry
--     : (LPAREN stringLiteral RPAREN | stringLiteral) COLON genericLiteral
--     | (LPAREN numericLiteral RPAREN | numericLiteral) COLON genericLiteral
--     | (LPAREN traversalToken RPAREN | traversalToken) COLON genericLiteral
--     | (LPAREN traversalDirection RPAREN | traversalDirection) COLON genericLiteral
--     | (LPAREN genericLiteralSet RPAREN | genericLiteralSet) COLON genericLiteral
--     | (LPAREN genericLiteralCollection RPAREN | genericLiteralCollection) COLON genericLiteral
--     | (LPAREN genericLiteralMap RPAREN | genericLiteralMap) COLON genericLiteral
--     | keyword COLON genericLiteral
--     | Identifier COLON genericLiteral
--     ;

      [Char] -> Type -> Element
def [Char]
"MapEntry" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"key"[Char] -> Type -> FieldType
>: [Char] -> Type
gremlin [Char]
"MapKey",
        [Char]
"value"[Char] -> Type -> FieldType
>: Type
genericLiteral],

      [Char] -> Type -> Element
def [Char]
"MapKey" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"string"[Char] -> Type -> FieldType
>: Type
stringLiteral,
        [Char]
"numeric"[Char] -> Type -> FieldType
>: Type
numericLiteral,
        [Char]
"traversalToken"[Char] -> Type -> FieldType
>: Type
traversalToken,
        [Char]
"traversalDirection"[Char] -> Type -> FieldType
>: Type
traversalDirection,
        [Char]
"set"[Char] -> Type -> FieldType
>: Type
genericLiteralSet,
        [Char]
"collection"[Char] -> Type -> FieldType
>: Type
genericLiteralCollection,
        [Char]
"map"[Char] -> Type -> FieldType
>: Type
genericLiteralMap,
        [Char]
"keyword"[Char] -> Type -> FieldType
>: Type
keyword,
        [Char]
"identifier"[Char] -> Type -> FieldType
>: Type
identifier],

-- stringLiteral
--     : EmptyStringLiteral
--     | NonEmptyStringLiteral
--     ;

      -- Use: stringLiteral

-- stringNullableLiteral
--     : EmptyStringLiteral
--     | NonEmptyStringLiteral
--     | NullLiteral
--     ;

      -- Use: stringNullableLiteral

-- integerLiteral
--     : IntegerLiteral
--     ;

      [Char] -> Type -> Element
def [Char]
"IntegerLiteral" Type
bigint,

--
-- floatLiteral
--     : FloatingPointLiteral
--     ;

      [Char] -> Type -> Element
def [Char]
"FloatLiteral" Type
bigfloat,

-- numericLiteral
--     : integerLiteral
--     | floatLiteral
--     ;

      [Char] -> Type -> Element
def [Char]
"NumericLiteral" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [FieldType] -> Type
union [
        [Char]
"integer"[Char] -> Type -> FieldType
>: Type
integerLiteral,
        [Char]
"float"[Char] -> Type -> FieldType
>: Type
floatLiteral],

-- booleanLiteral
--     : BooleanLiteral
--     ;

      -- Use: booleanLiteral

-- dateLiteral
--     : 'datetime' LPAREN stringArgument RPAREN
--     | 'datetime' LPAREN RPAREN
--     ;

      [Char] -> Type -> Element
def [Char]
"DateLiteral" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ Type -> Type
optional Type
stringArgument,

-- nullLiteral
--     : NullLiteral
--     ;
--
-- nanLiteral
--     : NaNLiteral
--     ;
--
-- infLiteral
--     : SignedInfLiteral
--     ;
--
-- classType
--     : Identifier
--     ;

      -- Use: classType

-- variable
--     : Identifier
--     ;

      -- Use: variable

-- // need to complete this list to fix https://issues.apache.org/jira/browse/TINKERPOP-3047 but this much proves the
-- // approach works and allows the TraversalStrategy work to be complete.
-- keyword
--     : EDGES
--     | KEYS
--     | NEW
--     | VALUES
--     ;

      [Char] -> Type -> Element
def [Char]
"Keyword" (Type -> Element) -> Type -> Element
forall a b. (a -> b) -> a -> b
$ [[Char]] -> Type
enum [
        [Char]
"edges",
        [Char]
"keys",
        [Char]
"new",
        [Char]
"values"],

-- /*********************************************
--     LEXER RULES
-- **********************************************/
--
-- // Lexer rules
-- // These rules are extracted from Java ANTLRv4 Grammar.
-- // Source: https://github.com/antlr/grammars-v4/blob/master/java8/Java8.g4
--
-- // §3.9 Keywords
--
-- EDGES: 'edges';
-- KEYS: 'keys';
-- NEW : 'new';
-- VALUES: 'values';
--
-- // Integer Literals
--
-- IntegerLiteral
--     : Sign? DecimalIntegerLiteral
--     | Sign? HexIntegerLiteral
--     | Sign? OctalIntegerLiteral
--     ;
--
-- fragment
-- DecimalIntegerLiteral
--     : DecimalNumeral IntegerTypeSuffix?
--     ;
--
-- fragment
-- HexIntegerLiteral
--     : HexNumeral IntegerTypeSuffix?
--     ;
--
-- fragment
-- OctalIntegerLiteral
--     : OctalNumeral IntegerTypeSuffix?
--     ;
--
-- fragment
-- IntegerTypeSuffix
--     : [bBsSnNiIlL]
--     ;
--
-- fragment
-- DecimalNumeral
--     : '0'
--     | NonZeroDigit (Digits? | Underscores Digits)
--     ;
--
-- fragment
-- Digits
--     : Digit (DigitsAndUnderscores? Digit)?
--     ;
--
-- fragment
-- Digit
--     : '0'
--     | NonZeroDigit
--     ;
--
-- fragment
-- NonZeroDigit
--     : [1-9]
--     ;
--
-- fragment
-- DigitsAndUnderscores
--     : DigitOrUnderscore+
--     ;
--
-- fragment
-- DigitOrUnderscore
--     : Digit
--     | '_'
--     ;
--
-- fragment
-- Underscores
--     : '_'+
--     ;
--
-- fragment
-- HexNumeral
--     : '0' [xX] HexDigits
--     ;
--
-- fragment
-- HexDigits
--     : HexDigit (HexDigitsAndUnderscores? HexDigit)?
--     ;
--
-- fragment
-- HexDigit
--     : [0-9a-fA-F]
--     ;
--
-- fragment
-- HexDigitsAndUnderscores
--     : HexDigitOrUnderscore+
--     ;
--
-- fragment
-- HexDigitOrUnderscore
--     : HexDigit
--     | '_'
--     ;
--
-- fragment
-- OctalNumeral
--     : '0' Underscores? OctalDigits
--     ;
--
-- fragment
-- OctalDigits
--     : OctalDigit (OctalDigitsAndUnderscores? OctalDigit)?
--     ;
--
-- fragment
-- OctalDigit
--     : [0-7]
--     ;
--
-- fragment
-- OctalDigitsAndUnderscores
--     : OctalDigitOrUnderscore+
--     ;
--
-- fragment
-- OctalDigitOrUnderscore
--     : OctalDigit
--     | '_'
--     ;
--
-- // Floating-Point Literals
--
-- FloatingPointLiteral
--     : Sign? DecimalFloatingPointLiteral
--     ;
--
-- fragment
-- DecimalFloatingPointLiteral
--     : Digits ('.' Digits ExponentPart? | ExponentPart) FloatTypeSuffix?
--     | Digits FloatTypeSuffix
--     ;
--
-- fragment
-- ExponentPart
--     : ExponentIndicator SignedInteger
--     ;
--
-- fragment
-- ExponentIndicator
--     : [eE]
--     ;
--
-- fragment
-- SignedInteger
--     : Sign? Digits
--     ;
--
-- fragment
-- Sign
--     : [+-]
--     ;
--
-- fragment
-- FloatTypeSuffix
--     : [fFdDmM]
--     ;
--
-- // Boolean Literals
--
-- BooleanLiteral
--     : 'true'
--     | 'false'
--     ;
--
-- // Null Literal
--
-- NullLiteral
--     : 'null'
--     ;
--
-- // NaN Literal
--
-- NaNLiteral
--     : 'NaN'
--     ;
--
-- // Inf Literal
--
-- SignedInfLiteral
--     : Sign? InfLiteral
--     ;
--
-- InfLiteral
--     : 'Infinity'
--     ;
--
-- // String Literals
--
-- // String literal is customized since Java only allows double quoted strings where Groovy supports single quoted
-- // literals also. A side effect of this is ANTLR will not be able to parse single character string literals with
-- // single quoted so we instead remove char literal altogether and only have string literal in lexer tokens.
-- NonEmptyStringLiteral
--     : '"' DoubleQuotedStringCharacters '"'
--     | '\'' SingleQuotedStringCharacters '\''
--     ;
--
-- // We define NonEmptyStringLiteral and EmptyStringLiteral separately so that we can unambiguously handle empty queries
-- EmptyStringLiteral
--     : '""'
--     | '\'\''
--     ;
--
-- fragment
-- DoubleQuotedStringCharacters
--     : DoubleQuotedStringCharacter+
--     ;
--
-- fragment
-- DoubleQuotedStringCharacter
--     : ~('"' | '\\')
--     | JoinLineEscape
--     | EscapeSequence
--     ;
--
-- fragment
-- SingleQuotedStringCharacters
--     : SingleQuotedStringCharacter+
--     ;
--
-- fragment
-- SingleQuotedStringCharacter
--     : ~('\'' | '\\')
--     | JoinLineEscape
--     | EscapeSequence
--     ;
--
-- // Escape Sequences for Character and String Literals
-- fragment JoinLineEscape
--     : '\\' '\r'? '\n'
--     ;
--
-- fragment
-- EscapeSequence
--     : '\\' [btnfr"'\\]
--     | OctalEscape
--     | UnicodeEscape // This is not in the spec but prevents having to preprocess the input
--     ;
--
-- fragment
-- OctalEscape
--     : '\\' OctalDigit
--     | '\\' OctalDigit OctalDigit
--     | '\\' ZeroToThree OctalDigit OctalDigit
--     ;
--
-- fragment
-- ZeroToThree
--     : [0-3]
--     ;
--
-- // This is not in the spec but prevents having to preprocess the input
-- fragment
-- UnicodeEscape
--     :   '\\' 'u'+  HexDigit HexDigit HexDigit HexDigit
--     ;
--
-- // Separators
--
-- LPAREN : '(';
-- RPAREN : ')';
-- LBRACE : '{';
-- RBRACE : '}';
-- LBRACK : '[';
-- RBRACK : ']';
-- SEMI : ';';
-- COMMA : ',';
-- DOT : '.';
-- COLON : ':';
--
-- TRAVERSAL_ROOT:     'g';
-- ANON_TRAVERSAL_ROOT:     '__';
--
-- // Trim whitespace and comments if present
--
-- WS  :  [ \t\r\n\u000C]+ -> skip
--     ;
--
-- LINE_COMMENT
--     :   '//' ~[\r\n]* -> skip
--     ;
--
-- Identifier
--     : IdentifierStart IdentifierPart*
--     ;

      [Char] -> Type -> Element
def [Char]
"Identifier" Type
string]

-- // REFERENCE: https://github.com/antlr/grammars-v4/blob/master/java/java8/Java8Lexer.g4
-- fragment
-- IdentifierStart
--     : [\u0024]
--     | [\u0041-\u005A]
--     | [\u005F]
--     | [\u0061-\u007A]
--     | [\u00A2-\u00A5]
--     | [\u00AA]
--     | [\u00B5]
--     | [\u00BA]
--     | [\u00C0-\u00D6]
--     | [\u00D8-\u00F6]
--     | [\u00F8-\u02C1]
--     | [\u02C6-\u02D1]
--     | [\u02E0-\u02E4]
--     | [\u02EC]
--     | [\u02EE]
--     | [\u0370-\u0374]
--     | [\u0376-\u0377]
--     | [\u037A-\u037D]
--     | [\u037F]
--     | [\u0386]
--     | [\u0388-\u038A]
--     | [\u038C]
--     | [\u038E-\u03A1]
--     | [\u03A3-\u03F5]
--     | [\u03F7-\u0481]
--     | [\u048A-\u052F]
--     | [\u0531-\u0556]
--     | [\u0559]
--     | [\u0561-\u0587]
--     | [\u058F]
--     | [\u05D0-\u05EA]
--     | [\u05F0-\u05F2]
--     | [\u060B]
--     | [\u0620-\u064A]
--     | [\u066E-\u066F]
--     | [\u0671-\u06D3]
--     | [\u06D5]
--     | [\u06E5-\u06E6]
--     | [\u06EE-\u06EF]
--     | [\u06FA-\u06FC]
--     | [\u06FF]
--     | [\u0710]
--     | [\u0712-\u072F]
--     | [\u074D-\u07A5]
--     | [\u07B1]
--     | [\u07CA-\u07EA]
--     | [\u07F4-\u07F5]
--     | [\u07FA]
--     | [\u0800-\u0815]
--     | [\u081A]
--     | [\u0824]
--     | [\u0828]
--     | [\u0840-\u0858]
--     | [\u0860-\u086A]
--     | [\u08A0-\u08B4]
--     | [\u08B6-\u08BD]
--     | [\u0904-\u0939]
--     | [\u093D]
--     | [\u0950]
--     | [\u0958-\u0961]
--     | [\u0971-\u0980]
--     | [\u0985-\u098C]
--     | [\u098F-\u0990]
--     | [\u0993-\u09A8]
--     | [\u09AA-\u09B0]
--     | [\u09B2]
--     | [\u09B6-\u09B9]
--     | [\u09BD]
--     | [\u09CE]
--     | [\u09DC-\u09DD]
--     | [\u09DF-\u09E1]
--     | [\u09F0-\u09F3]
--     | [\u09FB-\u09FC]
--     | [\u0A05-\u0A0A]
--     | [\u0A0F-\u0A10]
--     | [\u0A13-\u0A28]
--     | [\u0A2A-\u0A30]
--     | [\u0A32-\u0A33]
--     | [\u0A35-\u0A36]
--     | [\u0A38-\u0A39]
--     | [\u0A59-\u0A5C]
--     | [\u0A5E]
--     | [\u0A72-\u0A74]
--     | [\u0A85-\u0A8D]
--     | [\u0A8F-\u0A91]
--     | [\u0A93-\u0AA8]
--     | [\u0AAA-\u0AB0]
--     | [\u0AB2-\u0AB3]
--     | [\u0AB5-\u0AB9]
--     | [\u0ABD]
--     | [\u0AD0]
--     | [\u0AE0-\u0AE1]
--     | [\u0AF1]
--     | [\u0AF9]
--     | [\u0B05-\u0B0C]
--     | [\u0B0F-\u0B10]
--     | [\u0B13-\u0B28]
--     | [\u0B2A-\u0B30]
--     | [\u0B32-\u0B33]
--     | [\u0B35-\u0B39]
--     | [\u0B3D]
--     | [\u0B5C-\u0B5D]
--     | [\u0B5F-\u0B61]
--     | [\u0B71]
--     | [\u0B83]
--     | [\u0B85-\u0B8A]
--     | [\u0B8E-\u0B90]
--     | [\u0B92-\u0B95]
--     | [\u0B99-\u0B9A]
--     | [\u0B9C]
--     | [\u0B9E-\u0B9F]
--     | [\u0BA3-\u0BA4]
--     | [\u0BA8-\u0BAA]
--     | [\u0BAE-\u0BB9]
--     | [\u0BD0]
--     | [\u0BF9]
--     | [\u0C05-\u0C0C]
--     | [\u0C0E-\u0C10]
--     | [\u0C12-\u0C28]
--     | [\u0C2A-\u0C39]
--     | [\u0C3D]
--     | [\u0C58-\u0C5A]
--     | [\u0C60-\u0C61]
--     | [\u0C80]
--     | [\u0C85-\u0C8C]
--     | [\u0C8E-\u0C90]
--     | [\u0C92-\u0CA8]
--     | [\u0CAA-\u0CB3]
--     | [\u0CB5-\u0CB9]
--     | [\u0CBD]
--     | [\u0CDE]
--     | [\u0CE0-\u0CE1]
--     | [\u0CF1-\u0CF2]
--     | [\u0D05-\u0D0C]
--     | [\u0D0E-\u0D10]
--     | [\u0D12-\u0D3A]
--     | [\u0D3D]
--     | [\u0D4E]
--     | [\u0D54-\u0D56]
--     | [\u0D5F-\u0D61]
--     | [\u0D7A-\u0D7F]
--     | [\u0D85-\u0D96]
--     | [\u0D9A-\u0DB1]
--     | [\u0DB3-\u0DBB]
--     | [\u0DBD]
--     | [\u0DC0-\u0DC6]
--     | [\u0E01-\u0E30]
--     | [\u0E32-\u0E33]
--     | [\u0E3F-\u0E46]
--     | [\u0E81-\u0E82]
--     | [\u0E84]
--     | [\u0E87-\u0E88]
--     | [\u0E8A]
--     | [\u0E8D]
--     | [\u0E94-\u0E97]
--     | [\u0E99-\u0E9F]
--     | [\u0EA1-\u0EA3]
--     | [\u0EA5]
--     | [\u0EA7]
--     | [\u0EAA-\u0EAB]
--     | [\u0EAD-\u0EB0]
--     | [\u0EB2-\u0EB3]
--     | [\u0EBD]
--     | [\u0EC0-\u0EC4]
--     | [\u0EC6]
--     | [\u0EDC-\u0EDF]
--     | [\u0F00]
--     | [\u0F40-\u0F47]
--     | [\u0F49-\u0F6C]
--     | [\u0F88-\u0F8C]
--     | [\u1000-\u102A]
--     | [\u103F]
--     | [\u1050-\u1055]
--     | [\u105A-\u105D]
--     | [\u1061]
--     | [\u1065-\u1066]
--     | [\u106E-\u1070]
--     | [\u1075-\u1081]
--     | [\u108E]
--     | [\u10A0-\u10C5]
--     | [\u10C7]
--     | [\u10CD]
--     | [\u10D0-\u10FA]
--     | [\u10FC-\u1248]
--     | [\u124A-\u124D]
--     | [\u1250-\u1256]
--     | [\u1258]
--     | [\u125A-\u125D]
--     | [\u1260-\u1288]
--     | [\u128A-\u128D]
--     | [\u1290-\u12B0]
--     | [\u12B2-\u12B5]
--     | [\u12B8-\u12BE]
--     | [\u12C0]
--     | [\u12C2-\u12C5]
--     | [\u12C8-\u12D6]
--     | [\u12D8-\u1310]
--     | [\u1312-\u1315]
--     | [\u1318-\u135A]
--     | [\u1380-\u138F]
--     | [\u13A0-\u13F5]
--     | [\u13F8-\u13FD]
--     | [\u1401-\u166C]
--     | [\u166F-\u167F]
--     | [\u1681-\u169A]
--     | [\u16A0-\u16EA]
--     | [\u16EE-\u16F8]
--     | [\u1700-\u170C]
--     | [\u170E-\u1711]
--     | [\u1720-\u1731]
--     | [\u1740-\u1751]
--     | [\u1760-\u176C]
--     | [\u176E-\u1770]
--     | [\u1780-\u17B3]
--     | [\u17D7]
--     | [\u17DB-\u17DC]
--     | [\u1820-\u1877]
--     | [\u1880-\u1884]
--     | [\u1887-\u18A8]
--     | [\u18AA]
--     | [\u18B0-\u18F5]
--     | [\u1900-\u191E]
--     | [\u1950-\u196D]
--     | [\u1970-\u1974]
--     | [\u1980-\u19AB]
--     | [\u19B0-\u19C9]
--     | [\u1A00-\u1A16]
--     | [\u1A20-\u1A54]
--     | [\u1AA7]
--     | [\u1B05-\u1B33]
--     | [\u1B45-\u1B4B]
--     | [\u1B83-\u1BA0]
--     | [\u1BAE-\u1BAF]
--     | [\u1BBA-\u1BE5]
--     | [\u1C00-\u1C23]
--     | [\u1C4D-\u1C4F]
--     | [\u1C5A-\u1C7D]
--     | [\u1C80-\u1C88]
--     | [\u1CE9-\u1CEC]
--     | [\u1CEE-\u1CF1]
--     | [\u1CF5-\u1CF6]
--     | [\u1D00-\u1DBF]
--     | [\u1E00-\u1F15]
--     | [\u1F18-\u1F1D]
--     | [\u1F20-\u1F45]
--     | [\u1F48-\u1F4D]
--     | [\u1F50-\u1F57]
--     | [\u1F59]
--     | [\u1F5B]
--     | [\u1F5D]
--     | [\u1F5F-\u1F7D]
--     | [\u1F80-\u1FB4]
--     | [\u1FB6-\u1FBC]
--     | [\u1FBE]
--     | [\u1FC2-\u1FC4]
--     | [\u1FC6-\u1FCC]
--     | [\u1FD0-\u1FD3]
--     | [\u1FD6-\u1FDB]
--     | [\u1FE0-\u1FEC]
--     | [\u1FF2-\u1FF4]
--     | [\u1FF6-\u1FFC]
--     | [\u203F-\u2040]
--     | [\u2054]
--     | [\u2071]
--     | [\u207F]
--     | [\u2090-\u209C]
--     | [\u20A0-\u20BF]
--     | [\u2102]
--     | [\u2107]
--     | [\u210A-\u2113]
--     | [\u2115]
--     | [\u2119-\u211D]
--     | [\u2124]
--     | [\u2126]
--     | [\u2128]
--     | [\u212A-\u212D]
--     | [\u212F-\u2139]
--     | [\u213C-\u213F]
--     | [\u2145-\u2149]
--     | [\u214E]
--     | [\u2160-\u2188]
--     | [\u2C00-\u2C2E]
--     | [\u2C30-\u2C5E]
--     | [\u2C60-\u2CE4]
--     | [\u2CEB-\u2CEE]
--     | [\u2CF2-\u2CF3]
--     | [\u2D00-\u2D25]
--     | [\u2D27]
--     | [\u2D2D]
--     | [\u2D30-\u2D67]
--     | [\u2D6F]
--     | [\u2D80-\u2D96]
--     | [\u2DA0-\u2DA6]
--     | [\u2DA8-\u2DAE]
--     | [\u2DB0-\u2DB6]
--     | [\u2DB8-\u2DBE]
--     | [\u2DC0-\u2DC6]
--     | [\u2DC8-\u2DCE]
--     | [\u2DD0-\u2DD6]
--     | [\u2DD8-\u2DDE]
--     | [\u2E2F]
--     | [\u3005-\u3007]
--     | [\u3021-\u3029]
--     | [\u3031-\u3035]
--     | [\u3038-\u303C]
--     | [\u3041-\u3096]
--     | [\u309D-\u309F]
--     | [\u30A1-\u30FA]
--     | [\u30FC-\u30FF]
--     | [\u3105-\u312E]
--     | [\u3131-\u318E]
--     | [\u31A0-\u31BA]
--     | [\u31F0-\u31FF]
--     | [\u3400-\u4DB5]
--     | [\u4E00-\u9FEA]
--     | [\uA000-\uA48C]
--     | [\uA4D0-\uA4FD]
--     | [\uA500-\uA60C]
--     | [\uA610-\uA61F]
--     | [\uA62A-\uA62B]
--     | [\uA640-\uA66E]
--     | [\uA67F-\uA69D]
--     | [\uA6A0-\uA6EF]
--     | [\uA717-\uA71F]
--     | [\uA722-\uA788]
--     | [\uA78B-\uA7AE]
--     | [\uA7B0-\uA7B7]
--     | [\uA7F7-\uA801]
--     | [\uA803-\uA805]
--     | [\uA807-\uA80A]
--     | [\uA80C-\uA822]
--     | [\uA838]
--     | [\uA840-\uA873]
--     | [\uA882-\uA8B3]
--     | [\uA8F2-\uA8F7]
--     | [\uA8FB]
--     | [\uA8FD]
--     | [\uA90A-\uA925]
--     | [\uA930-\uA946]
--     | [\uA960-\uA97C]
--     | [\uA984-\uA9B2]
--     | [\uA9CF]
--     | [\uA9E0-\uA9E4]
--     | [\uA9E6-\uA9EF]
--     | [\uA9FA-\uA9FE]
--     | [\uAA00-\uAA28]
--     | [\uAA40-\uAA42]
--     | [\uAA44-\uAA4B]
--     | [\uAA60-\uAA76]
--     | [\uAA7A]
--     | [\uAA7E-\uAAAF]
--     | [\uAAB1]
--     | [\uAAB5-\uAAB6]
--     | [\uAAB9-\uAABD]
--     | [\uAAC0]
--     | [\uAAC2]
--     | [\uAADB-\uAADD]
--     | [\uAAE0-\uAAEA]
--     | [\uAAF2-\uAAF4]
--     | [\uAB01-\uAB06]
--     | [\uAB09-\uAB0E]
--     | [\uAB11-\uAB16]
--     | [\uAB20-\uAB26]
--     | [\uAB28-\uAB2E]
--     | [\uAB30-\uAB5A]
--     | [\uAB5C-\uAB65]
--     | [\uAB70-\uABE2]
--     | [\uAC00-\uD7A3]
--     | [\uD7B0-\uD7C6]
--     | [\uD7CB-\uD7FB]
--     | [\uF900-\uFA6D]
--     | [\uFA70-\uFAD9]
--     | [\uFB00-\uFB06]
--     | [\uFB13-\uFB17]
--     | [\uFB1D]
--     | [\uFB1F-\uFB28]
--     | [\uFB2A-\uFB36]
--     | [\uFB38-\uFB3C]
--     | [\uFB3E]
--     | [\uFB40-\uFB41]
--     | [\uFB43-\uFB44]
--     | [\uFB46-\uFBB1]
--     | [\uFBD3-\uFD3D]
--     | [\uFD50-\uFD8F]
--     | [\uFD92-\uFDC7]
--     | [\uFDF0-\uFDFC]
--     | [\uFE33-\uFE34]
--     | [\uFE4D-\uFE4F]
--     | [\uFE69]
--     | [\uFE70-\uFE74]
--     | [\uFE76-\uFEFC]
--     | [\uFF04]
--     | [\uFF21-\uFF3A]
--     | [\uFF3F]
--     | [\uFF41-\uFF5A]
--     | [\uFF66-\uFFBE]
--     | [\uFFC2-\uFFC7]
--     | [\uFFCA-\uFFCF]
--     | [\uFFD2-\uFFD7]
--     | [\uFFDA-\uFFDC]
--     | [\uFFE0-\uFFE1]
--     | [\uFFE5-\uFFE6]
--     ;
--
-- fragment
-- IdentifierPart
--     : IdentifierStart
--     | [\u0030-\u0039]
--     | [\u007F-\u009F]
--     | [\u00AD]
--     | [\u0300-\u036F]
--     | [\u0483-\u0487]
--     | [\u0591-\u05BD]
--     | [\u05BF]
--     | [\u05C1-\u05C2]
--     | [\u05C4-\u05C5]
--     | [\u05C7]
--     | [\u0600-\u0605]
--     | [\u0610-\u061A]
--     | [\u061C]
--     | [\u064B-\u0669]
--     | [\u0670]
--     | [\u06D6-\u06DD]
--     | [\u06DF-\u06E4]
--     | [\u06E7-\u06E8]
--     | [\u06EA-\u06ED]
--     | [\u06F0-\u06F9]
--     | [\u070F]
--     | [\u0711]
--     | [\u0730-\u074A]
--     | [\u07A6-\u07B0]
--     | [\u07C0-\u07C9]
--     | [\u07EB-\u07F3]
--     | [\u0816-\u0819]
--     | [\u081B-\u0823]
--     | [\u0825-\u0827]
--     | [\u0829-\u082D]
--     | [\u0859-\u085B]
--     | [\u08D4-\u0903]
--     | [\u093A-\u093C]
--     | [\u093E-\u094F]
--     | [\u0951-\u0957]
--     | [\u0962-\u0963]
--     | [\u0966-\u096F]
--     | [\u0981-\u0983]
--     | [\u09BC]
--     | [\u09BE-\u09C4]
--     | [\u09C7-\u09C8]
--     | [\u09CB-\u09CD]
--     | [\u09D7]
--     | [\u09E2-\u09E3]
--     | [\u09E6-\u09EF]
--     | [\u0A01-\u0A03]
--     | [\u0A3C]
--     | [\u0A3E-\u0A42]
--     | [\u0A47-\u0A48]
--     | [\u0A4B-\u0A4D]
--     | [\u0A51]
--     | [\u0A66-\u0A71]
--     | [\u0A75]
--     | [\u0A81-\u0A83]
--     | [\u0ABC]
--     | [\u0ABE-\u0AC5]
--     | [\u0AC7-\u0AC9]
--     | [\u0ACB-\u0ACD]
--     | [\u0AE2-\u0AE3]
--     | [\u0AE6-\u0AEF]
--     | [\u0AFA-\u0AFF]
--     | [\u0B01-\u0B03]
--     | [\u0B3C]
--     | [\u0B3E-\u0B44]
--     | [\u0B47-\u0B48]
--     | [\u0B4B-\u0B4D]
--     | [\u0B56-\u0B57]
--     | [\u0B62-\u0B63]
--     | [\u0B66-\u0B6F]
--     | [\u0B82]
--     | [\u0BBE-\u0BC2]
--     | [\u0BC6-\u0BC8]
--     | [\u0BCA-\u0BCD]
--     | [\u0BD7]
--     | [\u0BE6-\u0BEF]
--     | [\u0C00-\u0C03]
--     | [\u0C3E-\u0C44]
--     | [\u0C46-\u0C48]
--     | [\u0C4A-\u0C4D]
--     | [\u0C55-\u0C56]
--     | [\u0C62-\u0C63]
--     | [\u0C66-\u0C6F]
--     | [\u0C81-\u0C83]
--     | [\u0CBC]
--     | [\u0CBE-\u0CC4]
--     | [\u0CC6-\u0CC8]
--     | [\u0CCA-\u0CCD]
--     | [\u0CD5-\u0CD6]
--     | [\u0CE2-\u0CE3]
--     | [\u0CE6-\u0CEF]
--     | [\u0D00-\u0D03]
--     | [\u0D3B-\u0D3C]
--     | [\u0D3E-\u0D44]
--     | [\u0D46-\u0D48]
--     | [\u0D4A-\u0D4D]
--     | [\u0D57]
--     | [\u0D62-\u0D63]
--     | [\u0D66-\u0D6F]
--     | [\u0D82-\u0D83]
--     | [\u0DCA]
--     | [\u0DCF-\u0DD4]
--     | [\u0DD6]
--     | [\u0DD8-\u0DDF]
--     | [\u0DE6-\u0DEF]
--     | [\u0DF2-\u0DF3]
--     | [\u0E31]
--     | [\u0E34-\u0E3A]
--     | [\u0E47-\u0E4E]
--     | [\u0E50-\u0E59]
--     | [\u0EB1]
--     | [\u0EB4-\u0EB9]
--     | [\u0EBB-\u0EBC]
--     | [\u0EC8-\u0ECD]
--     | [\u0ED0-\u0ED9]
--     | [\u0F18-\u0F19]
--     | [\u0F20-\u0F29]
--     | [\u0F35]
--     | [\u0F37]
--     | [\u0F39]
--     | [\u0F3E-\u0F3F]
--     | [\u0F71-\u0F84]
--     | [\u0F86-\u0F87]
--     | [\u0F8D-\u0F97]
--     | [\u0F99-\u0FBC]
--     | [\u0FC6]
--     | [\u102B-\u103E]
--     | [\u1040-\u1049]
--     | [\u1056-\u1059]
--     | [\u105E-\u1060]
--     | [\u1062-\u1064]
--     | [\u1067-\u106D]
--     | [\u1071-\u1074]
--     | [\u1082-\u108D]
--     | [\u108F-\u109D]
--     | [\u135D-\u135F]
--     | [\u1712-\u1714]
--     | [\u1732-\u1734]
--     | [\u1752-\u1753]
--     | [\u1772-\u1773]
--     | [\u17B4-\u17D3]
--     | [\u17DD]
--     | [\u17E0-\u17E9]
--     | [\u180B-\u180E]
--     | [\u1810-\u1819]
--     | [\u1885-\u1886]
--     | [\u18A9]
--     | [\u1920-\u192B]
--     | [\u1930-\u193B]
--     | [\u1946-\u194F]
--     | [\u19D0-\u19D9]
--     | [\u1A17-\u1A1B]
--     | [\u1A55-\u1A5E]
--     | [\u1A60-\u1A7C]
--     | [\u1A7F-\u1A89]
--     | [\u1A90-\u1A99]
--     | [\u1AB0-\u1ABD]
--     | [\u1B00-\u1B04]
--     | [\u1B34-\u1B44]
--     | [\u1B50-\u1B59]
--     | [\u1B6B-\u1B73]
--     | [\u1B80-\u1B82]
--     | [\u1BA1-\u1BAD]
--     | [\u1BB0-\u1BB9]
--     | [\u1BE6-\u1BF3]
--     | [\u1C24-\u1C37]
--     | [\u1C40-\u1C49]
--     | [\u1C50-\u1C59]
--     | [\u1CD0-\u1CD2]
--     | [\u1CD4-\u1CE8]
--     | [\u1CED]
--     | [\u1CF2-\u1CF4]
--     | [\u1CF7-\u1CF9]
--     | [\u1DC0-\u1DF9]
--     | [\u1DFB-\u1DFF]
--     | [\u200B-\u200F]
--     | [\u202A-\u202E]
--     | [\u2060-\u2064]
--     | [\u2066-\u206F]
--     | [\u20D0-\u20DC]
--     | [\u20E1]
--     | [\u20E5-\u20F0]
--     | [\u2CEF-\u2CF1]
--     | [\u2D7F]
--     | [\u2DE0-\u2DFF]
--     | [\u302A-\u302F]
--     | [\u3099-\u309A]
--     | [\uA620-\uA629]
--     | [\uA66F]
--     | [\uA674-\uA67D]
--     | [\uA69E-\uA69F]
--     | [\uA6F0-\uA6F1]
--     | [\uA802]
--     | [\uA806]
--     | [\uA80B]
--     | [\uA823-\uA827]
--     | [\uA880-\uA881]
--     | [\uA8B4-\uA8C5]
--     | [\uA8D0-\uA8D9]
--     | [\uA8E0-\uA8F1]
--     | [\uA900-\uA909]
--     | [\uA926-\uA92D]
--     | [\uA947-\uA953]
--     | [\uA980-\uA983]
--     | [\uA9B3-\uA9C0]
--     | [\uA9D0-\uA9D9]
--     | [\uA9E5]
--     | [\uA9F0-\uA9F9]
--     | [\uAA29-\uAA36]
--     | [\uAA43]
--     | [\uAA4C-\uAA4D]
--     | [\uAA50-\uAA59]
--     | [\uAA7B-\uAA7D]
--     | [\uAAB0]
--     | [\uAAB2-\uAAB4]
--     | [\uAAB7-\uAAB8]
--     | [\uAABE-\uAABF]
--     | [\uAAC1]
--     | [\uAAEB-\uAAEF]
--     | [\uAAF5-\uAAF6]
--     | [\uABE3-\uABEA]
--     | [\uABEC-\uABED]
--     | [\uABF0-\uABF9]
--     | [\uFB1E]
--     | [\uFE00-\uFE0F]
--     | [\uFE20-\uFE2F]
--     | [\uFEFF]
--     | [\uFF10-\uFF19]
--     | [\uFFF9-\uFFFB]
--     ;